Merge lp:~jcsackett/launchpad/add-enums-to-models into lp:launchpad

[j.c.sackett]

Wraps the usage_enums (e.g. official_translations) on product and distribution in a property that makes use of and sets data on the official_ attrs (e.g. official_rosetta) to help transition over to the usage_enums.

= Summary =

IServiceUsage provides enums to give better data on how a product or distribution uses launchpad, in place of the old bool fields (e.g. official_rosetta). However, when we roll out these enums, they will default to UNKNOWN until we can migrate data.

This branch creates properties using the enums (moved to _[ENUM] format) to use the old bool data until data is set for the enum, so we can start using the enums in code.

== Proposed fix ==

Create properties using getters and setters to intelligent find the data from the new and old attributes, and set them properly moving forward.

== Pre-implementation notes ==

Talked with Curtis.

== Implementation details ==

As above.

This branch incorporates Brad's work on the progress bar, as they need to land together. ~bac/launchpad/progress-enums
== Tests ==

bin/test -vvc -t UsageEnums

== Demo and Q/A ==

Go to a project on launchpad.dev and ensure the configuration and status
links are correct.

= Launchpad lint =

= Launchpad lint =

Checking for conflicts and issues in changed files.

Linting changed files:
  lib/lp/registry/configure.zcml
  lib/lp/registry/browser/product.py
  lib/lp/registry/browser/tests/pillar-views.txt
  lib/lp/registry/interfaces/product.py
  lib/lp/registry/model/distribution.py
  lib/lp/registry/model/product.py
  lib/lp/registry/tests/test_distribution.py
  lib/lp/registry/tests/test_product.py

./lib/lp/registry/interfaces/product.py
     901: E301 expected 1 blank line, found 2
./lib/lp/registry/model/distribution.py
    1181: E231 missing whitespace after ','
    1185: E231 missing whitespace after ','
    1197: E231 missing whitespace after ','

E301 from comment issue
E231 from creation of tuple (something = ('some tuple',))

[Brad Crittenden (bac)]

Hi Jon,

In def test_codehosting_usage(self): why do you make a new distribution instead of using self.distribution?

Same question for def test_bug_tracking_usage(self):

We discussed on IRC refactoring the tests since they are mostly the same.

Otherwise this branch rocks. Look forward to seeing it landed.

review: Approve (code)

[j.c.sackett (jcsackett)]

> In def test_codehosting_usage(self): why do you make a new distribution instead of using self.distribution?
> Same question for def test_bug_tracking_usage(self):

A bad job of refactoring early on? I must have just missed it when I moved the call to makeDistribution up into setUp.

>
> We discussed on IRC refactoring the tests since they are mostly the same.

There is now one BaseTestCase that does most of the work, with subclass that define the target to product or distribution.

Thanks for the pointers, Brad.

=== modified file 'lib/lp/registry/tests/test_distribution.py'
--- lib/lp/registry/tests/test_distribution.py 2010-08-20 18:37:10 +0000
+++ lib/lp/registry/tests/test_distribution.py 2010-08-20 21:48:02 +0000
@@ -10,155 +10,17 @@
 from lazr.lifecycle.snapshot import Snapshot
 from lp.registry.tests.test_distroseries import (
     TestDistroSeriesCurrentSourceReleases)
-from lp.app.enums import ServiceUsage
 from lp.registry.interfaces.distroseries import NoSuchDistroSeries
 from lp.registry.interfaces.series import SeriesStatus
 from lp.registry.interfaces.distribution import IDistribution

 from lp.soyuz.interfaces.distributionsourcepackagerelease import (
     IDistributionSourcePackageRelease)
-from lp.testing import (
- login_person,
- TestCaseWithFactory,
- )
+from lp.testing import TestCaseWithFactory
 from canonical.testing.layers import (
     DatabaseFunctionalLayer, LaunchpadFunctionalLayer)

-class TestDistributionUsageEnums(TestCaseWithFactory):
- """Tests the usage enums for the distribution."""
-
- layer = DatabaseFunctionalLayer
-
- def setUp(self):
- super(TestDistributionUsageEnums, self).setUp()
- self.distribution = self.factory.makeDistribution()
-
- def test_answers_usage_no_data(self):
- # By default, we don't know anything about a distribution
- self.assertEqual(
- ServiceUsage.UNKNOWN,
- self.distribution.answers_usage)
-
- def test_answers_usage_using_bool(self):
- # If the old bool says they use Launchpad, return LAUNCHPAD
- # if the ServiceUsage is unknown.
- login_person(self.distribution.owner)
- self.distribution.official_answers = True
- self.assertEqual(
- ServiceUsage.LAUNCHPAD,
- self.distribution.answers_usage)
-
- def test_answers_usage_with_enum_data(self):
- # If the enum has something other than UNKNOWN as its status,
- # use that.
- login_person(self.distribution.owner)
- self.distribution.answers_usage = ServiceUsage.EXTERNAL
- self.assertEqual(
- ServiceUsage.EXTERNAL,
- self.distribution.answers_usage)
-
- def test_answers_setter(self):
- login_person(self.distribution.owner)
- self.distribution.official_answers = True
- self.distribution.answers_usage = ServiceUsage.EXTERNAL
- self.assertEqual(
- False,
- self.distribution.official_answers)
- self.distribution.answers_usage = ServiceUsage.LAUNCHPAD
- self.assertEqual(
- True,
- self.distribution.official_answers)
-
- def test_codehosting_usage(self):
- ...

[Robert Collins (lifeless)]

On Sat, Aug 21, 2010 at 9:58 AM, j.c.sackett
<email address hidden> wrote:

> +
> +# Manually create the TestLoader list, because the UsageEnumsBaseTestCase
> +# shouldn't run.
> +test_list = [
> +    __name__ + ".TestDistributionUsageEnums",
> +    __name__ + ".TestProductUsageEnums",
> +    ]
> +
> +
> +def test_suite():
> +    return unittest.TestLoader().loadTestsFromNames(test_list)

There are a few slightly better ways of doing this.

Class UsageEnumsMixinIn
....stuff

class TestDistributionUsageEnums(TestCaseWithFactory, UsageEnumsMixin):
 ...

class TestProductUsageEnums(TestCaseWithFactory, UsageEnumsMixin):
...

is one.

Another is to use testscenarios, and your parameterisation would be
more explicit, but we don't use that in lp today AFAIK, so I won't
suggest adding it in (but you could get much the same helpers from
bzrlib.testing).

These are better because they don't have a class that looks-to-loaders
like a valid test case, but isn't.

-Rob

=== modified file 'lib/lp/registry/browser/product.py'
--- lib/lp/registry/browser/product.py	2010-08-22 20:27:48 +0000
+++ lib/lp/registry/browser/product.py	2010-08-22 20:27:49 +0000
@@ -50,8 +50,6 @@
     )
 from operator import attrgetter
 
-from lazr.delegates import delegates
-from lazr.restful.interface import copy_field
 import pytz
 from z3c.ptcompat import ViewPageTemplateFile
 from zope.app.form.browser import (
@@ -79,7 +77,8 @@
 
 from canonical.cachedproperty import cachedproperty
 from canonical.config import config
-<<<<<<< TREE
+from lazr.delegates import delegates
+from lazr.restful.interface import copy_field
 from canonical.launchpad import (
     _,
     helpers,
@@ -89,20 +88,6 @@
     MultiStepView,
     StepView,
     )
-=======
-from lazr.delegates import delegates
-from lazr.restful.interface import copy_field
-from canonical.launchpad import _
-from lp.services.fields import PillarAliases, PublicPersonChoice
-from lp.app.enums import ServiceUsage
-from lp.app.errors import NotFoundError
-from lp.app.interfaces.headings import IEditableContextTitle
-from lp.blueprints.browser.specificationtarget import (
-    HasSpecificationsMenuMixin)
-from lp.bugs.interfaces.bugtask import RESOLVED_BUGTASK_STATUSES
-from lp.code.browser.sourcepackagerecipelisting import HasRecipesMenuMixin
-from lp.services.worlddata.interfaces.country import ICountry
->>>>>>> MERGE-SOURCE
 from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
 from canonical.launchpad.interfaces.librarian import ILibraryFileAliasSet
 from canonical.launchpad.mail import (
@@ -157,6 +142,7 @@
     QuestionTargetFacetMixin,
     QuestionTargetTraversalMixin,
     )
+from lp.app.enums import ServiceUsage
 from lp.app.errors import NotFoundError
 from lp.app.interfaces.headings import IEditableContextTitle
 from lp.blueprints.browser.specificationtarget import (

=== modified file 'lib/lp/registry/configure.zcml'
--- lib/lp/registry/configure.zcml	2010-08-22 20:27:48 +0000
+++ lib/lp/registry/configure.zcml	2010-08-22 20:27:49 +0000
@@ -1090,7 +1090,7 @@
             interface="lp.registry.interfaces.product.IProductEditRestricted"/>
         <require
             permission="launchpad.Edit"
-	    set_schema="lp.app.interfaces.launchpad.IServiceUsage"/>
+            set_schema="lp.app.interfaces.launchpad.IServiceUsage"/>
         <require
             permission="launchpad.Edit"
             set_attributes="bug_reporting_guidelines
@@ -1405,6 +1405,9 @@
             permission="launchpad.Edit"
             interface="lp.registry.interfaces.distribution.IDistributionEditRestricted"/>
         <require
+            permission="launchpad.Edit"
+            set_schema="lp.app.interfaces.launchpad.IServiceUsage"/>
+        <require
             permission="launchpad.Moderate"
             interface="lp.registry.interfaces.distribution.IDistributionDriverRestricted"/>
         <require

=== modified file 'lib/lp/registry/doc/distribution.txt'
--- lib/lp/registry/doc/distribution.txt	2010-08-06 14:49:35 +0000
+++ lib/lp/registry/doc/distribution.txt	2010-08-22 20:27:49 +0000
@@ -397,13 +397,26 @@
     >>> print ubuntu.bug_tracking_usage.name
     LAUNCHPAD
 
-While the other attributes are not yet used.
+While the other attributes track the other official_ attributes. 
 
+    >>> print ubuntu.official_rosetta
+    True
     >>> print ubuntu.translations_usage.name
-    UNKNOWN
+    LAUNCHPAD 
+    >>> print ubuntu.official_answers
+    True
     >>> print ubuntu.answers_usage.name
-    UNKNOWN
+    LAUNCHPAD
+    >>> print ubuntu.official_blueprints
+    True
     >>> print ubuntu.blueprints_usage.name
+    LAUNCHPAD
+
+If the official_ attributes are False, the usage enums don't know anything.
+
+    >>> login_person(ubuntu.owner.teamowner)
+    >>> ubuntu.official_rosetta = False
+    >>> print ubuntu.translations_usage.name
     UNKNOWN
 
 A distribution *cannot* specify that it uses codehosting. Currently there's

=== modified file 'lib/lp/registry/doc/product.txt'
--- lib/lp/registry/doc/product.txt	2010-08-06 14:49:35 +0000
+++ lib/lp/registry/doc/product.txt	2010-08-22 20:27:49 +0000
@@ -501,15 +501,11 @@
     False
     >>> print firefox.codehosting_usage.name
     UNKNOWN
-    >>> print firefox.uses_launchpad
-    False
     >>> firefox.development_focus.branch = factory.makeBranch(product=firefox)
     >>> print firefox.official_codehosting
     True
     >>> print firefox.codehosting_usage.name
     LAUNCHPAD
-    >>> print firefox.uses_launchpad
-    True
 
 We can also find all the products that have branches.
 

=== modified file 'lib/lp/registry/model/distribution.py'
--- lib/lp/registry/model/distribution.py	2010-08-20 20:31:18 +0000
+++ lib/lp/registry/model/distribution.py	2010-08-22 20:27:49 +0000
@@ -63,6 +63,11 @@
     ILaunchpadCelebrities,
     )
 from canonical.launchpad.interfaces.lpstorm import IStore
+from lp.registry.model.announcement import MakesAnnouncements
+from lp.soyuz.model.archive import Archive
+from lp.soyuz.model.binarypackagename import BinaryPackageName
+from lp.soyuz.model.binarypackagerelease import (
+    BinaryPackageRelease)
 from canonical.launchpad.validators.name import (
     sanitize_name,
     valid_name,
@@ -273,7 +278,6 @@
         else:
             alsoProvides(self, IDerivativeDistribution)
 
-
     @property
     def uploaders(self):
         """See `IDistribution`."""
@@ -310,21 +314,85 @@
         return True in (self.official_malone, self.official_rosetta,
                         self.official_blueprints, self.official_answers)
 
-    answers_usage = EnumCol(
+    _answers_usage = EnumCol(
         dbName="answers_usage", notNull=True,
         schema=ServiceUsage,
         default=ServiceUsage.UNKNOWN)
-    blueprints_usage = EnumCol(
+
+    def _get_answers_usage(self):
+        if self._answers_usage != ServiceUsage.UNKNOWN:
+            # If someone has set something with the enum, use it.
+            return self._answers_usage
+        elif self.official_answers:
+            return ServiceUsage.LAUNCHPAD
+        return self._answers_usage
+
+    def _set_answers_usage(self, val):
+        self._answers_usage = val
+        if val == ServiceUsage.LAUNCHPAD:
+            self.official_answers = True
+        else:
+            self.official_answers = False
+
+    answers_usage = property(
+        _get_answers_usage,
+        _set_answers_usage,
+        doc="Indicates if the product uses the answers service.")
+
+    _blueprints_usage = EnumCol(
         dbName="blueprints_usage", notNull=True,
         schema=ServiceUsage,
         default=ServiceUsage.UNKNOWN)
-    translations_usage = EnumCol(
+
+    def _get_blueprints_usage(self):
+        if self._blueprints_usage != ServiceUsage.UNKNOWN:
+            # If someone has set something with the enum, use it.
+            return self._blueprints_usage
+        elif self.official_blueprints:
+            return ServiceUsage.LAUNCHPAD
+        return self._blueprints_usage
+
+    def _set_blueprints_usage(self, val):
+        self._blueprints_usage = val
+        if val == ServiceUsage.LAUNCHPAD:
+            self.official_blueprints = True
+        else:
+            self.official_blueprints = False
+
+    blueprints_usage = property(
+        _get_blueprints_usage,
+        _set_blueprints_usage,
+        doc="Indicates if the product uses the blueprints service.")
+
+    _translations_usage = EnumCol(
         dbName="translations_usage", notNull=True,
         schema=ServiceUsage,
         default=ServiceUsage.UNKNOWN)
+
+    def _get_translations_usage(self):
+        if self._translations_usage != ServiceUsage.UNKNOWN:
+            # If someone has set something with the enum, use it.
+            return self._translations_usage
+        elif self.official_rosetta:
+            return ServiceUsage.LAUNCHPAD
+        return self._translations_usage
+
+    def _set_translations_usage(self, val):
+        self._translations_usage = val
+        if val == ServiceUsage.LAUNCHPAD:
+            self.official_rosetta = True
+        else:
+            self.official_rosetta = False
+
+    translations_usage = property(
+        _get_translations_usage,
+        _set_translations_usage,
+        doc="Indicates if the product uses the translations service.")
+
     @property
     def codehosting_usage(self):
         return ServiceUsage.NOT_APPLICABLE
+
     @property
     def bug_tracking_usage(self):
         if not self.official_malone:
@@ -551,9 +619,9 @@
         if not self.full_functionality:
             return None
 
-        urls = {'http_base_url' : http_base_url,
-                'ftp_base_url' : ftp_base_url,
-                'rsync_base_url' : rsync_base_url}
+        urls = {'http_base_url': http_base_url,
+                'ftp_base_url': ftp_base_url,
+                'rsync_base_url': rsync_base_url}
         for name, value in urls.items():
             if value is not None:
                 urls[name] = IDistributionMirror[name].normalize(value)
@@ -766,7 +834,7 @@
 
         # filter based on completion. see the implementation of
         # Specification.is_complete() for more details
-        completeness =  Specification.completeness_clause
+        completeness = Specification.completeness_clause
 
         if SpecificationFilter.COMPLETE in filter:
             query += ' AND ( %s ) ' % completeness
@@ -1091,15 +1159,15 @@
         find_spec = (
             DistributionSourcePackageCache,
             SourcePackageName,
-            SQL('rank(fti, ftq(%s)) AS rank' % sqlvalues(text))
+            SQL('rank(fti, ftq(%s)) AS rank' % sqlvalues(text)),
             )
         origin = [
             DistributionSourcePackageCache,
             Join(
                 SourcePackageName,
                 DistributionSourcePackageCache.sourcepackagename ==
-                    SourcePackageName.id
-                )
+                    SourcePackageName.id,
+                ),
             ]
 
         publishing_condition = ''
@@ -1140,8 +1208,7 @@
                    quote(text), quote_like(text), has_packaging_condition,
                    publishing_condition)
         dsp_caches_with_ranks = store.using(*origin).find(
-            find_spec, condition
-            ).order_by('rank DESC')
+            find_spec, condition).order_by('rank DESC')
 
         return dsp_caches_with_ranks
 
@@ -1160,8 +1227,7 @@
             cache, source_package_name, rank = result
             return DistributionSourcePackage(
                 self,
-                source_package_name
-                )
+                source_package_name)
 
         # Return the decorated result set so the consumer of these
         # results will only see DSPs
@@ -1225,7 +1291,7 @@
         extra_clauses = (
             BinaryPackageRelease.binarypackagenameID ==
                 DistroSeriesPackageCache.binarypackagenameID,
-            Match(search_vector_column, query_function)
+            Match(search_vector_column, query_function),
             )
         where_spec = (self._binaryPackageSearchClause + extra_clauses)
 
@@ -1481,11 +1547,11 @@
         # XXX Julian 2007-08-16
         # These component names should be Soyuz-wide constants.
         componentMapToArchivePurpose = {
-            'main' : ArchivePurpose.PRIMARY,
-            'restricted' : ArchivePurpose.PRIMARY,
-            'universe' : ArchivePurpose.PRIMARY,
-            'multiverse' : ArchivePurpose.PRIMARY,
-            'partner' : ArchivePurpose.PARTNER,
+            'main': ArchivePurpose.PRIMARY,
+            'restricted': ArchivePurpose.PRIMARY,
+            'universe': ArchivePurpose.PRIMARY,
+            'multiverse': ArchivePurpose.PRIMARY,
+            'partner': ArchivePurpose.PARTNER,
             'contrib': ArchivePurpose.PRIMARY,
             'non-free': ArchivePurpose.PRIMARY,
             }

=== modified file 'lib/lp/registry/model/product.py'
--- lib/lp/registry/model/product.py	2010-08-22 20:27:48 +0000
+++ lib/lp/registry/model/product.py	2010-08-22 20:27:49 +0000
@@ -39,10 +39,6 @@
 from zope.security.proxy import removeSecurityProxy
 
 from canonical.cachedproperty import cachedproperty
-<<<<<<< TREE
-=======
-from lazr.delegates import delegates
->>>>>>> MERGE-SOURCE
 from canonical.database.constants import UTC_NOW
 from canonical.database.datetimecol import UtcDateTimeCol
 from canonical.database.enumcol import EnumCol
@@ -67,7 +63,6 @@
     MAIN_STORE,
     )
 from canonical.launchpad.webapp.sorting import sorted_version_numbers
-from canonical.lazr.utils import safe_hasattr
 from lp.answers.interfaces.faqtarget import IFAQTarget
 from lp.answers.interfaces.questioncollection import (
     QUESTION_STATUS_DEFAULT_SEARCH,
@@ -323,24 +318,26 @@
         # XXX Need to remove official_codehosting column from Product
         # table.
         return self.development_focus.branch is not None
+
     @property
     def official_anything(self):
         return True in (self.official_malone, self.official_rosetta,
                         self.official_blueprints, self.official_answers,
                         self.official_codehosting)
 
-    answers_usage = EnumCol(
+    _answers_usage = EnumCol(
         dbName="answers_usage", notNull=True,
         schema=ServiceUsage,
         default=ServiceUsage.UNKNOWN)
-    blueprints_usage = EnumCol(
+    _blueprints_usage = EnumCol(
         dbName="blueprints_usage", notNull=True,
         schema=ServiceUsage,
         default=ServiceUsage.UNKNOWN)
-    translations_usage = EnumCol(
+    _translations_usage = EnumCol(
         dbName="translations_usage", notNull=True,
         schema=ServiceUsage,
         default=ServiceUsage.UNKNOWN)
+
     @property
     def codehosting_usage(self):
         if self.development_focus.branch is None:
@@ -350,6 +347,7 @@
         elif self.development_focus.branch.branch_type == BranchType.MIRRORED:
             return ServiceUsage.EXTERNAL
         return ServiceUsage.NOT_APPLICABLE
+
     @property
     def bug_tracking_usage(self):
         if self.official_malone:
@@ -358,6 +356,7 @@
             return ServiceUsage.UNKNOWN
         else:
             return ServiceUsage.EXTERNAL
+
     @property
     def uses_launchpad(self):
         """Does this distribution actually use Launchpad?"""
@@ -573,6 +572,66 @@
         super(Product, self).__storm_invalidated__()
         self._cached_licenses = None
 
+    def _get_answers_usage(self):
+        if self._answers_usage != ServiceUsage.UNKNOWN:
+            # If someone has set something with the enum, use it.
+            return self._answers_usage
+        elif self.official_answers:
+            return ServiceUsage.LAUNCHPAD
+        return self._answers_usage
+
+    def _set_answers_usage(self, val):
+        self._answers_usage = val
+        if val == ServiceUsage.LAUNCHPAD:
+            self.official_answers = True
+        else:
+            self.official_answers = False
+
+    answers_usage = property(
+        _get_answers_usage,
+        _set_answers_usage,
+        doc="Indicates if the product uses the answers service.")
+
+    def _get_blueprints_usage(self):
+        if self._blueprints_usage != ServiceUsage.UNKNOWN:
+            # If someone has set something with the enum, use it.
+            return self._blueprints_usage
+        elif self.official_blueprints:
+            return ServiceUsage.LAUNCHPAD
+        return self._blueprints_usage
+
+    def _set_blueprints_usage(self, val):
+        self._blueprints_usage = val
+        if val == ServiceUsage.LAUNCHPAD:
+            self.official_blueprints = True
+        else:
+            self.official_blueprints = False
+
+    blueprints_usage = property(
+        _get_blueprints_usage,
+        _set_blueprints_usage,
+        doc="Indicates if the product uses the blueprints service.")
+
+    def _get_translations_usage(self):
+        if self._translations_usage != ServiceUsage.UNKNOWN:
+            # If someone has set something with the enum, use it.
+            return self._translations_usage
+        elif self.official_rosetta:
+            return ServiceUsage.LAUNCHPAD
+        return self._translations_usage
+
+    def _set_translations_usage(self, val):
+        self._translations_usage = val
+        if val == ServiceUsage.LAUNCHPAD:
+            self.official_rosetta = True
+        else:
+            self.official_rosetta = False
+
+    translations_usage = property(
+        _get_translations_usage,
+        _set_translations_usage,
+        doc="Indicates if the product uses the translations service.")
+
     def _getLicenses(self):
         """Get the licenses as a tuple."""
         if self._cached_licenses is None:

=== added file 'lib/lp/registry/tests/test_service_usage.py'
--- lib/lp/registry/tests/test_service_usage.py	1970-01-01 00:00:00 +0000
+++ lib/lp/registry/tests/test_service_usage.py	2010-08-22 20:27:49 +0000
@@ -0,0 +1,174 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+__metaclass__ = type
+
+import unittest
+
+from canonical.testing import DatabaseFunctionalLayer
+
+from lp.app.enums import ServiceUsage
+from lp.testing import (
+    login_person,
+    TestCaseWithFactory,
+    )
+
+
+class UsageEnumsMixin(object):
+    """Base class for testing the UsageEnums on their pillars."""
+
+    def setUp(self):
+        self.target = None
+
+    def test_answers_usage_no_data(self):
+        # By default, we don't know anything about a target
+        self.assertEqual(
+            ServiceUsage.UNKNOWN,
+            self.target.answers_usage)
+
+    def test_answers_usage_using_bool(self):
+        # If the old bool says they use Launchpad, return LAUNCHPAD
+        # if the ServiceUsage is unknown.
+        login_person(self.target.owner)
+        self.target.official_answers = True
+        self.assertEqual(
+            ServiceUsage.LAUNCHPAD,
+            self.target.answers_usage)
+
+    def test_answers_usage_with_enum_data(self):
+        # If the enum has something other than UNKNOWN as its status,
+        # use that.
+        login_person(self.target.owner)
+        self.target.answers_usage = ServiceUsage.EXTERNAL
+        self.assertEqual(
+            ServiceUsage.EXTERNAL,
+            self.target.answers_usage)
+
+    def test_answers_setter(self):
+        login_person(self.target.owner)
+        self.target.official_answers = True
+        self.target.answers_usage = ServiceUsage.EXTERNAL
+        self.assertEqual(
+            False,
+            self.target.official_answers)
+        self.target.answers_usage = ServiceUsage.LAUNCHPAD
+        self.assertEqual(
+            True,
+            self.target.official_answers)
+
+    def test_codehosting_usage(self):
+        # Only test get for codehosting; this has no setter because the
+        # state is derived from other data.
+        self.assertEqual(
+            ServiceUsage.UNKNOWN,
+            self.target.codehosting_usage)
+
+    def test_translations_usage_no_data(self):
+        # By default, we don't know anything about a target
+        self.assertEqual(
+            ServiceUsage.UNKNOWN,
+            self.target.translations_usage)
+
+    def test_translations_usage_using_bool(self):
+        # If the old bool says they use Launchpad, return LAUNCHPAD
+        # if the ServiceUsage is unknown.
+        login_person(self.target.owner)
+        self.target.official_rosetta = True
+        self.assertEqual(
+            ServiceUsage.LAUNCHPAD,
+            self.target.translations_usage)
+
+    def test_translations_usage_with_enum_data(self):
+        # If the enum has something other than UNKNOWN as its status,
+        # use that.
+        login_person(self.target.owner)
+        self.target.translations_usage = ServiceUsage.EXTERNAL
+        self.assertEqual(
+            ServiceUsage.EXTERNAL,
+            self.target.translations_usage)
+
+    def test_translations_setter(self):
+        login_person(self.target.owner)
+        self.target.official_rosetta = True
+        self.target.translations_usage = ServiceUsage.EXTERNAL
+        self.assertEqual(
+            False,
+            self.target.official_rosetta)
+        self.target.translations_usage = ServiceUsage.LAUNCHPAD
+        self.assertEqual(
+            True,
+            self.target.official_rosetta)
+
+    def test_bug_tracking_usage(self):
+        # Only test get for bug_tracking; this has no setter because the
+        # state is derived from other data.
+        self.assertEqual(
+            ServiceUsage.UNKNOWN,
+            self.target.bug_tracking_usage)
+
+    def test_blueprints_usage_no_data(self):
+        # By default, we don't know anything about a target
+        self.assertEqual(
+            ServiceUsage.UNKNOWN,
+            self.target.blueprints_usage)
+
+    def test_blueprints_usage_using_bool(self):
+        # If the old bool says they use Launchpad, return LAUNCHPAD
+        # if the ServiceUsage is unknown.
+        login_person(self.target.owner)
+        self.target.official_blueprints = True
+        self.assertEqual(
+            ServiceUsage.LAUNCHPAD,
+            self.target.blueprints_usage)
+
+    def test_blueprints_usage_with_enum_data(self):
+        # If the enum has something other than UNKNOWN as its status,
+        # use that.
+        login_person(self.target.owner)
+        self.target.blueprints_usage = ServiceUsage.EXTERNAL
+        self.assertEqual(
+            ServiceUsage.EXTERNAL,
+            self.target.blueprints_usage)
+
+    def test_blueprints_setter(self):
+        login_person(self.target.owner)
+        self.target.official_blueprints = True
+        self.target.blueprints_usage = ServiceUsage.EXTERNAL
+        self.assertEqual(
+            False,
+            self.target.official_blueprints)
+        self.target.blueprints_usage = ServiceUsage.LAUNCHPAD
+        self.assertEqual(
+            True,
+            self.target.official_blueprints)
+
+
+class TestDistributionUsageEnums(TestCaseWithFactory, UsageEnumsMixin):
+    """Tests the usage enums for the distribution."""
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        super(TestDistributionUsageEnums, self).setUp()
+        self.target = self.factory.makeDistribution()
+
+    def test_codehosting_usage(self):
+        # This method must be changed for Distribution, because its
+        # enum defaults to different data.
+        self.assertEqual(
+            ServiceUsage.NOT_APPLICABLE,
+            self.target.codehosting_usage)
+
+
+class TestProductUsageEnums(TestCaseWithFactory, UsageEnumsMixin):
+    """Tests the usage enums for the product."""
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        super(TestProductUsageEnums, self).setUp()
+        self.target = self.factory.makeProduct()
+
+
+def test_suite():
+    return unittest.TestLoader().loadTestsFromName(__name__)