Merge lp:~jtv/launchpad/recife-policy-mixin into lp:~launchpad/launchpad/recife

[Jeroen T. Vermeulen]

TranslationPolicyMixin

= TranslationPolicy mixin =

In my ongoing work for the Recife feature branch, the ITranslationPolicy is growing from a placeholder for two pieces of configuration data into a place where translation policy is derived from that configuration data. Product, ProjectGroup, and Distribution all implement the interface.

At this point I'm extending the interface further and introducing TranslationPolicyMixin, a base class that implements most of ITranslationPolicy in one place. The branch is meant for merging into the feature branch, not devel or db-devel.

I'm not actually making much use of the new class yet, but I have prototypes that move the related decision-making into the TranslationPolicyMixin. I'm splitting the actual landing up into multiple smaller branches. (That's also why I'm using the multi-line import format in a case that would have fit into a single line: I'm about to add to that import anyway). For now you'll see some less significant code being reworked to use the policy methods.

For testing I just ran all Translations tests except the windmill ones (which crash firefox on my system):
{{{
./bin/test -vvc lp.translations.tests
}}}

Needless to say, these all pass. There were one or two tiny pieces of lint left, but none that I caused or dare fix.

Jeroen

[Robert Collins (lifeless)]

I think this would be better as a dedicated class not a mixin. Other than that it seems reasonable to me.

[Jeroen T. Vermeulen (jtv)]

Okay: I'm reworking this to be a dedicated class.

[Jeroen T. Vermeulen (jtv)]

The rework gets too big. I'll have to leave that for a separate branch.

[Brad Crittenden (bac)]

Hi Jeroen,

This branch continuing your work looks good. I understand your desire to not do the conversion from a mixin in this branch,but as follow on work.

In getTranslationPolicy you test for productseries is not None to determine whether it is a product/projectgroup or distro. I'd like to see a test for distroseries before you use it and raise an AssertionError if both are None.

Please run the copyright and import sort tools on your branch b/c I didn't pay any attention to sorting, etc.

Other than that the branch looks good.

review: Approve

[Jeroen T. Vermeulen (jtv)]

Hi Brad. Thanks for the review!

The restrictions POTemplate are such that one of {productseries, distroseries} is always None and the other is not. An attempt to do it differently would result in a database error, or possibly an assertion failure even before it gets to that. The fields are initialized once and then never changed, so there are no reasonable transient states that might deviate from the rule either.

Will run copyright and import sort tools. Thanks for the reminder.

Jeroen

=== modified file 'lib/lp/registry/interfaces/product.py'
--- lib/lp/registry/interfaces/product.py	2010-11-05 09:59:37 +0000
+++ lib/lp/registry/interfaces/product.py	2010-11-08 09:02:43 +0000
@@ -1,4 +1,4 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 # pylint: disable-msg=E0211,E0213
@@ -706,10 +706,6 @@
         "groups for a product. There can be several: one from the product, "
         "and potentially one from the project, too.")
 
-    aggregatetranslationpermission = Attribute("The translation permission "
-        "that applies to translations in this product, based on the "
-        "permissions that apply to the product as well as its project.")
-
     commercial_subscription = exported(
         Reference(
             ICommercialSubscription,

=== modified file 'lib/lp/registry/model/distribution.py'
--- lib/lp/registry/model/distribution.py	2010-11-02 20:10:56 +0000
+++ lib/lp/registry/model/distribution.py	2010-11-08 09:02:43 +0000
@@ -192,6 +192,7 @@
 from lp.translations.model.hastranslationimports import (
     HasTranslationImportsMixin,
     )
+from lp.translations.model.translationpolicy import TranslationPolicyMixin
 
 
 class Distribution(SQLBase, BugTargetBase, MakesAnnouncements,
@@ -199,7 +200,7 @@
                    HasTranslationImportsMixin, KarmaContextMixin,
                    OfficialBugTagTargetMixin, QuestionTargetMixin,
                    StructuralSubscriptionTargetMixin, HasMilestonesMixin,
-                   HasBugHeatMixin):
+                   HasBugHeatMixin, TranslationPolicyMixin):
     """A distribution of an operating system, e.g. Debian GNU/Linux."""
     implements(
         IDistribution, IFAQTarget, IHasBugHeat, IHasBugSupervisor,

=== modified file 'lib/lp/registry/model/product.py'
--- lib/lp/registry/model/product.py	2010-11-03 22:37:55 +0000
+++ lib/lp/registry/model/product.py	2010-11-08 09:02:43 +0000
@@ -174,6 +174,7 @@
     HasTranslationImportsMixin,
     )
 from lp.translations.model.potemplate import POTemplate
+from lp.translations.model.translationpolicy import TranslationPolicyMixin
 
 
 def get_license_status(license_approved, license_reviewed, licenses):
@@ -290,7 +291,7 @@
               HasAliasMixin, StructuralSubscriptionTargetMixin,
               HasMilestonesMixin, OfficialBugTagTargetMixin, HasBranchesMixin,
               HasCustomLanguageCodesMixin, HasMergeProposalsMixin,
-              HasBugHeatMixin, HasCodeImportsMixin):
+              HasBugHeatMixin, HasCodeImportsMixin, TranslationPolicyMixin):
     """A Product."""
 
     implements(
@@ -1045,26 +1046,18 @@
 
     @property
     def translationgroups(self):
-        tg = []
-        if self.translationgroup:
-            tg.append(self.translationgroup)
-        if self.project:
-            if self.project.translationgroup:
-                if self.project.translationgroup not in tg:
-                    tg.append(self.project.translationgroup)
-
-    @property
-    def aggregatetranslationpermission(self):
-        perms = [self.translationpermission]
-        if self.project:
-            perms.append(self.project.translationpermission)
-        # XXX Carlos Perello Marin 2005-06-02:
-        # Reviewer please describe a better way to explicitly order
-        # the enums. The spec describes the order, and the values make
-        # it work, and there is space left for new values so we can
-        # ensure a consistent sort order in future, but there should be
-        # a better way.
-        return max(perms)
+        return reversed(self.getTranslationGroups())
+
+    def isTranslationsOwner(self, person):
+        """See `ITranslationPolicy`."""
+        # A Product owner gets special translation privileges.
+        return person.inTeam(self.owner)
+
+    def getInheritedTranslationPolicy(self):
+        """See `ITranslationPolicy`."""
+        # A Product inherits parts of it its effective translation
+        # policy from its ProjectGroup, if any.
+        return self.project
 
     @property
     def has_any_specifications(self):

=== modified file 'lib/lp/registry/model/projectgroup.py'
--- lib/lp/registry/model/projectgroup.py	2010-11-02 20:10:56 +0000
+++ lib/lp/registry/model/projectgroup.py	2010-11-08 09:02:43 +0000
@@ -1,4 +1,4 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 # pylint: disable-msg=E0611,W0212
@@ -105,6 +105,7 @@
     )
 from lp.services.worlddata.model.language import Language
 from lp.translations.interfaces.translationgroup import TranslationPermission
+from lp.translations.model.translationpolicy import TranslationPolicyMixin
 
 
 class ProjectGroup(SQLBase, BugTargetBase, HasSpecificationsMixin,
@@ -112,7 +113,7 @@
                    KarmaContextMixin, BranchVisibilityPolicyMixin,
                    StructuralSubscriptionTargetMixin,
                    HasBranchesMixin, HasMergeProposalsMixin, HasBugHeatMixin,
-                   HasMilestonesMixin):
+                   HasMilestonesMixin, TranslationPolicyMixin):
     """A ProjectGroup"""
 
     implements(IProjectGroup, IFAQCollection, IHasBugHeat, IHasIcon, IHasLogo,

=== modified file 'lib/lp/translations/browser/pofile.py'
--- lib/lp/translations/browser/pofile.py	2010-11-04 09:32:28 +0000
+++ lib/lp/translations/browser/pofile.py	2010-11-08 09:02:43 +0000
@@ -503,24 +503,19 @@
         Duplicates are eliminated; every translation group will occur
         at most once.
         """
-        language = self.context.language
         managers = []
-        groups = set()
-        for group in self.context.potemplate.translationgroups:
-            if group not in groups:
-                translator = group.query_translator(language)
-                if translator is None:
-                    team = None
-                    style_guide_url = None
-                else:
-                    team = translator.translator
-                    style_guide_url = translator.style_guide_url
-                managers.append({
-                    'group': group,
-                    'team': team,
-                    'style_guide_url': style_guide_url,
-                    })
-            groups.add(group)
+        policy = self.context.potemplate.getTranslationPolicy()
+        translators = policy.getTranslators(self.context.language)
+        for group, translator, team in reversed(translators):
+            if translator is None:
+                style_guide_url = None
+            else:
+                style_guide_url = translator.style_guide_url
+            managers.append({
+                'group': group,
+                'team': team,
+                'style_guide_url': style_guide_url,
+            })
         return managers
 
 

=== modified file 'lib/lp/translations/interfaces/potemplate.py'
--- lib/lp/translations/interfaces/potemplate.py	2010-10-18 16:36:46 +0000
+++ lib/lp/translations/interfaces/potemplate.py	2010-11-08 09:02:43 +0000
@@ -517,6 +517,12 @@
     def awardKarma(person, action_name):
         """Award karma for a translation action on this template."""
 
+    def getTranslationPolicy():
+        """Return the applicable `ITranslationPolicy` object.
+
+        The returned object is either a `Product` or a `Distribution`.
+        """
+
 
 class IPOTemplateSubset(Interface):
     """A subset of POTemplate."""

=== modified file 'lib/lp/translations/interfaces/translationpolicy.py'
--- lib/lp/translations/interfaces/translationpolicy.py	2010-11-05 08:16:14 +0000
+++ lib/lp/translations/interfaces/translationpolicy.py	2010-11-08 09:02:43 +0000
@@ -1,7 +1,7 @@
 # Copyright 2010 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
-"""Translation permissions policy."""
+"""Translation access and sharing policy."""
 
 __metaclass__ = type
 __all__ = [
@@ -9,13 +9,23 @@
     ]
 
 from zope.interface import Interface
-from zope.schema import Choice
+from zope.schema import (
+    Choice,
+    )
 
 from canonical.launchpad import _
 from lp.translations.interfaces.translationgroup import TranslationPermission
 
 
 class ITranslationPolicy(Interface):
+    """Permissions and sharing policy for translatable pillars.
+
+    A translation policy defines who can edit translations, and who can
+    add suggestions.  (The ability to edit also implies the ability to
+    enter suggestions).  Everyone else is allowed only to view the
+    translations.
+    """
+
     translationgroup = Choice(
         title = _("Translation group"),
         description = _("The translation group that helps review "
@@ -30,3 +40,44 @@
             " balance openness and control for their translations."),
         required=True,
         vocabulary=TranslationPermission)
+
+    def getTranslationGroups(self):
+        """List all applicable translation groups.
+
+        This may be an empty list, or a list containing just this
+        policy's translation group, or for a product that is part of a
+        project group, possibly a list of two translation groups.
+
+        If there is an inherited policy, its translation group comes
+        first.  Duplicates are removed.
+        """
+
+    def getTranslators(language, store=None):
+        """Find the applicable `TranslationGroup`(s) and translators.
+
+        Zero, one, or two translation groups may apply.  Each may have a
+        `Translator` for the language, with either a person or a team
+        assigned.
+
+        In the case of a product in a project group, there may be up to
+        two entries.  In that case, the entry from the project group
+        comes first.
+
+        :param language: The language that you want the translators for.
+        :type language: ILanguage
+        :param store: Optionally a specific store to retrieve from.
+        :type store: Store
+        :return: A result set of zero or more tuples:
+            (`TranslationGroup`, `Translator`, `Person`).  The
+            translation group is always present and unique.  The person
+            is present if and only if the translator is present.  The
+            translator is unique if present, but the person need not be.
+        """
+
+    def getEffectiveTranslationPermission(self):
+        """Get the effective `TranslationPermission`.
+
+        Returns the strictest applicable permission out of
+        `self.translationpermission` and any inherited
+        `TranslationPermission`.
+        """

=== modified file 'lib/lp/translations/model/potemplate.py'
--- lib/lp/translations/model/potemplate.py	2010-11-05 08:11:53 +0000
+++ lib/lp/translations/model/potemplate.py	2010-11-08 09:02:43 +0000
@@ -316,37 +316,22 @@
         else:
             return None
 
+    def getTranslationPolicy(self):
+        """See `IPOTemplate`."""
+        if self.productseries is not None:
+            return self.productseries.product
+        else:
+            return self.distroseries.distribution
+
     @property
     def translationgroups(self):
         """See `IPOTemplate`."""
-        ret = []
-        if self.distroseries:
-            tg = self.distroseries.distribution.translationgroup
-            if tg is not None:
-                ret.append(tg)
-        elif self.productseries:
-            product_tg = self.productseries.product.translationgroup
-            if product_tg is not None:
-                ret.append(product_tg)
-            project = self.productseries.product.project
-            if project is not None:
-                if project.translationgroup is not None:
-                    ret.append(project.translationgroup)
-        else:
-            raise NotImplementedError('Cannot find translation groups.')
-        return ret
+        return self.getTranslationPolicy().getTranslationGroups()
 
     @property
     def translationpermission(self):
         """See `IPOTemplate`."""
-        if self.distroseries:
-            # in the case of a distro template, use the distro translation
-            # permission settings
-            return self.distroseries.distribution.translationpermission
-        elif self.productseries:
-            # for products, use the "most restrictive permission" between
-            # project and product.
-            return self.productseries.product.aggregatetranslationpermission
+        return self.getTranslationPolicy().getEffectiveTranslationPermission()
 
     @property
     def relatives_by_name(self):

=== modified file 'lib/lp/translations/model/translationgroup.py'
--- lib/lp/translations/model/translationgroup.py	2010-09-03 10:59:24 +0000
+++ lib/lp/translations/model/translationgroup.py	2010-11-08 09:02:43 +0000
@@ -33,13 +33,7 @@
 from canonical.launchpad.interfaces.lpstorm import ISlaveStore
 from lp.app.errors import NotFoundError
 from lp.registry.interfaces.person import validate_public_person
-from lp.registry.model.distribution import Distribution
 from lp.registry.model.person import Person
-from lp.registry.model.product import (
-    Product,
-    ProductWithLicenses,
-    )
-from lp.registry.model.projectgroup import ProjectGroup
 from lp.registry.model.teammembership import TeamParticipation
 from lp.services.database.prejoin import prejoin
 from lp.services.worlddata.model.language import Language
@@ -108,10 +102,18 @@
 
     @property
     def products(self):
+        """See `ITranslationGroup`."""
+        # Avoid circular imports.
+        from lp.registry.model.product import Product
+
         return Product.selectBy(translationgroup=self.id, active=True)
 
     @property
     def projects(self):
+        """See `ITranslationGroup`."""
+        # Avoid circular imports.
+        from lp.registry.model.projectgroup import ProjectGroup
+
         return ProjectGroup.selectBy(translationgroup=self.id, active=True)
 
     # A limit of projects to get for the `top_projects`.
@@ -178,6 +180,12 @@
 
     def fetchProjectsForDisplay(self):
         """See `ITranslationGroup`."""
+        # Avoid circular imports.
+        from lp.registry.model.product import (
+            Product,
+            ProductWithLicenses,
+            )
+
         using = [
             Product,
             LeftJoin(LibraryFileAlias, LibraryFileAlias.id == Product.iconID),
@@ -202,6 +210,9 @@
 
     def fetchProjectGroupsForDisplay(self):
         """See `ITranslationGroup`."""
+        # Avoid circular imports.
+        from lp.registry.model.projectgroup import ProjectGroup
+
         using = [
             ProjectGroup,
             LeftJoin(
@@ -225,6 +236,9 @@
 
     def fetchDistrosForDisplay(self):
         """See `ITranslationGroup`."""
+        # Avoid circular imports.
+        from lp.registry.model.distribution import Distribution
+
         using = [
             Distribution,
             LeftJoin(

=== added file 'lib/lp/translations/model/translationpolicy.py'
--- lib/lp/translations/model/translationpolicy.py	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/model/translationpolicy.py	2010-11-08 09:02:43 +0000
@@ -0,0 +1,104 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Translation access and sharing policy."""
+
+__metaclass__ = type
+__all__ = [
+    'TranslationPolicyMixin',
+    ]
+
+from storm.expr import (
+    And,
+    LeftJoin,
+    )
+from zope.component import getUtility
+
+from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
+from canonical.launchpad.interfaces.lpstorm import IStore
+from lp.registry.model.person import Person
+from lp.translations.interfaces.translationsperson import ITranslationsPerson
+from lp.translations.model.translationgroup import TranslationGroup
+from lp.translations.model.translator import Translator
+
+
+class TranslationPolicyMixin:
+    """Implementation mixin for `ITranslationPolicy`."""
+
+    def getInheritedTranslationPolicy(self):
+        """Get any `ITranslationPolicy` objects that this one inherits.
+
+        To be overridden by the implementing class.  A `Product` may
+        inherit a policy from a `ProjectGroup` it's in.
+        """
+        return None
+
+    def isTranslationsOwner(self, person):
+        """Is `person` one of the owners of these translations?
+
+        To be overridden by the implementing class if it grants special
+        translation rights to certain people.
+        """
+        return False
+
+    def _hasSpecialTranslationPrivileges(self, person):
+        """Does this person have special translation editing rights here?"""
+        celebs = getUtility(ILaunchpadCelebrities)
+        return (
+            person.inTeam(celebs.admin) or
+            person.inTeam(celebs.rosetta_experts) or
+            self.isTranslationsOwner(person))
+
+    def _canTranslate(self, person):
+        """Is `person` in a position to translate?
+
+        Someone who has declined the translations relicensing agreement
+        is not.  Someone who hasn't decided on the agreement yet is, but
+        may be redirected to a form to sign first.
+        """
+        translations_person = ITranslationsPerson(person)
+        agreement = translations_person.translations_relicensing_agreement
+        return agreement is not False
+
+    def getTranslationGroups(self):
+        """See `ITranslationPolicy`."""
+        inherited = self.getInheritedTranslationPolicy()
+        if inherited is None:
+            groups = []
+        else:
+            groups = inherited.getTranslationGroups()
+        my_group = self.translationgroup
+        if my_group is not None and my_group not in groups:
+            groups.append(my_group)
+        return groups
+
+    def _getTranslator(self, translationgroup, language, store):
+        """Retrieve one (TranslationGroup, Translator, Person) tuple."""
+        translator_join = LeftJoin(Translator, And(
+            Translator.translationgroupID == TranslationGroup.id,
+            Translator.languageID == language.id))
+        person_join = LeftJoin(
+            Person, Person.id == Translator.translatorID)
+
+        source = store.using(TranslationGroup, translator_join, person_join)
+        return source.find(
+            (TranslationGroup, Translator, Person),
+            TranslationGroup.id == translationgroup.id).one()
+
+    def getTranslators(self, language, store=None):
+        """See `ITranslationPolicy`."""
+        if store is None:
+            store = IStore(TranslationGroup)
+        return [
+            self._getTranslator(group, language, store)
+            for group in self.getTranslationGroups()]
+
+    def getEffectiveTranslationPermission(self):
+        """See `ITranslationPolicy`."""
+        inherited = self.getInheritedTranslationPolicy()
+        if inherited is None:
+            return self.translationpermission
+        else:
+            return max([
+                self.translationpermission,
+                inherited.getEffectiveTranslationPermission()])

=== added file 'lib/lp/translations/tests/test_translationpolicy.py'
--- lib/lp/translations/tests/test_translationpolicy.py	1970-01-01 00:00:00 +0000
+++ lib/lp/translations/tests/test_translationpolicy.py	2010-11-08 09:02:43 +0000
@@ -0,0 +1,184 @@
+# Copyright 2010 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Test `TranslationPolicyMixin`."""
+
+__metaclass__ = type
+
+from zope.component import getUtility
+from zope.interface import implements
+
+from canonical.launchpad.interfaces.launchpad import ILaunchpadCelebrities
+from canonical.testing.layers import ZopelessDatabaseLayer
+from lp.testing import TestCaseWithFactory
+from lp.testing.fakemethod import FakeMethod
+from lp.translations.interfaces.translationgroup import TranslationPermission
+from lp.translations.interfaces.translationpolicy import ITranslationPolicy
+from lp.translations.interfaces.translationsperson import ITranslationsPerson
+from lp.translations.interfaces.translator import ITranslatorSet
+from lp.translations.model.translationpolicy import TranslationPolicyMixin
+
+
+class TranslationPolicyImplementation(TranslationPolicyMixin):
+    implements(ITranslationPolicy)
+
+    translationgroup = None
+
+    translationpermission = TranslationPermission.OPEN
+
+
+class TestTranslationPolicy(TestCaseWithFactory):
+    layer = ZopelessDatabaseLayer
+
+    def setUp(self):
+        super(TestTranslationPolicy, self).setUp()
+        self.policy = TranslationPolicyImplementation()
+
+    def _makeParentPolicy(self):
+        """Create a policy that `self.policy` inherits from."""
+        parent = TranslationPolicyImplementation()
+        self.policy.getInheritedTranslationPolicy = FakeMethod(result=parent)
+        return parent
+
+    def _makeTranslationGroups(self, count):
+        """Return a list of `count` freshly minted `TranslationGroup`s."""
+        return [
+            self.factory.makeTranslationGroup() for number in xrange(count)]
+
+    def _makeTranslator(self, language, for_policy=None):
+        """Create a translator for a policy object.
+
+        Default is `self.policy`.  Creates a translation group if necessary.
+        """
+        if for_policy is None:
+            for_policy = self.policy
+        if for_policy.translationgroup is None:
+            for_policy.translationgroup = self.factory.makeTranslationGroup()
+        person = self.factory.makePerson()
+        getUtility(ITranslatorSet).new(
+            for_policy.translationgroup, language, person, None)
+        return person
+
+    def _setPermissions(self, child_permission, parent_permission):
+        """Set `TranslationPermission`s for `self.policy` and its parent."""
+        self.policy.translationpermission = child_permission
+        self.policy.getInheritedTranslationPolicy().translationpermission = (
+            parent_permission)
+
+    def test_hasSpecialTranslationPrivileges_for_regular_joe(self):
+        # A logged-in user has no special translationprivileges by
+        # default.
+        joe = self.factory.makePerson()
+        self.assertFalse(self.policy._hasSpecialTranslationPrivileges(joe))
+
+    def test_hasSpecialTranslationPrivileges_for_admin(self):
+        # Admins have special translation privileges.
+        admin = self.factory.makePerson()
+        getUtility(ILaunchpadCelebrities).admin.addMember(admin, admin)
+        self.assertTrue(self.policy._hasSpecialTranslationPrivileges(admin))
+
+    def test_hasSpecialTranslationPrivileges_for_translations_owner(self):
+        # A policy may define a "translations owner" who also gets
+        # special translation privileges.
+        self.policy.isTranslationsOwner = FakeMethod(result=True)
+        owner = self.factory.makePerson()
+        self.assertTrue(self.policy._hasSpecialTranslationPrivileges(owner))
+
+    def test_canTranslate(self):
+        # A user who has declined the licensing agreement can't
+        # translate.  Someone who has agreed, or not made a decision
+        # yet, can.
+        user = self.factory.makePerson()
+        translations_user = ITranslationsPerson(user)
+
+        self.assertTrue(self.policy._canTranslate(user))
+
+        translations_user.translations_relicensing_agreement = True
+        self.assertTrue(self.policy._canTranslate(user))
+
+        translations_user.translations_relicensing_agreement = False
+        self.assertFalse(self.policy._canTranslate(user))
+
+    def test_getTranslationGroups_returns_translation_group(self):
+        # In the simple case, getTranslationGroup simply returns the
+        # policy implementation's translation group.
+        self.assertEqual([], self.policy.getTranslationGroups())
+        self.policy.translationgroup = self.factory.makeTranslationGroup()
+        self.assertEqual(
+            [self.policy.translationgroup],
+            self.policy.getTranslationGroups())
+
+    def test_getTranslationGroups_enumerates_groups_inherited_first(self):
+        parent = self._makeParentPolicy()
+        groups = self._makeTranslationGroups(2)
+        parent.translationgroup = groups[0]
+        self.policy.translationgroup = groups[1]
+        self.assertEqual(groups, self.policy.getTranslationGroups())
+
+    def test_getTranslationGroups_inheritance_is_asymmetric(self):
+        parent = self._makeParentPolicy()
+        groups = self._makeTranslationGroups(2)
+        parent.translationgroup = groups[0]
+        self.policy.translationgroup = groups[1]
+        self.assertEqual(groups[:1], parent.getTranslationGroups())
+
+    def test_getTranslationGroups_eliminates_duplicates(self):
+        parent = self._makeParentPolicy()
+        groups = self._makeTranslationGroups(1)
+        parent.translationgroup = groups[0]
+        self.policy.translationgroup = groups[0]
+        self.assertEqual(groups, self.policy.getTranslationGroups())
+
+    def test_getTranslators_without_groups_returns_empty_list(self):
+        language = self.factory.makeLanguage()
+        self.assertEqual([], self.policy.getTranslators(language))
+
+    def test_getTranslators_returns_group_even_without_translators(self):
+        self.policy.translationgroup = self.factory.makeTranslationGroup()
+        self.assertEqual(
+            [(self.policy.translationgroup, None, None)],
+            self.policy.getTranslators(self.factory.makeLanguage()))
+
+    def test_getTranslators_returns_translator(self):
+        language = self.factory.makeLanguage()
+        language_translator = self._makeTranslator(language)
+        translators = self.policy.getTranslators(language)
+        self.assertEqual(1, len(translators))
+        group, translator, person = translators[0]
+        self.assertEqual(self.policy.translationgroup, group)
+        self.assertEqual(
+            self.policy.translationgroup, translator.translationgroup)
+        self.assertEqual(person, translator.translator)
+        self.assertEqual(language, translator.language)
+        self.assertEqual(language_translator, person)
+
+    def test_getEffectiveTranslationPermission_returns_permission(self):
+        # In the basic case, getEffectiveTranslationPermission just
+        # returns the policy's translation permission.
+        self.policy.translationpermission = TranslationPermission.CLOSED
+        self.assertEqual(
+            self.policy.translationpermission,
+            self.policy.getEffectiveTranslationPermission())
+
+    def test_getEffectiveTranslationPermission_returns_maximum(self):
+        # When combining permissions, getEffectiveTranslationPermission
+        # returns the one with the highest numerical value.
+        parent = self._makeParentPolicy()
+        for child_permission in TranslationPermission.items:
+            for parent_permission in TranslationPermission.items:
+                self._setPermissions(child_permission, parent_permission)
+                stricter = max(child_permission, parent_permission)
+                self.assertEqual(
+                    stricter, self.policy.getEffectiveTranslationPermission())
+
+    def test_maximum_permission_is_strictest(self):
+        # The TranslationPermissions are ordered from loosest to
+        # strictest, so the maximum is always the strictest.
+        self.assertEqual(TranslationPermission.STRUCTURED, max(
+            TranslationPermission.OPEN, TranslationPermission.STRUCTURED))
+        self.assertEqual(TranslationPermission.RESTRICTED, max(
+            TranslationPermission.STRUCTURED,
+            TranslationPermission.RESTRICTED))
+        self.assertEqual(TranslationPermission.CLOSED, max(
+            TranslationPermission.RESTRICTED,
+            TranslationPermission.CLOSED))