Merge lp:~henninge/launchpad/devel-710591-sharing-info-groundwork-0 into lp:launchpad
- devel-710591-sharing-info-groundwork-0
- Merge into devel
Proposed by
Henning Eggers
| Status: | Merged |
|---|---|
| Approved by: | Henning Eggers |
| Approved revision: | no longer in the source branch. |
| Merged at revision: | 12320 |
| Proposed branch: | lp:~henninge/launchpad/devel-710591-sharing-info-groundwork-0 |
| Merge into: | lp:launchpad |
| Diff against target: |
504 lines (+487/-0) 3 files modified
.bzrignore (+1/-0) lib/lp/translations/utilities/tests/test_translation_sharing_info.py (+310/-0) lib/lp/translations/utilities/translationsharinginfo.py (+176/-0) |
| To merge this branch: | bzr merge lp:~henninge/launchpad/devel-710591-sharing-info-groundwork-0 |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Deryck Hodge (community) | code | Approve | |
|
Review via email:
|
|||
Commit message
[r=deryck]
Description of the change
= Summary =
For the current feature work but also to fix bug 710591, the information
about sharing template on the other side must be easily available. This
branch provides this informatioon through a couple of functions.
== Proposed fix ==
Provide functions that list information about the current sharing
information on the other side. "Other side" is an upstream product series
for a source package and an Ubuntu sourcepackage for a product series.
Translation sharing only happens when a template of the same name as the one
on this side exists but before that a packaging link is required. These
functions list both the content of the packaging link and any templates on
the other side, if any.
== Pre-implementation notes ==
I did not really consult anybody about this particular module although the
necessity for this functionality has been discussed.
== Implementation details ==
I had first considered creating an adapter on productseries and source
package but decided against it and chose the simpler approach. Since there
is no state information or anything, functions do the job just as well.
The find_* functions are meant to be internal functions that return Storm
ResultSets and the get_* and has_* functions make use of this. It may still
make sense to put the find_* functions into __all__, though.
== Tests ==
bin/test -vvcm lp.translations
== Demo and Q/A ==
None.
= Launchpad lint =
Checking for conflicts and issues in changed files.
Linting changed files:
.bzrignore
lib/lp/
lib/lp/
To post a comment you must log in.
Revision history for this message
| Henning Eggers (henninge) wrote : | # |
Thanks for the review. Please find my added comments below.
| 1 | === modified file 'lib/lp/translations/utilities/tests/test_translation_sharing_info.py' | |||
| 2 | --- lib/lp/translations/utilities/tests/test_translation_sharing_info.py 2011-02-03 01:13:32 +0000 | |||
| 3 | +++ lib/lp/translations/utilities/tests/test_translation_sharing_info.py 2011-02-03 18:18:29 +0000 | |||
| 4 | @@ -1,8 +1,6 @@ | |||
| 5 | 1 | # Copyright 2009 Canonical Ltd. This software is licensed under the | 1 | # Copyright 2009 Canonical Ltd. This software is licensed under the |
| 6 | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). |
| 7 | 3 | 3 | ||
| 8 | 4 | # pylint: disable-msg=C0102 | ||
| 9 | 5 | |||
| 10 | 6 | __metaclass__ = type | 4 | __metaclass__ = type |
| 11 | 7 | 5 | ||
| 12 | 8 | from canonical.testing.layers import ZopelessDatabaseLayer | 6 | from canonical.testing.layers import ZopelessDatabaseLayer |
| 13 | @@ -219,6 +217,8 @@ | |||
| 14 | 219 | templatename=different_templatename)) | 217 | templatename=different_templatename)) |
| 15 | 220 | 218 | ||
| 16 | 221 | def test_has_upstream_template_no_productseries(self): | 219 | def test_has_upstream_template_no_productseries(self): |
| 17 | 220 | # Without an upstream project, no upstream templates won't be | ||
| 18 | 221 | # available either. | ||
| 19 | 222 | distroseries, sourcepackagename = self._makeSourcePackage() | 222 | distroseries, sourcepackagename = self._makeSourcePackage() |
| 20 | 223 | templatename = self.factory.getUniqueString() | 223 | templatename = self.factory.getUniqueString() |
| 21 | 224 | 224 | ||
| 22 | @@ -227,6 +227,7 @@ | |||
| 23 | 227 | distroseries, sourcepackagename, templatename)) | 227 | distroseries, sourcepackagename, templatename)) |
| 24 | 228 | 228 | ||
| 25 | 229 | def test_has_upstream_template_no_template(self): | 229 | def test_has_upstream_template_no_template(self): |
| 26 | 230 | # No template exists on the upstream project. | ||
| 27 | 230 | distroseries, sourcepackagename = self._makeSourcePackage() | 231 | distroseries, sourcepackagename = self._makeSourcePackage() |
| 28 | 231 | productseries = self._makeUpstreamProductSeries( | 232 | productseries = self._makeUpstreamProductSeries( |
| 29 | 232 | distroseries, sourcepackagename) | 233 | distroseries, sourcepackagename) |
| 30 | @@ -237,6 +238,8 @@ | |||
| 31 | 237 | distroseries, sourcepackagename, templatename)) | 238 | distroseries, sourcepackagename, templatename)) |
| 32 | 238 | 239 | ||
| 33 | 239 | def test_has_upstream_template_one_template(self): | 240 | def test_has_upstream_template_one_template(self): |
| 34 | 241 | # There is one template on the upstream project that matches the | ||
| 35 | 242 | # name. | ||
| 36 | 240 | distroseries, sourcepackagename = self._makeSourcePackage() | 243 | distroseries, sourcepackagename = self._makeSourcePackage() |
| 37 | 241 | productseries = self._makeUpstreamProductSeries( | 244 | productseries = self._makeUpstreamProductSeries( |
| 38 | 242 | distroseries, sourcepackagename) | 245 | distroseries, sourcepackagename) |
| 39 | @@ -249,6 +252,8 @@ | |||
| 40 | 249 | distroseries, sourcepackagename, templatename)) | 252 | distroseries, sourcepackagename, templatename)) |
| 41 | 250 | 253 | ||
| 42 | 251 | def test_has_upstream_template_one_template_wrong_name(self): | 254 | def test_has_upstream_template_one_template_wrong_name(self): |
| 43 | 255 | # There is one template on the upstream project but it matches not | ||
| 44 | 256 | # the requested name. | ||
| 45 | 252 | distroseries, sourcepackagename = self._makeSourcePackage() | 257 | distroseries, sourcepackagename = self._makeSourcePackage() |
| 46 | 253 | productseries = self._makeUpstreamProductSeries( | 258 | productseries = self._makeUpstreamProductSeries( |
| 47 | 254 | distroseries, sourcepackagename) | 259 | distroseries, sourcepackagename) |
| 48 | @@ -260,12 +265,15 @@ | |||
| 49 | 260 | distroseries, sourcepackagename, different_templatename)) | 265 | distroseries, sourcepackagename, different_templatename)) |
| 50 | 261 | 266 | ||
| 51 | 262 | def test_has_ubuntu_template_no_sourcepackage(self): | 267 | def test_has_ubuntu_template_no_sourcepackage(self): |
| 52 | 268 | # There is no Ubuntu source package, so no Ubuntu template can be | ||
| 53 | 269 | # found. | ||
| 54 | 263 | productseries = self.factory.makeProductSeries() | 270 | productseries = self.factory.makeProductSeries() |
| 55 | 264 | templatename = self.factory.getUniqueString() | 271 | templatename = self.factory.getUniqueString() |
| 56 | 265 | 272 | ||
| 57 | 266 | self.assertFalse(has_ubuntu_template(productseries, templatename)) | 273 | self.assertFalse(has_ubuntu_template(productseries, templatename)) |
| 58 | 267 | 274 | ||
| 59 | 268 | def test_has_ubuntu_template_no_template(self): | 275 | def test_has_ubuntu_template_no_template(self): |
| 60 | 276 | # The Ubuntu source package has no template. | ||
| 61 | 269 | distroseries, sourcepackagename = self._makeSourcePackage() | 277 | distroseries, sourcepackagename = self._makeSourcePackage() |
| 62 | 270 | productseries = self._makeUpstreamProductSeries( | 278 | productseries = self._makeUpstreamProductSeries( |
| 63 | 271 | distroseries, sourcepackagename) | 279 | distroseries, sourcepackagename) |
| 64 | @@ -274,6 +282,8 @@ | |||
| 65 | 274 | self.assertFalse(has_ubuntu_template(productseries, templatename)) | 282 | self.assertFalse(has_ubuntu_template(productseries, templatename)) |
| 66 | 275 | 283 | ||
| 67 | 276 | def test_has_ubuntu_template_one_template(self): | 284 | def test_has_ubuntu_template_one_template(self): |
| 68 | 285 | # There is one template on the Ubuntu source package that matches | ||
| 69 | 286 | # the name. | ||
| 70 | 277 | distroseries, sourcepackagename = self._makeSourcePackage() | 287 | distroseries, sourcepackagename = self._makeSourcePackage() |
| 71 | 278 | productseries = self._makeUpstreamProductSeries( | 288 | productseries = self._makeUpstreamProductSeries( |
| 72 | 279 | distroseries, sourcepackagename) | 289 | distroseries, sourcepackagename) |
| 73 | @@ -285,6 +295,8 @@ | |||
| 74 | 285 | self.assertTrue(has_ubuntu_template(productseries, templatename)) | 295 | self.assertTrue(has_ubuntu_template(productseries, templatename)) |
| 75 | 286 | 296 | ||
| 76 | 287 | def test_has_ubuntu_template_one_template_wrong_name(self): | 297 | def test_has_ubuntu_template_one_template_wrong_name(self): |
| 77 | 298 | # There is one template on the Ubuntu source package but it matches | ||
| 78 | 299 | # not the requested name. | ||
| 79 | 288 | distroseries, sourcepackagename = self._makeSourcePackage() | 300 | distroseries, sourcepackagename = self._makeSourcePackage() |
| 80 | 289 | productseries = self._makeUpstreamProductSeries( | 301 | productseries = self._makeUpstreamProductSeries( |
| 81 | 290 | distroseries, sourcepackagename) | 302 | distroseries, sourcepackagename) |
| 82 | 291 | 303 | ||
| 83 | === modified file 'lib/lp/translations/utilities/translationsharinginfo.py' | |||
| 84 | --- lib/lp/translations/utilities/translationsharinginfo.py 2011-02-03 01:13:32 +0000 | |||
| 85 | +++ lib/lp/translations/utilities/translationsharinginfo.py 2011-02-03 18:35:28 +0000 | |||
| 86 | @@ -1,7 +1,23 @@ | |||
| 87 | 1 | # Copyright 2011 Canonical Ltd. This software is licensed under the | 1 | # Copyright 2011 Canonical Ltd. This software is licensed under the |
| 88 | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). |
| 89 | 3 | 3 | ||
| 91 | 4 | """Provide sharing information.""" | 4 | """Provide sharing information. |
| 92 | 5 | |||
| 93 | 6 | This module defines two different types of functions that provide | ||
| 94 | 7 | information about what sharing options are available on the other side of a | ||
| 95 | 8 | packaging link. Since they perform similar but slightly different complex | ||
| 96 | 9 | database queries combining them in any way will usually be wrong. | ||
| 97 | 10 | |||
| 98 | 11 | get_ubuntu_sharing_info and get_upstream_sharing_info will give you | ||
| 99 | 12 | information about the source package or productseries respectively, | ||
| 100 | 13 | combined with possibly available templates. You can restrict the search | ||
| 101 | 14 | by specifying a template name. | ||
| 102 | 15 | |||
| 103 | 16 | has_ubuntu_template and has_upstream_template make a direct search for a | ||
| 104 | 17 | template of the given name on the other side. They do not search for | ||
| 105 | 18 | source package or productseries but will only return True if an actual | ||
| 106 | 19 | template exists. That is a significant difference to the get_* functions. | ||
| 107 | 20 | """ | ||
| 108 | 5 | 21 | ||
| 109 | 6 | __metaclass__ = type | 22 | __metaclass__ = type |
| 110 | 7 | __all__ = [ | 23 | __all__ = [ |
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file '.bzrignore' | |||
| 2 | --- .bzrignore 2011-01-16 19:04:25 +0000 | |||
| 3 | +++ .bzrignore 2011-02-03 18:46:24 +0000 | |||
| 4 | @@ -76,3 +76,4 @@ | |||
| 5 | 76 | librarian.log | 76 | librarian.log |
| 6 | 77 | configs/testrunner_* | 77 | configs/testrunner_* |
| 7 | 78 | configs/testrunner-appserver_* | 78 | configs/testrunner-appserver_* |
| 8 | 79 | .idea | ||
| 9 | 79 | 80 | ||
| 10 | === added file 'lib/lp/translations/utilities/tests/test_translation_sharing_info.py' | |||
| 11 | --- lib/lp/translations/utilities/tests/test_translation_sharing_info.py 1970-01-01 00:00:00 +0000 | |||
| 12 | +++ lib/lp/translations/utilities/tests/test_translation_sharing_info.py 2011-02-03 18:46:24 +0000 | |||
| 13 | @@ -0,0 +1,310 @@ | |||
| 14 | 1 | # Copyright 2009 Canonical Ltd. This software is licensed under the | ||
| 15 | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). | ||
| 16 | 3 | |||
| 17 | 4 | __metaclass__ = type | ||
| 18 | 5 | |||
| 19 | 6 | from canonical.testing.layers import ZopelessDatabaseLayer | ||
| 20 | 7 | from lp.testing import TestCaseWithFactory | ||
| 21 | 8 | from lp.translations.utilities.translationsharinginfo import ( | ||
| 22 | 9 | get_ubuntu_sharing_info, | ||
| 23 | 10 | get_upstream_sharing_info, | ||
| 24 | 11 | has_ubuntu_template, | ||
| 25 | 12 | has_upstream_template, | ||
| 26 | 13 | ) | ||
| 27 | 14 | |||
| 28 | 15 | |||
| 29 | 16 | class TestTranslationSharingInfo(TestCaseWithFactory): | ||
| 30 | 17 | """Tests for `get_upstream_sharing_info` and `get_ubuntu_sharing_info`""" | ||
| 31 | 18 | |||
| 32 | 19 | layer = ZopelessDatabaseLayer | ||
| 33 | 20 | |||
| 34 | 21 | def _makeSourcePackage(self): | ||
| 35 | 22 | """Create a distroseries and a sourcepackagename.""" | ||
| 36 | 23 | distroseries = self.factory.makeUbuntuDistroSeries() | ||
| 37 | 24 | sourcepackagename = self.factory.makeSourcePackageName() | ||
| 38 | 25 | return (distroseries, sourcepackagename) | ||
| 39 | 26 | |||
| 40 | 27 | def _makeUpstreamProductSeries(self, distroseries, sourcepackagename): | ||
| 41 | 28 | """Create a product series and link it to the source package.""" | ||
| 42 | 29 | productseries = self.factory.makeProductSeries() | ||
| 43 | 30 | sourcepackage = self.factory.makeSourcePackage( | ||
| 44 | 31 | sourcepackagename, distroseries) | ||
| 45 | 32 | owner = self.factory.makePerson() | ||
| 46 | 33 | sourcepackage.setPackaging(productseries, owner) | ||
| 47 | 34 | return productseries | ||
| 48 | 35 | |||
| 49 | 36 | def test_no_upstream(self): | ||
| 50 | 37 | # With no upstream the sharing information on a source package will | ||
| 51 | 38 | # be empty. | ||
| 52 | 39 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 53 | 40 | self.assertEquals( | ||
| 54 | 41 | [], | ||
| 55 | 42 | get_upstream_sharing_info( | ||
| 56 | 43 | distroseries=distroseries, | ||
| 57 | 44 | sourcepackagename=sourcepackagename)) | ||
| 58 | 45 | |||
| 59 | 46 | def test_no_upstream_with_name(self): | ||
| 60 | 47 | # With no upstream the sharing information on a source package will | ||
| 61 | 48 | # be empty, even when searching for a specific template name. | ||
| 62 | 49 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 63 | 50 | templatename = self.factory.getUniqueString() | ||
| 64 | 51 | self.assertEquals( | ||
| 65 | 52 | [], | ||
| 66 | 53 | get_upstream_sharing_info( | ||
| 67 | 54 | distroseries=distroseries, | ||
| 68 | 55 | sourcepackagename=sourcepackagename, | ||
| 69 | 56 | templatename=templatename)) | ||
| 70 | 57 | |||
| 71 | 58 | def test_upstream_no_template(self): | ||
| 72 | 59 | # With an upstream without a template the sharing information on a | ||
| 73 | 60 | # source package will be empty. | ||
| 74 | 61 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 75 | 62 | productseries = self._makeUpstreamProductSeries( | ||
| 76 | 63 | distroseries, sourcepackagename) | ||
| 77 | 64 | self.assertEquals( | ||
| 78 | 65 | [(productseries, None)], | ||
| 79 | 66 | get_upstream_sharing_info( | ||
| 80 | 67 | distroseries=distroseries, | ||
| 81 | 68 | sourcepackagename=sourcepackagename)) | ||
| 82 | 69 | |||
| 83 | 70 | def test_upstream_no_template_with_name(self): | ||
| 84 | 71 | # With an upstream without a template the sharing information on a | ||
| 85 | 72 | # source package will be empty, even when searching for a specific | ||
| 86 | 73 | # template name. | ||
| 87 | 74 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 88 | 75 | productseries = self._makeUpstreamProductSeries( | ||
| 89 | 76 | distroseries, sourcepackagename) | ||
| 90 | 77 | templatename = self.factory.getUniqueString() | ||
| 91 | 78 | self.assertEquals( | ||
| 92 | 79 | [(productseries, None)], | ||
| 93 | 80 | get_upstream_sharing_info( | ||
| 94 | 81 | distroseries=distroseries, | ||
| 95 | 82 | sourcepackagename=sourcepackagename, | ||
| 96 | 83 | templatename=templatename)) | ||
| 97 | 84 | |||
| 98 | 85 | def test_upstream_one_template(self): | ||
| 99 | 86 | # With an upstream template the sharing information on a | ||
| 100 | 87 | # source package will return that. | ||
| 101 | 88 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 102 | 89 | productseries = self._makeUpstreamProductSeries( | ||
| 103 | 90 | distroseries, sourcepackagename) | ||
| 104 | 91 | potemplate = self.factory.makePOTemplate(productseries=productseries) | ||
| 105 | 92 | self.assertEquals( | ||
| 106 | 93 | [(productseries, potemplate)], | ||
| 107 | 94 | get_upstream_sharing_info( | ||
| 108 | 95 | distroseries=distroseries, | ||
| 109 | 96 | sourcepackagename=sourcepackagename)) | ||
| 110 | 97 | |||
| 111 | 98 | def test_upstream_one_template_with_name(self): | ||
| 112 | 99 | # With an upstream template the sharing information on a | ||
| 113 | 100 | # source package will return that, even when searching for a | ||
| 114 | 101 | # specific template name. | ||
| 115 | 102 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 116 | 103 | productseries = self._makeUpstreamProductSeries( | ||
| 117 | 104 | distroseries, sourcepackagename) | ||
| 118 | 105 | templatename = self.factory.getUniqueString() | ||
| 119 | 106 | potemplate = self.factory.makePOTemplate( | ||
| 120 | 107 | productseries=productseries, name=templatename) | ||
| 121 | 108 | self.assertEquals( | ||
| 122 | 109 | [(productseries, potemplate)], | ||
| 123 | 110 | get_upstream_sharing_info( | ||
| 124 | 111 | distroseries=distroseries, | ||
| 125 | 112 | sourcepackagename=sourcepackagename, | ||
| 126 | 113 | templatename=templatename)) | ||
| 127 | 114 | |||
| 128 | 115 | def test_upstream_one_template_with_different_name(self): | ||
| 129 | 116 | # With an upstream template the sharing information on a | ||
| 130 | 117 | # source package will be empty if a different name is queried. | ||
| 131 | 118 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 132 | 119 | productseries = self._makeUpstreamProductSeries( | ||
| 133 | 120 | distroseries, sourcepackagename) | ||
| 134 | 121 | templatename = self.factory.getUniqueString() | ||
| 135 | 122 | self.factory.makePOTemplate( | ||
| 136 | 123 | productseries=productseries, name=templatename) | ||
| 137 | 124 | different_templatename = self.factory.getUniqueString() | ||
| 138 | 125 | self.assertEquals( | ||
| 139 | 126 | [(productseries, None)], | ||
| 140 | 127 | get_upstream_sharing_info( | ||
| 141 | 128 | distroseries=distroseries, | ||
| 142 | 129 | sourcepackagename=sourcepackagename, | ||
| 143 | 130 | templatename=different_templatename)) | ||
| 144 | 131 | |||
| 145 | 132 | def test_no_ubuntu(self): | ||
| 146 | 133 | # With no sourcepackage the sharing information on a source package | ||
| 147 | 134 | # will be empty. | ||
| 148 | 135 | productseries = self.factory.makeProductSeries() | ||
| 149 | 136 | self.assertEquals( | ||
| 150 | 137 | [], | ||
| 151 | 138 | get_ubuntu_sharing_info(productseries=productseries)) | ||
| 152 | 139 | |||
| 153 | 140 | def test_no_ubuntu_with_name(self): | ||
| 154 | 141 | # With no sourcepackage the sharing information on a source package | ||
| 155 | 142 | # will be empty, even when searching for a specific template name. | ||
| 156 | 143 | productseries = self.factory.makeProductSeries() | ||
| 157 | 144 | templatename = self.factory.getUniqueString() | ||
| 158 | 145 | self.assertEquals( | ||
| 159 | 146 | [], | ||
| 160 | 147 | get_ubuntu_sharing_info( | ||
| 161 | 148 | productseries=productseries, templatename=templatename)) | ||
| 162 | 149 | |||
| 163 | 150 | def test_ubuntu_no_template(self): | ||
| 164 | 151 | # With a sourcepackage without a template the sharing information | ||
| 165 | 152 | # on a productseries will be empty. | ||
| 166 | 153 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 167 | 154 | productseries = self._makeUpstreamProductSeries( | ||
| 168 | 155 | distroseries, sourcepackagename) | ||
| 169 | 156 | self.assertEquals( | ||
| 170 | 157 | [(distroseries, sourcepackagename, None)], | ||
| 171 | 158 | get_ubuntu_sharing_info(productseries=productseries)) | ||
| 172 | 159 | |||
| 173 | 160 | def test_ubuntu_no_template_with_name(self): | ||
| 174 | 161 | # With a sourcepackage without a template the sharing information | ||
| 175 | 162 | # on a productseries will be empty, even when searching for a | ||
| 176 | 163 | # specific template name. | ||
| 177 | 164 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 178 | 165 | productseries = self._makeUpstreamProductSeries( | ||
| 179 | 166 | distroseries, sourcepackagename) | ||
| 180 | 167 | templatename = self.factory.getUniqueString() | ||
| 181 | 168 | self.assertEquals( | ||
| 182 | 169 | [(distroseries, sourcepackagename, None)], | ||
| 183 | 170 | get_ubuntu_sharing_info( | ||
| 184 | 171 | productseries=productseries, templatename=templatename)) | ||
| 185 | 172 | |||
| 186 | 173 | def test_ubuntu_one_template(self): | ||
| 187 | 174 | # With a sourcepackage template the sharing information on a | ||
| 188 | 175 | # source package will return that. | ||
| 189 | 176 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 190 | 177 | productseries = self._makeUpstreamProductSeries( | ||
| 191 | 178 | distroseries, sourcepackagename) | ||
| 192 | 179 | potemplate = self.factory.makePOTemplate( | ||
| 193 | 180 | distroseries=distroseries, sourcepackagename=sourcepackagename) | ||
| 194 | 181 | self.assertEquals( | ||
| 195 | 182 | [(distroseries, sourcepackagename, potemplate)], | ||
| 196 | 183 | get_ubuntu_sharing_info( | ||
| 197 | 184 | productseries=productseries)) | ||
| 198 | 185 | |||
| 199 | 186 | def test_ubuntu_one_template_with_name(self): | ||
| 200 | 187 | # With a sourcepackage template the sharing information on a | ||
| 201 | 188 | # productseries will return that, even when searching for a | ||
| 202 | 189 | # specific template name. | ||
| 203 | 190 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 204 | 191 | productseries = self._makeUpstreamProductSeries( | ||
| 205 | 192 | distroseries, sourcepackagename) | ||
| 206 | 193 | templatename = self.factory.getUniqueString() | ||
| 207 | 194 | potemplate = self.factory.makePOTemplate( | ||
| 208 | 195 | distroseries=distroseries, sourcepackagename=sourcepackagename, | ||
| 209 | 196 | name=templatename) | ||
| 210 | 197 | self.assertEquals( | ||
| 211 | 198 | [(distroseries, sourcepackagename, potemplate)], | ||
| 212 | 199 | get_ubuntu_sharing_info( | ||
| 213 | 200 | productseries=productseries, templatename=templatename)) | ||
| 214 | 201 | |||
| 215 | 202 | def test_ubuntu_one_template_with_different_name(self): | ||
| 216 | 203 | # With a sourcepackage template the sharing information on a | ||
| 217 | 204 | # productseries will be empty if a different name is queried. | ||
| 218 | 205 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 219 | 206 | productseries = self._makeUpstreamProductSeries( | ||
| 220 | 207 | distroseries, sourcepackagename) | ||
| 221 | 208 | templatename = self.factory.getUniqueString() | ||
| 222 | 209 | self.factory.makePOTemplate( | ||
| 223 | 210 | distroseries=distroseries, sourcepackagename=sourcepackagename, | ||
| 224 | 211 | name=templatename) | ||
| 225 | 212 | different_templatename = self.factory.getUniqueString() | ||
| 226 | 213 | self.assertEquals( | ||
| 227 | 214 | [(distroseries, sourcepackagename, None)], | ||
| 228 | 215 | get_ubuntu_sharing_info( | ||
| 229 | 216 | productseries=productseries, | ||
| 230 | 217 | templatename=different_templatename)) | ||
| 231 | 218 | |||
| 232 | 219 | def test_has_upstream_template_no_productseries(self): | ||
| 233 | 220 | # Without an upstream project, no upstream templates won't be | ||
| 234 | 221 | # available either. | ||
| 235 | 222 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 236 | 223 | templatename = self.factory.getUniqueString() | ||
| 237 | 224 | |||
| 238 | 225 | self.assertFalse( | ||
| 239 | 226 | has_upstream_template( | ||
| 240 | 227 | distroseries, sourcepackagename, templatename)) | ||
| 241 | 228 | |||
| 242 | 229 | def test_has_upstream_template_no_template(self): | ||
| 243 | 230 | # No template exists on the upstream project. | ||
| 244 | 231 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 245 | 232 | productseries = self._makeUpstreamProductSeries( | ||
| 246 | 233 | distroseries, sourcepackagename) | ||
| 247 | 234 | templatename = self.factory.getUniqueString() | ||
| 248 | 235 | |||
| 249 | 236 | self.assertFalse( | ||
| 250 | 237 | has_upstream_template( | ||
| 251 | 238 | distroseries, sourcepackagename, templatename)) | ||
| 252 | 239 | |||
| 253 | 240 | def test_has_upstream_template_one_template(self): | ||
| 254 | 241 | # There is one template on the upstream project that matches the | ||
| 255 | 242 | # name. | ||
| 256 | 243 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 257 | 244 | productseries = self._makeUpstreamProductSeries( | ||
| 258 | 245 | distroseries, sourcepackagename) | ||
| 259 | 246 | templatename = self.factory.getUniqueString() | ||
| 260 | 247 | self.factory.makePOTemplate( | ||
| 261 | 248 | productseries=productseries, name=templatename) | ||
| 262 | 249 | |||
| 263 | 250 | self.assertTrue( | ||
| 264 | 251 | has_upstream_template( | ||
| 265 | 252 | distroseries, sourcepackagename, templatename)) | ||
| 266 | 253 | |||
| 267 | 254 | def test_has_upstream_template_one_template_wrong_name(self): | ||
| 268 | 255 | # There is one template on the upstream project but it matches not | ||
| 269 | 256 | # the requested name. | ||
| 270 | 257 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 271 | 258 | productseries = self._makeUpstreamProductSeries( | ||
| 272 | 259 | distroseries, sourcepackagename) | ||
| 273 | 260 | self.factory.makePOTemplate(productseries=productseries) | ||
| 274 | 261 | different_templatename = self.factory.getUniqueString() | ||
| 275 | 262 | |||
| 276 | 263 | self.assertFalse( | ||
| 277 | 264 | has_upstream_template( | ||
| 278 | 265 | distroseries, sourcepackagename, different_templatename)) | ||
| 279 | 266 | |||
| 280 | 267 | def test_has_ubuntu_template_no_sourcepackage(self): | ||
| 281 | 268 | # There is no Ubuntu source package, so no Ubuntu template can be | ||
| 282 | 269 | # found. | ||
| 283 | 270 | productseries = self.factory.makeProductSeries() | ||
| 284 | 271 | templatename = self.factory.getUniqueString() | ||
| 285 | 272 | |||
| 286 | 273 | self.assertFalse(has_ubuntu_template(productseries, templatename)) | ||
| 287 | 274 | |||
| 288 | 275 | def test_has_ubuntu_template_no_template(self): | ||
| 289 | 276 | # The Ubuntu source package has no template. | ||
| 290 | 277 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 291 | 278 | productseries = self._makeUpstreamProductSeries( | ||
| 292 | 279 | distroseries, sourcepackagename) | ||
| 293 | 280 | templatename = self.factory.getUniqueString() | ||
| 294 | 281 | |||
| 295 | 282 | self.assertFalse(has_ubuntu_template(productseries, templatename)) | ||
| 296 | 283 | |||
| 297 | 284 | def test_has_ubuntu_template_one_template(self): | ||
| 298 | 285 | # There is one template on the Ubuntu source package that matches | ||
| 299 | 286 | # the name. | ||
| 300 | 287 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 301 | 288 | productseries = self._makeUpstreamProductSeries( | ||
| 302 | 289 | distroseries, sourcepackagename) | ||
| 303 | 290 | templatename = self.factory.getUniqueString() | ||
| 304 | 291 | self.factory.makePOTemplate( | ||
| 305 | 292 | distroseries=distroseries, sourcepackagename=sourcepackagename, | ||
| 306 | 293 | name=templatename) | ||
| 307 | 294 | |||
| 308 | 295 | self.assertTrue(has_ubuntu_template(productseries, templatename)) | ||
| 309 | 296 | |||
| 310 | 297 | def test_has_ubuntu_template_one_template_wrong_name(self): | ||
| 311 | 298 | # There is one template on the Ubuntu source package but it matches | ||
| 312 | 299 | # not the requested name. | ||
| 313 | 300 | distroseries, sourcepackagename = self._makeSourcePackage() | ||
| 314 | 301 | productseries = self._makeUpstreamProductSeries( | ||
| 315 | 302 | distroseries, sourcepackagename) | ||
| 316 | 303 | templatename = self.factory.getUniqueString() | ||
| 317 | 304 | self.factory.makePOTemplate( | ||
| 318 | 305 | distroseries=distroseries, sourcepackagename=sourcepackagename, | ||
| 319 | 306 | name=templatename) | ||
| 320 | 307 | different_templatename = self.factory.getUniqueString() | ||
| 321 | 308 | |||
| 322 | 309 | self.assertFalse( | ||
| 323 | 310 | has_ubuntu_template(productseries, different_templatename)) | ||
| 324 | 0 | 311 | ||
| 325 | === added file 'lib/lp/translations/utilities/translationsharinginfo.py' | |||
| 326 | --- lib/lp/translations/utilities/translationsharinginfo.py 1970-01-01 00:00:00 +0000 | |||
| 327 | +++ lib/lp/translations/utilities/translationsharinginfo.py 2011-02-03 18:46:24 +0000 | |||
| 328 | @@ -0,0 +1,176 @@ | |||
| 329 | 1 | # Copyright 2011 Canonical Ltd. This software is licensed under the | ||
| 330 | 2 | # GNU Affero General Public License version 3 (see the file LICENSE). | ||
| 331 | 3 | |||
| 332 | 4 | """Provide sharing information. | ||
| 333 | 5 | |||
| 334 | 6 | This module defines two different types of functions that provide | ||
| 335 | 7 | information about what sharing options are available on the other side of a | ||
| 336 | 8 | packaging link. Since they perform similar but slightly different complex | ||
| 337 | 9 | database queries combining them in any way will usually be wrong. | ||
| 338 | 10 | |||
| 339 | 11 | get_ubuntu_sharing_info and get_upstream_sharing_info will give you | ||
| 340 | 12 | information about the source package or productseries respectively, | ||
| 341 | 13 | combined with possibly available templates. You can restrict the search | ||
| 342 | 14 | by specifying a template name. | ||
| 343 | 15 | |||
| 344 | 16 | has_ubuntu_template and has_upstream_template make a direct search for a | ||
| 345 | 17 | template of the given name on the other side. They do not search for | ||
| 346 | 18 | source package or productseries but will only return True if an actual | ||
| 347 | 19 | template exists. That is a significant difference to the get_* functions. | ||
| 348 | 20 | """ | ||
| 349 | 21 | |||
| 350 | 22 | __metaclass__ = type | ||
| 351 | 23 | __all__ = [ | ||
| 352 | 24 | 'get_ubuntu_sharing_info', | ||
| 353 | 25 | 'get_upstream_sharing_info', | ||
| 354 | 26 | 'has_ubuntu_template', | ||
| 355 | 27 | 'has_upstream_template', | ||
| 356 | 28 | ] | ||
| 357 | 29 | |||
| 358 | 30 | from storm.expr import (\ | ||
| 359 | 31 | And, | ||
| 360 | 32 | Join, | ||
| 361 | 33 | LeftJoin, | ||
| 362 | 34 | ) | ||
| 363 | 35 | |||
| 364 | 36 | from canonical.launchpad.interfaces.lpstorm import IStore | ||
| 365 | 37 | from lp.registry.model.distroseries import DistroSeries | ||
| 366 | 38 | from lp.registry.model.packaging import Packaging | ||
| 367 | 39 | from lp.registry.model.productseries import ProductSeries | ||
| 368 | 40 | from lp.registry.model.sourcepackagename import SourcePackageName | ||
| 369 | 41 | from lp.translations.model.potemplate import POTemplate | ||
| 370 | 42 | |||
| 371 | 43 | |||
| 372 | 44 | def find_ubuntu_sharing_info(productseries, templatename=None, | ||
| 373 | 45 | template_only=False): | ||
| 374 | 46 | """Return a `ResultSet` of sharing information for this productseries. | ||
| 375 | 47 | |||
| 376 | 48 | Target is either a productseries or a source package. | ||
| 377 | 49 | :param productseries: The target productseries or None. | ||
| 378 | 50 | :param templatename: The name of the template to find information for or | ||
| 379 | 51 | None to get information about any sharing template in any series. | ||
| 380 | 52 | :param template_only: Return only `POTemplate` instances. | ||
| 381 | 53 | :returns: A result set of ('Distroseries', SourcePackageName, POTemplate) | ||
| 382 | 54 | tuples. | ||
| 383 | 55 | """ | ||
| 384 | 56 | |||
| 385 | 57 | # SELECT * | ||
| 386 | 58 | # FROM Packaging | ||
| 387 | 59 | # JOIN Distroseries | ||
| 388 | 60 | # ON Packaging.distroseries = Distroseries.id | ||
| 389 | 61 | # JOIN SourcePackageName | ||
| 390 | 62 | # ON Packaging.sourcepackagename = SourcePackageName.id | ||
| 391 | 63 | # LEFT JOIN POTemplate | ||
| 392 | 64 | # ON Packaging.distroseries = POTemplate.distroseries AND | ||
| 393 | 65 | # Packaging.sourcepackagename = POTemplate.sourcepackagename AND | ||
| 394 | 66 | # POTemplate.name = templatename | ||
| 395 | 67 | # WHERE Packaging.productseries = productseries | ||
| 396 | 68 | # | ||
| 397 | 69 | if templatename is None: | ||
| 398 | 70 | potemplate_condition = And( | ||
| 399 | 71 | Packaging.distroseriesID == POTemplate.distroseriesID, | ||
| 400 | 72 | Packaging.sourcepackagenameID == POTemplate.sourcepackagenameID) | ||
| 401 | 73 | else: | ||
| 402 | 74 | potemplate_condition = And( | ||
| 403 | 75 | Packaging.distroseriesID == POTemplate.distroseriesID, | ||
| 404 | 76 | Packaging.sourcepackagenameID == | ||
| 405 | 77 | POTemplate.sourcepackagenameID, | ||
| 406 | 78 | POTemplate.name == templatename) | ||
| 407 | 79 | if template_only: | ||
| 408 | 80 | prejoin = Join( | ||
| 409 | 81 | Packaging, | ||
| 410 | 82 | POTemplate, | ||
| 411 | 83 | potemplate_condition) | ||
| 412 | 84 | result_classes = POTemplate | ||
| 413 | 85 | else: | ||
| 414 | 86 | prejoin = LeftJoin( | ||
| 415 | 87 | Join( | ||
| 416 | 88 | Join( | ||
| 417 | 89 | Packaging, DistroSeries, | ||
| 418 | 90 | Packaging.distroseriesID == DistroSeries.id), | ||
| 419 | 91 | SourcePackageName, | ||
| 420 | 92 | Packaging.sourcepackagenameID == SourcePackageName.id), | ||
| 421 | 93 | POTemplate, | ||
| 422 | 94 | potemplate_condition) | ||
| 423 | 95 | result_classes = (DistroSeries, SourcePackageName, POTemplate) | ||
| 424 | 96 | conditions = [ | ||
| 425 | 97 | Packaging.productseries == productseries, | ||
| 426 | 98 | ] | ||
| 427 | 99 | return IStore(Packaging).using(prejoin).find( | ||
| 428 | 100 | result_classes, *conditions) | ||
| 429 | 101 | |||
| 430 | 102 | |||
| 431 | 103 | def find_upstream_sharing_info(distroseries, sourcepackagename, | ||
| 432 | 104 | templatename=None, template_only=False): | ||
| 433 | 105 | """Return a `ResultSet` of sharing information for this sourcepackage. | ||
| 434 | 106 | |||
| 435 | 107 | :param distroseries: The target distroseries or None. | ||
| 436 | 108 | :param sourcepackagename: The target sourcepackagename or None. | ||
| 437 | 109 | :param templatename: The name of the template to find information for or | ||
| 438 | 110 | None to get information about any sharing template in any series. | ||
| 439 | 111 | :param template_only: Return only `POTemplate` instances. | ||
| 440 | 112 | :returns: A ResultSet of (ProductSeries, POTemplate) tuples. | ||
| 441 | 113 | """ | ||
| 442 | 114 | # SELECT * | ||
| 443 | 115 | # FROM Packaging | ||
| 444 | 116 | # JOIN ProductSeries | ||
| 445 | 117 | # ON Packaging.productseries = Productseris.id | ||
| 446 | 118 | # LEFT JOIN POTemplate | ||
| 447 | 119 | # ON Packaging.productseries = POTemplate.productseries AND | ||
| 448 | 120 | # POTemplate.name = templatename | ||
| 449 | 121 | # WHERE Packaging.distroseries = distroseries AND | ||
| 450 | 122 | # Packaging.sourcepackagename = sourcepackagename | ||
| 451 | 123 | # | ||
| 452 | 124 | if templatename is None: | ||
| 453 | 125 | potemplate_condition = ( | ||
| 454 | 126 | Packaging.productseriesID == POTemplate.productseriesID) | ||
| 455 | 127 | else: | ||
| 456 | 128 | potemplate_condition = And( | ||
| 457 | 129 | Packaging.productseriesID == POTemplate.productseriesID, | ||
| 458 | 130 | POTemplate.name == templatename) | ||
| 459 | 131 | if template_only: | ||
| 460 | 132 | prejoin = Join( | ||
| 461 | 133 | Packaging, POTemplate, potemplate_condition) | ||
| 462 | 134 | result_classes = POTemplate | ||
| 463 | 135 | else: | ||
| 464 | 136 | prejoin = LeftJoin( | ||
| 465 | 137 | Join( | ||
| 466 | 138 | Packaging, ProductSeries, | ||
| 467 | 139 | Packaging.productseriesID == ProductSeries.id), | ||
| 468 | 140 | POTemplate, | ||
| 469 | 141 | potemplate_condition) | ||
| 470 | 142 | result_classes = (ProductSeries, POTemplate) | ||
| 471 | 143 | conditions = [ | ||
| 472 | 144 | Packaging.distroseries == distroseries, | ||
| 473 | 145 | Packaging.sourcepackagename == sourcepackagename, | ||
| 474 | 146 | ] | ||
| 475 | 147 | |||
| 476 | 148 | return IStore(Packaging).using(prejoin).find( | ||
| 477 | 149 | result_classes, *conditions) | ||
| 478 | 150 | |||
| 479 | 151 | |||
| 480 | 152 | def get_ubuntu_sharing_info(productseries, templatename=None): | ||
| 481 | 153 | """Return a list of sharing information for the given target.""" | ||
| 482 | 154 | return list(find_ubuntu_sharing_info(productseries, templatename)) | ||
| 483 | 155 | |||
| 484 | 156 | |||
| 485 | 157 | def get_upstream_sharing_info(distroseries, sourcepackagename, | ||
| 486 | 158 | templatename=None): | ||
| 487 | 159 | """Return a list of sharing information for the given target.""" | ||
| 488 | 160 | return list(find_upstream_sharing_info( | ||
| 489 | 161 | distroseries, sourcepackagename, templatename)) | ||
| 490 | 162 | |||
| 491 | 163 | |||
| 492 | 164 | def has_ubuntu_template(productseries, templatename): | ||
| 493 | 165 | """Check for existence of ubuntu template.""" | ||
| 494 | 166 | result = find_ubuntu_sharing_info( | ||
| 495 | 167 | productseries, templatename, template_only=True) | ||
| 496 | 168 | return not result.is_empty() | ||
| 497 | 169 | |||
| 498 | 170 | |||
| 499 | 171 | def has_upstream_template(distroseries, sourcepackagename, templatename): | ||
| 500 | 172 | """Check for existence of upstream template.""" | ||
| 501 | 173 | result = find_upstream_sharing_info( | ||
| 502 | 174 | distroseries, sourcepackagename, templatename, | ||
| 503 | 175 | template_only=True) | ||
| 504 | 176 | return not result.is_empty() | ||
Henning,
This looks good. Thanks for taking the time to jump on Mumble and talk this over with me. I really like the test, and appreciate you being thorough in covering all the various cases.
Some minor cleanups/
* Remove the pylint disable-msg declaration
* Be consistent about comments on the test methods
(Just so it's easy to scan the test and work out
what is being tested)
* Add clarify comments to the main module (docstring perhaps?)
This last one is because it was not clear to me where I would use these methods, or why I should prefer one over the other. So some documentation to clarify would help. And also prevent people importing all these functions and doing:
if has_upstream_
info = get_upstream_
To help prevent people firing off more queries then they they realize.
Thanks, again!