Merge lp:~cjwatson/launchpad/git-defaults into lp:launchpad

[Colin Watson]

Implement target and owner-target default Git repositories.

Implement target and owner-target default Git repositories.

This presents two different layers because of the different ways we'll need to call this. For the webservice, it's simplest to just have {get,set}DefaultRepository* methods on GitRepositorySet. But for some internal purposes, it's useful to have an ICanHasDefaultGitRepository abstraction that's sortable and so on, much like ICanHasLinkedBranch: this is useful when working out Git identities.

I chose to have {get,set}DefaultRepository and {get,set}DefaultRepositoryForOwner be separate methods rather than taking an optional owner keyword argument, because I felt that the optional argument causing completely different semantics was a little too easy to get wrong for webservice users. It's marginally more awkward internally but not too bad.

[William Grant (wgrant)]

I'm not sure about the target.getDefaultGitRepository/setDefaultGitRepository design. They're yet more domain-specific methods on already huge Registry classes, which just isn't maintainable long-term.

During Disclosure we experimented with SharingService to stop the bloat, which ended up hideous more because of the different artifact types than because of a fundamental issue with the service concept.

review: Needs Fixing (code)

[William Grant (wgrant)]

review: Approve (code)

=== modified file 'lib/lp/code/configure.zcml'
--- lib/lp/code/configure.zcml	2015-02-19 23:57:34 +0000
+++ lib/lp/code/configure.zcml	2015-02-26 14:40:55 +0000
@@ -1,4 +1,4 @@
-<!-- Copyright 2009-2013 Canonical Ltd.  This software is licensed under the
+<!-- Copyright 2009-2015 Canonical Ltd.  This software is licensed under the
      GNU Affero General Public License version 3 (see the file LICENSE).
 -->
 
@@ -858,6 +858,13 @@
     <allow interface="lp.code.interfaces.gitnamespace.IGitNamespaceSet" />
   </securedutility>
 
+  <!-- Default Git repositories -->
+
+  <adapter factory="lp.code.model.defaultgit.ProjectDefaultGitRepository" />
+  <adapter factory="lp.code.model.defaultgit.PackageDefaultGitRepository" />
+  <adapter factory="lp.code.model.defaultgit.OwnerProjectDefaultGitRepository" />
+  <adapter factory="lp.code.model.defaultgit.OwnerPackageDefaultGitRepository" />
+
   <lp:help-folder folder="help" name="+help-code" />
 
   <!-- Diffs -->
 
=== modified file 'lib/lp/code/errors.py'
--- lib/lp/code/errors.py	2015-02-11 17:10:09 +0000
+++ lib/lp/code/errors.py	2015-02-26 14:40:55 +0000
@@ -1,4 +1,4 @@
-# Copyright 2009-2013 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2015 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Errors used in the lp/code modules."""
@@ -20,9 +20,9 @@
     'BuildNotAllowedForDistro',
     'BranchMergeProposalExists',
     'CannotDeleteBranch',
+    'CannotHaveLinkedBranch',
     'CannotUpgradeBranch',
     'CannotUpgradeNonHosted',
-    'CannotHaveLinkedBranch',
     'CodeImportAlreadyRequested',
     'CodeImportAlreadyRunning',
     'CodeImportNotInReviewedState',
 
=== added file 'lib/lp/code/interfaces/defaultgit.py'
--- lib/lp/code/interfaces/defaultgit.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/interfaces/defaultgit.py	2015-02-26 14:40:55 +0000
@@ -0,0 +1,29 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Interface for objects that have a default Git repository.
+
+A default Git repository is a repository that's somehow officially related
+to an object.  It might be a project, a distribution source package, or a
+combination of one of those with an owner to represent that owner's default
+repository for that target.
+"""
+
+__metaclass__ = type
+__all__ = [
+    'ICanHasDefaultGitRepository',
+    ]
+
+from zope.interface import (
+    Attribute,
+    Interface,
+    )
+
+
+class ICanHasDefaultGitRepository(Interface):
+    """Something that has a default Git repository."""
+
+    context = Attribute("The object that can have a default Git repository.")
+    path = Attribute(
+        "The path for the default Git repository. "
+        "Note that this will be set even if there is no default repository.")
 
=== modified file 'lib/lp/code/interfaces/gitrepository.py'
--- lib/lp/code/interfaces/gitrepository.py	2015-02-19 23:57:34 +0000
+++ lib/lp/code/interfaces/gitrepository.py	2015-02-26 14:40:55 +0000
@@ -16,6 +16,7 @@
 import re
 
 from lazr.restful.fields import Reference
+from zope.component import getUtility
 from zope.interface import (
     Attribute,
     Interface,
@@ -32,7 +33,16 @@
 from lp import _
 from lp.app.enums import InformationType
 from lp.app.validators import LaunchpadValidationError
+from lp.code.interfaces.defaultgit import ICanHasDefaultGitRepository
 from lp.code.interfaces.hasgitrepositories import IHasGitRepositories
+from lp.registry.interfaces.distributionsourcepackage import (
+    IDistributionSourcePackage,
+    )
+from lp.registry.interfaces.persondistributionsourcepackage import (
+    IPersonDistributionSourcePackageFactory,
+    )
+from lp.registry.interfaces.personproduct import IPersonProductFactory
+from lp.registry.interfaces.product import IProduct
 from lp.registry.interfaces.role import IPersonRoles
 from lp.services.fields import (
     PersonChoice,
@@ -309,16 +319,44 @@
         Return None if no match was found.
         """
 
-    def getDefaultRepository(target, owner=None):
-        """Get the default repository for a target or owner-target.
-
-        :param target: An `IHasGitRepositories`.
-        :param owner: An `IPerson`, in which case search for that person's
-            default repository for this target; or None, in which case
-            search for the overall default repository for this target.
-
-        :raises GitTargetError: if `target` is an `IPerson`.
-        :return: An `IGitRepository`, or None.
+    def getDefaultRepository(target):
+        """Get the default repository for a target.
+
+        :param target: An `IHasGitRepositories`.
+
+        :raises GitTargetError: if `target` is an `IPerson`.
+        :return: An `IGitRepository`, or None.
+        """
+
+    def getDefaultRepositoryForOwner(owner, target):
+        """Get a person's default repository for a target.
+
+        :param owner: An `IPerson`.
+        :param target: An `IHasGitRepositories`.
+
+        :raises GitTargetError: if `target` is an `IPerson`.
+        :return: An `IGitRepository`, or None.
+        """
+
+    def setDefaultRepository(target, repository):
+        """Set the default repository for a target.
+
+        :param target: An `IHasGitRepositories`.
+        :param repository: An `IGitRepository`, or None to unset the default
+            repository.
+
+        :raises GitTargetError: if `target` is an `IPerson`.
+        """
+
+    def setDefaultRepositoryForOwner(owner, target, repository):
+        """Set a person's default repository for a target.
+
+        :param owner: An `IPerson`.
+        :param target: An `IHasGitRepositories`.
+        :param repository: An `IGitRepository`, or None to unset the default
+            repository.
+
+        :raises GitTargetError: if `target` is an `IPerson`.
         """
 
     def getRepositories():
@@ -349,9 +387,23 @@
 
     def getRepositoryDefaults(self):
         """See `IGitRepository`."""
-        # XXX cjwatson 2015-02-06: This will return shortcut defaults once
-        # they're implemented.
-        return []
+        defaults = []
+        if self.target_default:
+            defaults.append(ICanHasDefaultGitRepository(self.target))
+        if self.owner_default:
+            if IProduct.providedBy(self.target):
+                factory = getUtility(IPersonProductFactory)
+                default = factory.create(self.owner, self.target)
+            elif IDistributionSourcePackage.providedBy(self.target):
+                factory = getUtility(IPersonDistributionSourcePackageFactory)
+                default = factory.create(self.owner, self.target)
+            else:
+                # Also enforced by database constraint.
+                raise AssertionError(
+                    "Only projects or packages can have owner-target default "
+                    "repositories.")
+            defaults.append(ICanHasDefaultGitRepository(default))
+        return sorted(defaults)
 
     def getRepositoryIdentities(self):
         """See `IGitRepository`."""
 
=== added file 'lib/lp/code/model/defaultgit.py'
--- lib/lp/code/model/defaultgit.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/model/defaultgit.py	2015-02-26 14:40:55 +0000
@@ -0,0 +1,113 @@
+# Copyright 2009-2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Implementation of `ICanHasDefaultGitRepository`."""
+
+__metaclass__ = type
+# Don't export anything -- anything you need from this module you can get by
+# adapting another object.
+__all__ = []
+
+from zope.component import adapts
+from zope.interface import implements
+
+from lp.code.interfaces.defaultgit import ICanHasDefaultGitRepository
+from lp.registry.interfaces.distributionsourcepackage import (
+    IDistributionSourcePackage,
+    )
+from lp.registry.interfaces.persondistributionsourcepackage import (
+    IPersonDistributionSourcePackage,
+    )
+from lp.registry.interfaces.personproduct import IPersonProduct
+from lp.registry.interfaces.product import IProduct
+
+
+class BaseDefaultGitRepository:
+    """Provides the common sorting algorithm."""
+
+    def __cmp__(self, other):
+        if not ICanHasDefaultGitRepository.providedBy(other):
+            raise AssertionError("Can't compare with: %r" % other)
+        return cmp(self.sort_order, other.sort_order)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, self.__class__) and
+            self.context == other.context)
+
+    def __ne__(self, other):
+        return not self == other
+
+
+class ProjectDefaultGitRepository(BaseDefaultGitRepository):
+    """Implement a default Git repository for a project."""
+
+    adapts(IProduct)
+    implements(ICanHasDefaultGitRepository)
+
+    sort_order = 0
+
+    def __init__(self, project):
+        self.context = project
+
+    @property
+    def path(self):
+        """See `ICanHasDefaultGitRepository`."""
+        return self.context.name
+
+
+class PackageDefaultGitRepository(BaseDefaultGitRepository):
+    """Implement a default Git repository for a distribution source package."""
+
+    adapts(IDistributionSourcePackage)
+    implements(ICanHasDefaultGitRepository)
+
+    sort_order = 0
+
+    def __init__(self, distro_source_package):
+        self.context = distro_source_package
+
+    @property
+    def path(self):
+        """See `ICanHasDefaultGitRepository`."""
+        return "%s/+source/%s" % (
+            self.context.distribution.name,
+            self.context.sourcepackagename.name)
+
+
+class OwnerProjectDefaultGitRepository(BaseDefaultGitRepository):
+    """Implement an owner's default Git repository for a project."""
+
+    adapts(IPersonProduct)
+    implements(ICanHasDefaultGitRepository)
+
+    sort_order = 1
+
+    def __init__(self, person_project):
+        self.context = person_project
+
+    @property
+    def path(self):
+        """See `ICanHasDefaultGitRepository`."""
+        return "~%s/%s" % (self.context.person.name, self.context.product.name)
+
+
+class OwnerPackageDefaultGitRepository(BaseDefaultGitRepository):
+    """Implement an owner's default Git repository for a distribution source
+    package."""
+
+    adapts(IPersonDistributionSourcePackage)
+    implements(ICanHasDefaultGitRepository)
+
+    sort_order = 1
+
+    def __init__(self, person_distro_source_package):
+        self.context = person_distro_source_package
+
+    @property
+    def path(self):
+        """See `ICanHasDefaultGitRepository`."""
+        dsp = self.context.distro_source_package
+        return "~%s/%s/+source/%s" % (
+            self.context.person.name, dsp.distribution.name,
+            dsp.sourcepackagename.name)
 
=== modified file 'lib/lp/code/model/gitrepository.py'
--- lib/lp/code/model/gitrepository.py	2015-02-19 23:57:34 +0000
+++ lib/lp/code/model/gitrepository.py	2015-02-26 14:40:55 +0000
@@ -83,6 +83,7 @@
     ArrayIntersects,
     )
 from lp.services.propertycache import cachedproperty
+from lp.services.webapp.authorization import available_with_permission
 
 
 def git_repository_modified(repository, event):
@@ -206,8 +207,9 @@
         """See `IGitRepository`."""
         if value:
             # Check for an existing owner-target default.
-            existing = getUtility(IGitRepositorySet).getDefaultRepository(
-                self.target, owner=self.owner)
+            repository_set = getUtility(IGitRepositorySet)
+            existing = repository_set.getDefaultRepositoryForOwner(
+                self.owner, self.target)
             if existing is not None:
                 raise GitDefaultConflict(
                     existing, self.target, owner=self.owner)
@@ -358,24 +360,76 @@
         # XXX cjwatson 2015-02-06: Fill this in once IGitLookup is in place.
         raise NotImplementedError
 
-    def getDefaultRepository(self, target, owner=None):
-        """See `IGitRepositorySet`."""
-        clauses = []
-        if IProduct.providedBy(target):
-            clauses.append(GitRepository.project == target)
-        elif IDistributionSourcePackage.providedBy(target):
-            clauses.append(GitRepository.distribution == target.distribution)
-            clauses.append(
-                GitRepository.sourcepackagename == target.sourcepackagename)
-        else:
-            raise GitTargetError(
-                "Personal repositories cannot be defaults for any target.")
-        if owner is not None:
-            clauses.append(GitRepository.owner == owner)
-            clauses.append(GitRepository.owner_default == True)
-        else:
-            clauses.append(GitRepository.target_default == True)
-        return IStore(GitRepository).find(GitRepository, *clauses).one()
+    def getDefaultRepository(self, target):
+        """See `IGitRepositorySet`."""
+        clauses = [GitRepository.target_default == True]
+        if IProduct.providedBy(target):
+            clauses.append(GitRepository.project == target)
+        elif IDistributionSourcePackage.providedBy(target):
+            clauses.append(GitRepository.distribution == target.distribution)
+            clauses.append(
+                GitRepository.sourcepackagename == target.sourcepackagename)
+        else:
+            raise GitTargetError(
+                "Personal repositories cannot be defaults for any target.")
+        return IStore(GitRepository).find(GitRepository, *clauses).one()
+
+    def getDefaultRepositoryForOwner(self, owner, target):
+        """See `IGitRepositorySet`."""
+        clauses = [
+            GitRepository.owner == owner,
+            GitRepository.owner_default == True,
+            ]
+        if IProduct.providedBy(target):
+            clauses.append(GitRepository.project == target)
+        elif IDistributionSourcePackage.providedBy(target):
+            clauses.append(GitRepository.distribution == target.distribution)
+            clauses.append(
+                GitRepository.sourcepackagename == target.sourcepackagename)
+        else:
+            raise GitTargetError(
+                "Personal repositories cannot be defaults for any target.")
+        return IStore(GitRepository).find(GitRepository, *clauses).one()
+
+    @available_with_permission('launchpad.Edit', 'target')
+    def setDefaultRepository(self, target, repository):
+        """See `IGitRepositorySet`."""
+        if IPerson.providedBy(target):
+            raise GitTargetError(
+                "Cannot set a default Git repository for a person, only "
+                "for a project or a package.")
+        if repository is not None:
+            if repository.target != target:
+                raise GitTargetError(
+                    "Cannot set default Git repository to one attached to "
+                    "another target.")
+            repository.setTargetDefault(True)
+        else:
+            previous = self.getDefaultRepository(target)
+            if previous is not None:
+                previous.setTargetDefault(False)
+
+    @available_with_permission('launchpad.Edit', 'owner')
+    def setDefaultRepositoryForOwner(self, owner, target, repository):
+        """See `IGitRepositorySet`."""
+        if IPerson.providedBy(target):
+            raise GitTargetError(
+                "Cannot set a default Git repository for a person, only "
+                "for a project or a package.")
+        if repository is not None:
+            if repository.target != target:
+                raise GitTargetError(
+                    "Cannot set default Git repository to one attached to "
+                    "another target.")
+            if repository.owner != owner:
+                raise GitTargetError(
+                    "Cannot set a person's default Git repository to one "
+                    "owned by somebody else.")
+            repository.setOwnerDefault(True)
+        else:
+            previous = self.getDefaultRepositoryForOwner(owner, target)
+            if previous is not None:
+                previous.setOwnerDefault(False)
 
     def getRepositories(self):
         """See `IGitRepositorySet`."""
 
=== modified file 'lib/lp/code/model/tests/test_gitrepository.py'
--- lib/lp/code/model/tests/test_gitrepository.py	2015-02-20 00:56:57 +0000
+++ lib/lp/code/model/tests/test_gitrepository.py	2015-02-26 14:40:55 +0000
@@ -6,6 +6,7 @@
 __metaclass__ = type
 
 from datetime import datetime
+from functools import partial
 
 from lazr.lifecycle.event import ObjectModifiedEvent
 import pytz
@@ -24,12 +25,20 @@
     GitRepositoryCreatorNotOwner,
     GitTargetError,
     )
+from lp.code.interfaces.defaultgit import ICanHasDefaultGitRepository
 from lp.code.interfaces.gitnamespace import (
     IGitNamespacePolicy,
     IGitNamespaceSet,
     )
-from lp.code.interfaces.gitrepository import IGitRepository
+from lp.code.interfaces.gitrepository import (
+    IGitRepository,
+    IGitRepositorySet,
+    )
 from lp.registry.enums import BranchSharingPolicy
+from lp.registry.interfaces.persondistributionsourcepackage import (
+    IPersonDistributionSourcePackageFactory,
+    )
+from lp.registry.interfaces.personproduct import IPersonProductFactory
 from lp.services.database.constants import UTC_NOW
 from lp.services.webapp.authorization import check_permission
 from lp.testing import (
@@ -96,6 +105,10 @@
 
     layer = DatabaseFunctionalLayer
 
+    def setUp(self):
+        super(TestGitIdentityMixin, self).setUp()
+        self.repository_set = getUtility(IGitRepositorySet)
+
     def assertGitIdentity(self, repository, identity_path):
         """Assert that the Git identity of 'repository' is 'identity_path'.
 
@@ -111,6 +124,53 @@
         repository = self.factory.makeGitRepository()
         self.assertGitIdentity(repository, repository.unique_name)
 
+    def test_git_identity_default_for_project(self):
+        # If a repository is the default for a project, then its Git
+        # identity is the project name.
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(
+            owner=project.owner, target=project)
+        with person_logged_in(project.owner):
+            self.repository_set.setDefaultRepository(project, repository)
+        self.assertGitIdentity(repository, project.name)
+
+    def test_git_identity_default_for_package(self):
+        # If a repository is the default for a package, then its Git
+        # identity uses the path to that package.
+        dsp = self.factory.makeDistributionSourcePackage()
+        repository = self.factory.makeGitRepository(target=dsp)
+        with admin_logged_in():
+            self.repository_set.setDefaultRepository(dsp, repository)
+        self.assertGitIdentity(
+            repository,
+            "%s/+source/%s" % (
+                dsp.distribution.name, dsp.sourcepackagename.name))
+
+    def test_git_identity_owner_default_for_project(self):
+        # If a repository is a person's default for a project, then its Git
+        # identity is a combination of the person and project names.
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(target=project)
+        with person_logged_in(repository.owner):
+            self.repository_set.setDefaultRepositoryForOwner(
+                repository.owner, project, repository)
+        self.assertGitIdentity(
+            repository, "~%s/%s" % (repository.owner.name, project.name))
+
+    def test_git_identity_owner_default_for_package(self):
+        # If a repository is a person's default for a package, then its Git
+        # identity is a combination of the person name and the package path.
+        dsp = self.factory.makeDistributionSourcePackage()
+        repository = self.factory.makeGitRepository(target=dsp)
+        with person_logged_in(repository.owner):
+            self.repository_set.setDefaultRepositoryForOwner(
+                repository.owner, dsp, repository)
+        self.assertGitIdentity(
+            repository,
+            "~%s/%s/+source/%s" % (
+                repository.owner.name, dsp.distribution.name,
+                dsp.sourcepackagename.name))
+
     def test_identities_no_defaults(self):
         # If there are no defaults, the only repository identity is the
         # unique name.
@@ -119,8 +179,54 @@
             [(repository.unique_name, repository)],
             repository.getRepositoryIdentities())
 
-    # XXX cjwatson 2015-02-12: This will need to be expanded once support
-    # for default repositories is in place.
+    def test_default_for_project(self):
+        # If a repository is the default for a project, then that is the
+        # preferred identity.  Target defaults are preferred over
+        # owner-target defaults.
+        eric = self.factory.makePerson(name="eric")
+        fooix = self.factory.makeProduct(name="fooix", owner=eric)
+        repository = self.factory.makeGitRepository(
+            owner=eric, target=fooix, name=u"fooix-repo")
+        with person_logged_in(fooix.owner):
+            self.repository_set.setDefaultRepositoryForOwner(
+                repository.owner, fooix, repository)
+            self.repository_set.setDefaultRepository(fooix, repository)
+        eric_fooix = getUtility(IPersonProductFactory).create(eric, fooix)
+        self.assertEqual(
+            [ICanHasDefaultGitRepository(target)
+             for target in (fooix, eric_fooix)],
+            repository.getRepositoryDefaults())
+        self.assertEqual(
+            [("fooix", fooix), ("~eric/fooix", eric_fooix),
+             ("~eric/fooix/+git/fooix-repo", repository)],
+            repository.getRepositoryIdentities())
+
+    def test_default_for_package(self):
+        # If a repository is the default for a package, then that is the
+        # preferred identity.  Target defaults are preferred over
+        # owner-target defaults.
+        mint = self.factory.makeDistribution(name="mint")
+        eric = self.factory.makePerson(name="eric")
+        mint_choc = self.factory.makeDistributionSourcePackage(
+            distribution=mint, sourcepackagename="choc")
+        repository = self.factory.makeGitRepository(
+            owner=eric, target=mint_choc, name=u"choc-repo")
+        dsp = repository.target
+        with admin_logged_in():
+            self.repository_set.setDefaultRepositoryForOwner(
+                repository.owner, dsp, repository)
+            self.repository_set.setDefaultRepository(dsp, repository)
+        eric_dsp = getUtility(IPersonDistributionSourcePackageFactory).create(
+            eric, dsp)
+        self.assertEqual(
+            [ICanHasDefaultGitRepository(target)
+             for target in (dsp, eric_dsp)],
+            repository.getRepositoryDefaults())
+        self.assertEqual(
+            [("mint/+source/choc", dsp),
+             ("~eric/mint/+source/choc", eric_dsp),
+             ("~eric/mint/+source/choc/+git/choc-repo", repository)],
+            repository.getRepositoryIdentities())
 
 
 class TestGitRepositoryDateLastModified(TestCaseWithFactory):
@@ -392,3 +498,133 @@
             self.assertRaises(
                 GitTargetError, repository.setTarget,
                 target=commercial_project, user=owner)
+
+
+class TestGitRepositorySet(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        super(TestGitRepositorySet, self).setUp()
+        self.repository_set = getUtility(IGitRepositorySet)
+
+    def test_provides_IGitRepositorySet(self):
+        # GitRepositorySet instances provide IGitRepositorySet.
+        verifyObject(IGitRepositorySet, self.repository_set)
+
+    def test_setDefaultRepository_refuses_person(self):
+        # setDefaultRepository refuses if the target is a person.
+        person = self.factory.makePerson()
+        repository = self.factory.makeGitRepository(owner=person)
+        with person_logged_in(person):
+            self.assertRaises(
+                GitTargetError, self.repository_set.setDefaultRepository,
+                person, repository)
+
+    def test_setDefaultRepositoryForOwner_refuses_person(self):
+        # setDefaultRepositoryForOwner refuses if the target is a person.
+        person = self.factory.makePerson()
+        repository = self.factory.makeGitRepository(owner=person)
+        with person_logged_in(person):
+            self.assertRaises(
+                GitTargetError,
+                self.repository_set.setDefaultRepositoryForOwner,
+                person, person, repository)
+
+
+class TestGitRepositorySetDefaultsMixin:
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        super(TestGitRepositorySetDefaultsMixin, self).setUp()
+        self.repository_set = getUtility(IGitRepositorySet)
+        self.get_method = self.repository_set.getDefaultRepository
+        self.set_method = self.repository_set.setDefaultRepository
+
+    def makeGitRepository(self, target):
+        return self.factory.makeGitRepository(target=target)
+
+    def test_default_repository_round_trip(self):
+        # A target's default Git repository set using setDefaultRepository*
+        # can be retrieved using getDefaultRepository*.
+        target = self.makeTarget()
+        repository = self.makeGitRepository(target)
+        self.assertIsNone(self.get_method(target))
+        with person_logged_in(self.getPersonForLogin(target)):
+            self.set_method(target, repository)
+        self.assertEqual(repository, self.get_method(target))
+
+    def test_set_default_repository_None(self):
+        # setDefaultRepository*(target, None) clears the default.
+        target = self.makeTarget()
+        repository = self.makeGitRepository(target)
+        with person_logged_in(self.getPersonForLogin(target)):
+            self.set_method(target, repository)
+            self.set_method(target, None)
+        self.assertIsNone(self.get_method(target))
+
+    def test_set_default_repository_different_target(self):
+        # setDefaultRepository* refuses if the repository is attached to a
+        # different target.
+        target = self.makeTarget()
+        other_target = self.makeTarget(template=target)
+        repository = self.makeGitRepository(other_target)
+        with person_logged_in(self.getPersonForLogin(target)):
+            self.assertRaises(
+                GitTargetError, self.set_method, target, repository)
+
+
+class TestGitRepositorySetDefaultsProject(
+    TestGitRepositorySetDefaultsMixin, TestCaseWithFactory):
+
+    def makeTarget(self, template=None):
+        return self.factory.makeProduct()
+
+    @staticmethod
+    def getPersonForLogin(target):
+        return target.owner
+
+
+class TestGitRepositorySetDefaultsPackage(
+    TestGitRepositorySetDefaultsMixin, TestCaseWithFactory):
+
+    def makeTarget(self, template=None):
+        kwargs = {}
+        if template is not None:
+            kwargs["distribution"] = template.distribution
+        return self.factory.makeDistributionSourcePackage(**kwargs)
+
+    @staticmethod
+    def getPersonForLogin(target):
+        return target.distribution.owner
+
+
+class TestGitRepositorySetDefaultsOwnerMixin(
+    TestGitRepositorySetDefaultsMixin):
+
+    def setUp(self):
+        super(TestGitRepositorySetDefaultsOwnerMixin, self).setUp()
+        self.person = self.factory.makePerson()
+        self.get_method = partial(
+            self.repository_set.getDefaultRepositoryForOwner, self.person)
+        self.set_method = partial(
+            self.repository_set.setDefaultRepositoryForOwner, self.person)
+
+    def makeGitRepository(self, target):
+        return self.factory.makeGitRepository(owner=self.person, target=target)
+
+    def getPersonForLogin(self, target):
+        return self.person
+
+
+class TestGitRepositorySetDefaultsOwnerProject(
+    TestGitRepositorySetDefaultsOwnerMixin,
+    TestGitRepositorySetDefaultsProject):
+    pass
+
+
+class TestGitRepositorySetDefaultsOwnerPackage(
+    TestGitRepositorySetDefaultsOwnerMixin,
+    TestGitRepositorySetDefaultsPackage):
+    pass
 
=== modified file 'lib/lp/registry/model/persondistributionsourcepackage.py'
--- lib/lp/registry/model/persondistributionsourcepackage.py	2015-02-06 13:37:58 +0000
+++ lib/lp/registry/model/persondistributionsourcepackage.py	2015-02-26 14:40:55 +0000
@@ -37,3 +37,12 @@
     def displayname(self):
         return '%s in %s' % (
             self.person.displayname, self.distro_source_package.displayname)
+
+    def __eq__(self, other):
+        return (
+            IPersonDistributionSourcePackage.providedBy(other) and
+            self.person.id == other.person.id and
+            self.distro_source_package == other.distro_source_package)
+
+    def __ne__(self, other):
+        return not self == other
 
=== modified file 'lib/lp/registry/model/personproduct.py'
--- lib/lp/registry/model/personproduct.py	2011-12-19 23:38:16 +0000
+++ lib/lp/registry/model/personproduct.py	2015-02-26 14:40:55 +0000
@@ -38,3 +38,12 @@
     def displayname(self):
         return '%s in %s' % (
             self.person.displayname, self.product.displayname)
+
+    def __eq__(self, other):
+        return (
+            IPersonProduct.providedBy(other) and
+            self.person.id == other.person.id and
+            self.product.id == other.product.id)
+
+    def __ne__(self, other):
+        return not self == other