Merge lp:~cjwatson/launchpad/relax-personal-git-mp-restrictions into lp:launchpad

[Colin Watson]

Allow proposing merges between different branches of the same personal Git repository.

[William Grant (wgrant)]

Why is the suggestion widget now sometimes called on a GitRef rather than a GitRepository?

review: Approve (code)

[Colin Watson (cjwatson)]

> Why is the suggestion widget now sometimes called on a GitRef rather than a
> GitRepository?

It was in fact always that way: it's essentially just because this widget is used on GitRef:+register-merge. It happened to work by chance because GitRef has lots of properties that pass through to the repository. I only noticed when I tried to set `target_repositories = [repository]` in the personal namespace case and found that the UI rendered it as something like "~owner/+git/repo:branch" rather than just "~owner/+git/repo".

I think it's reasonably worth handling both even though we only use the GitRef case today, since we often want to expose similar operations on GitRef and GitRepository: for example, once we have a better ref picker I can well imagine wanting to add GitRepository:+register-merge.

=== modified file 'lib/lp/app/widgets/suggestion.py'
--- lib/lp/app/widgets/suggestion.py	2016-01-12 12:28:09 +0000
+++ lib/lp/app/widgets/suggestion.py	2018-07-11 08:48:06 +0000
@@ -1,4 +1,4 @@
-# Copyright 2009-2016 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Widgets related to IBranch."""
@@ -34,7 +34,9 @@
 
 from lp.app.widgets.itemswidgets import LaunchpadRadioWidget
 from lp.code.interfaces.gitcollection import IGitCollection
+from lp.code.interfaces.gitref import IGitRef
 from lp.code.interfaces.gitrepository import IGitRepositorySet
+from lp.registry.interfaces.person import IPerson
 from lp.services.webapp import canonical_url
 from lp.services.webapp.escaping import (
     html_escape,
@@ -295,31 +297,42 @@
     """
 
     @staticmethod
-    def _generateSuggestionVocab(repository, full_vocabulary):
+    def _generateSuggestionVocab(context, full_vocabulary):
         """Generate the vocabulary for the radio buttons.
 
         The generated vocabulary contains the default repository for the
         target if there is one, and also any other repositories that the
         user has specified recently as a target for a proposed merge.
         """
-        default_target = getUtility(IGitRepositorySet).getDefaultRepository(
-            repository.target)
-        logged_in_user = getUtility(ILaunchBag).user
-        since = datetime.now(utc) - timedelta(days=90)
-        collection = IGitCollection(repository.target).targetedBy(
-            logged_in_user, since)
-        collection = collection.visibleByUser(logged_in_user)
-        # May actually need some eager loading, but the API isn't fine grained
-        # yet.
-        repositories = collection.getRepositories(eager_load=False).config(
-            distinct=True)
-        target_repositories = list(repositories.config(limit=5))
-        # If there is a default repository, make sure it is always shown,
-        # and as the first item.
-        if default_target is not None:
-            if default_target in target_repositories:
-                target_repositories.remove(default_target)
-            target_repositories.insert(0, default_target)
+        if IGitRef.providedBy(context):
+            repository = context.repository
+        else:
+            repository = context
+
+        if IPerson.providedBy(repository.target):
+            # If the source is a personal repository, then the only valid
+            # target is that same repository.
+            target_repositories = [repository]
+        else:
+            repository_set = getUtility(IGitRepositorySet)
+            default_target = repository_set.getDefaultRepository(
+                repository.target)
+            logged_in_user = getUtility(ILaunchBag).user
+            since = datetime.now(utc) - timedelta(days=90)
+            collection = IGitCollection(repository.target).targetedBy(
+                logged_in_user, since)
+            collection = collection.visibleByUser(logged_in_user)
+            # May actually need some eager loading, but the API isn't fine
+            # grained yet.
+            repositories = collection.getRepositories(eager_load=False).config(
+                distinct=True)
+            target_repositories = list(repositories.config(limit=5))
+            # If there is a default repository, make sure it is always
+            # shown, and as the first item.
+            if default_target is not None:
+                if default_target in target_repositories:
+                    target_repositories.remove(default_target)
+                target_repositories.insert(0, default_target)
 
         terms = []
         for repository in target_repositories:
@@ -335,10 +348,12 @@
         # instead to have a separate link to the repository details.
         text = u'%s (<a href="%s">repository details</a>)'
         # If the repository is the default for the target, say so.
-        default_target = getUtility(IGitRepositorySet).getDefaultRepository(
-            repository.target)
-        if repository == default_target:
-            text += u"&ndash; <em>default repository</em>"
+        if not IPerson.providedBy(repository.target):
+            repository_set = getUtility(IGitRepositorySet)
+            default_target = repository_set.getDefaultRepository(
+                repository.target)
+            if repository == default_target:
+                text += u"&ndash; <em>default repository</em>"
         label = (
             u'<label for="%s" style="font-weight: normal">' + text +
             u'</label>')
 
=== modified file 'lib/lp/app/widgets/tests/test_suggestion.py'
--- lib/lp/app/widgets/tests/test_suggestion.py	2015-07-08 16:05:11 +0000
+++ lib/lp/app/widgets/tests/test_suggestion.py	2018-07-11 08:48:06 +0000
@@ -1,4 +1,4 @@
-# Copyright 2011-2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2011-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 __metaclass__ = type
@@ -199,11 +199,11 @@
             DocTestMatches(expected, self.doctest_opts))
 
 
-def make_target_git_repository_widget(repository):
-    """Given a Git repository, return a widget for selecting where to land
-    it."""
+def make_target_git_repository_widget(context):
+    """Given a Git repository or reference, return a widget for selecting
+    where to land it."""
     choice = Choice(__name__='test_field', vocabulary='GitRepository')
-    choice = choice.bind(repository)
+    choice = choice.bind(context)
     request = LaunchpadTestRequest()
     return TargetGitRepositoryWidget(choice, None, request)
 
@@ -216,41 +216,79 @@
         doctest.NORMALIZE_WHITESPACE | doctest.REPORT_NDIFF |
         doctest.ELLIPSIS)
 
-    def makeRepositoryAndOldMergeProposal(self, timedelta):
-        """Make an old merge proposal and a repository with the same target."""
+    def makeRefAndOldMergeProposal(self, timedelta):
+        """Make an old merge proposal and a ref with the same target."""
         bmp = self.factory.makeBranchMergeProposalForGit(
             date_created=datetime.now(utc) - timedelta)
         login_person(bmp.registrant)
-        target = bmp.target_git_repository
-        return target, self.factory.makeGitRepository(target=target.target)
+        target = bmp.merge_target
+        return target, self.factory.makeGitRefs(target=target.target)[0]
 
     def test_recent_target(self):
         """Targets for proposals newer than 90 days are included."""
-        target, source = self.makeRepositoryAndOldMergeProposal(
-            timedelta(days=89))
+        target, source = self.makeRefAndOldMergeProposal(timedelta(days=89))
         widget = make_target_git_repository_widget(source)
-        self.assertIn(target, widget.suggestion_vocab)
+        self.assertIn(target.repository, widget.suggestion_vocab)
 
     def test_stale_target(self):
         """Targets for proposals older than 90 days are not considered."""
-        target, source = self.makeRepositoryAndOldMergeProposal(
-            timedelta(days=91))
-        widget = make_target_git_repository_widget(source)
-        self.assertNotIn(target, widget.suggestion_vocab)
+        target, source = self.makeRefAndOldMergeProposal(timedelta(days=91))
+        widget = make_target_git_repository_widget(source)
+        self.assertNotIn(target.repository, widget.suggestion_vocab)
+
+    def test_personal_repository(self):
+        """Proposals for personal repositories only suggest that repository."""
+        owner = self.factory.makePerson()
+        this_source, this_target = self.factory.makeGitRefs(
+            owner=owner, target=owner,
+            paths=[u"refs/heads/source", u"refs/heads/target"])
+        bmp = self.factory.makeBranchMergeProposalForGit(
+            source_ref=this_source, target_ref=this_target,
+            date_created=datetime.now(utc) - timedelta(days=1))
+        other_source, other_target = self.factory.makeGitRefs(
+            owner=owner, target=owner,
+            paths=[u"refs/heads/source", u"refs/heads/target"])
+        self.factory.makeBranchMergeProposalForGit(
+            source_ref=other_source, target_ref=other_target,
+            date_created=datetime.now(utc) - timedelta(days=1))
+        login_person(bmp.registrant)
+        [source] = self.factory.makeGitRefs(repository=this_target.repository)
+        widget = make_target_git_repository_widget(source)
+        self.assertContentEqual(
+            [this_target.repository],
+            [term.value for term in widget.suggestion_vocab])
 
     def test__renderSuggestionLabel(self):
         """Git repositories have a reasonable suggestion label."""
-        target, source = self.makeRepositoryAndOldMergeProposal(
-            timedelta(days=1))
+        target, source = self.makeRefAndOldMergeProposal(timedelta(days=1))
         login_person(target.target.owner)
         getUtility(IGitRepositorySet).setDefaultRepository(
-            target.target, target)
+            target.target, target.repository)
         widget = make_target_git_repository_widget(source)
         expected = (
             """<label for="field.test_field.2"
             ...>... (<a href="...">repository details</a>)&ndash;
             <em>default repository</em></label>""")
-        structured_string = widget._renderSuggestionLabel(target, 2)
+        structured_string = widget._renderSuggestionLabel(target.repository, 2)
+        self.assertThat(
+            structured_string.escapedtext,
+            DocTestMatches(expected, self.doctest_opts))
+
+    def test__renderSuggestionLabel_personal(self):
+        """Personal Git repositories have a reasonable suggestion label."""
+        owner = self.factory.makePerson()
+        source, target = self.factory.makeGitRefs(
+            owner=owner, target=owner,
+            paths=[u"refs/heads/source", u"refs/heads/target"])
+        bmp = self.factory.makeBranchMergeProposalForGit(
+            source_ref=source, target_ref=target,
+            date_created=datetime.now(utc) - timedelta(days=1))
+        login_person(bmp.registrant)
+        widget = make_target_git_repository_widget(source)
+        expected = (
+            """<label for="field.test_field.2"
+            ...>... (<a href="...">repository details</a>)</label>""")
+        structured_string = widget._renderSuggestionLabel(target.repository, 2)
         self.assertThat(
             structured_string.escapedtext,
             DocTestMatches(expected, self.doctest_opts))
 
=== modified file 'lib/lp/code/interfaces/gitnamespace.py'
--- lib/lp/code/interfaces/gitnamespace.py	2016-10-14 17:25:51 +0000
+++ lib/lp/code/interfaces/gitnamespace.py	2018-07-11 08:48:06 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Interface for a Git repository namespace."""
@@ -178,8 +178,12 @@
             already exists in the namespace.
         """
 
-    def areRepositoriesMergeable(other_namespace):
-        """Are repositories from other_namespace mergeable into this one?"""
+    def areRepositoriesMergeable(this, other):
+        """Is `other` mergeable into `this`?
+
+        :param this: An `IGitRepository` in this namespace.
+        :param other: An `IGitRepository` in either this or another namespace.
+        """
 
     collection = Attribute("An `IGitCollection` for this namespace.")
 
 
=== modified file 'lib/lp/code/model/gitnamespace.py'
--- lib/lp/code/model/gitnamespace.py	2018-05-14 08:01:56 +0000
+++ lib/lp/code/model/gitnamespace.py	2018-07-11 08:48:06 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Implementations of `IGitNamespace`."""
@@ -250,7 +250,7 @@
 
     has_defaults = False
     allow_push_to_set_default = False
-    supports_merge_proposals = False
+    supports_merge_proposals = True
     supports_code_imports = False
     allow_recipe_name_from_target = False
 
@@ -303,15 +303,17 @@
         else:
             return InformationType.PUBLIC
 
-    def areRepositoriesMergeable(self, other_namespace):
+    def areRepositoriesMergeable(self, this, other):
         """See `IGitNamespacePolicy`."""
-        return False
+        if this.namespace != self:
+            raise AssertionError(
+                "Namespace of %s is not %s." % (this.unique_name, self.name))
+        return this == other
 
     @property
     def collection(self):
         """See `IGitNamespacePolicy`."""
-        return getUtility(IAllGitRepositories).ownedBy(
-            self.person).isPersonal()
+        return getUtility(IAllGitRepositories).ownedBy(self.owner).isPersonal()
 
     def assignKarma(self, person, action_name, date_created=None):
         """See `IGitNamespacePolicy`."""
@@ -383,12 +385,16 @@
             return None
         return default_type
 
-    def areRepositoriesMergeable(self, other_namespace):
+    def areRepositoriesMergeable(self, this, other):
         """See `IGitNamespacePolicy`."""
         # Repositories are mergeable into a project repository if the
         # project is the same.
         # XXX cjwatson 2015-04-18: Allow merging from a package repository
         # if any (active?) series is linked to this project.
+        if this.namespace != self:
+            raise AssertionError(
+                "Namespace of %s is not %s." % (this.unique_name, self.name))
+        other_namespace = other.namespace
         if zope_isinstance(other_namespace, ProjectGitNamespace):
             return self.target == other_namespace.target
         else:
@@ -457,12 +463,16 @@
         """See `IGitNamespace`."""
         return InformationType.PUBLIC
 
-    def areRepositoriesMergeable(self, other_namespace):
+    def areRepositoriesMergeable(self, this, other):
         """See `IGitNamespacePolicy`."""
         # Repositories are mergeable into a package repository if the
         # package is the same.
         # XXX cjwatson 2015-04-18: Allow merging from a project repository
         # if any (active?) series links this package to that project.
+        if this.namespace != self:
+            raise AssertionError(
+                "Namespace of %s is not %s." % (this.unique_name, self.name))
+        other_namespace = other.namespace
         if zope_isinstance(other_namespace, PackageGitNamespace):
             return self.target == other_namespace.target
         else:
 
=== modified file 'lib/lp/code/model/gitrepository.py'
--- lib/lp/code/model/gitrepository.py	2017-11-24 17:22:34 +0000
+++ lib/lp/code/model/gitrepository.py	2018-07-11 08:48:06 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015-2017 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 __metaclass__ = type
@@ -946,7 +946,7 @@
 
     def isRepositoryMergeable(self, other):
         """See `IGitRepository`."""
-        return self.namespace.areRepositoriesMergeable(other.namespace)
+        return self.namespace.areRepositoriesMergeable(self, other)
 
     @property
     def pending_updates(self):
 
=== modified file 'lib/lp/code/model/tests/test_gitnamespace.py'
--- lib/lp/code/model/tests/test_gitnamespace.py	2017-10-04 01:29:35 +0000
+++ lib/lp/code/model/tests/test_gitnamespace.py	2018-07-11 08:48:06 +0000
@@ -1,4 +1,4 @@
-# Copyright 2015-2017 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2018 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Tests for `IGitNamespace` implementations."""
@@ -278,6 +278,70 @@
         namespace = PersonalGitNamespace(person)
         self.assertEqual(person, namespace.target)
 
+    def test_supports_merge_proposals(self):
+        # Personal namespaces support merge proposals.
+        self.assertTrue(self.getNamespace().supports_merge_proposals)
+
+    def test_areRepositoriesMergeable_same_repository(self):
+        # A personal repository is mergeable into itself.
+        owner = self.factory.makePerson()
+        repository = self.factory.makeGitRepository(owner=owner, target=owner)
+        self.assertTrue(
+            repository.namespace.areRepositoriesMergeable(
+                repository, repository))
+
+    def test_areRepositoriesMergeable_same_namespace(self):
+        # A personal repository is not mergeable into another personal
+        # repository, even if they are in the same namespace.
+        owner = self.factory.makePerson()
+        this = self.factory.makeGitRepository(owner=owner, target=owner)
+        other = self.factory.makeGitRepository(owner=owner, target=owner)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_different_namespace(self):
+        # A personal repository is not mergeable into another personal
+        # repository with a different namespace.
+        this_owner = self.factory.makePerson()
+        this = self.factory.makeGitRepository(
+            owner=this_owner, target=this_owner)
+        other_owner = self.factory.makePerson()
+        other = self.factory.makeGitRepository(
+            owner=other_owner, target=other_owner)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_project(self):
+        # Project repositories are not mergeable into personal repositories.
+        owner = self.factory.makePerson()
+        this = self.factory.makeGitRepository(owner=owner, target=owner)
+        project = self.factory.makeProduct()
+        other = self.factory.makeGitRepository(owner=owner, target=project)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_package(self):
+        # Package repositories are not mergeable into personal repositories.
+        owner = self.factory.makePerson()
+        this = self.factory.makeGitRepository(owner=owner, target=owner)
+        dsp = self.factory.makeDistributionSourcePackage()
+        other = self.factory.makeGitRepository(owner=owner, target=dsp)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_collection(self):
+        # A personal namespace's collection is of personal repositories with
+        # the same owner.
+        owner = self.factory.makePerson()
+        repositories = [
+            self.factory.makeGitRepository(owner=owner, target=owner)
+            for _ in range(3)]
+        other_owner = self.factory.makePerson()
+        self.factory.makeGitRepository(owner=other_owner, target=other_owner)
+        self.factory.makeGitRepository(
+            owner=owner, target=self.factory.makeProduct())
+        self.factory.makeGitRepository(
+            owner=owner, target=self.factory.makeDistributionSourcePackage())
+        self.assertContentEqual(
+            repositories,
+            repositories[0].namespace.collection.getRepositories())
+
 
 class TestProjectGitNamespace(TestCaseWithFactory, NamespaceMixin):
     """Tests for `ProjectGitNamespace`."""
@@ -312,6 +376,65 @@
         namespace = ProjectGitNamespace(person, project)
         self.assertEqual(project, namespace.target)
 
+    def test_supports_merge_proposals(self):
+        # Project namespaces support merge proposals.
+        self.assertTrue(self.getNamespace().supports_merge_proposals)
+
+    def test_areRepositoriesMergeable_same_repository(self):
+        # A project repository is mergeable into itself.
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(target=project)
+        self.assertTrue(
+            repository.namespace.areRepositoriesMergeable(
+                repository, repository))
+
+    def test_areRepositoriesMergeable_same_namespace(self):
+        # Repositories of the same project are mergeable.
+        project = self.factory.makeProduct()
+        this = self.factory.makeGitRepository(target=project)
+        other = self.factory.makeGitRepository(target=project)
+        self.assertTrue(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_different_namespace(self):
+        # Repositories of a different project are not mergeable.
+        this_project = self.factory.makeProduct()
+        this = self.factory.makeGitRepository(target=this_project)
+        other_project = self.factory.makeProduct()
+        other = self.factory.makeGitRepository(target=other_project)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_personal(self):
+        # Personal repositories are not mergeable into project repositories.
+        owner = self.factory.makePerson()
+        project = self.factory.makeProduct()
+        this = self.factory.makeGitRepository(owner=owner, target=project)
+        other = self.factory.makeGitRepository(owner=owner, target=owner)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_package(self):
+        # Package repositories are not mergeable into project repositories.
+        owner = self.factory.makePerson()
+        project = self.factory.makeProduct()
+        this = self.factory.makeGitRepository(owner=owner, target=project)
+        dsp = self.factory.makeDistributionSourcePackage()
+        other = self.factory.makeGitRepository(owner=owner, target=dsp)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_collection(self):
+        # A project namespace's collection is of repositories for the same
+        # project.
+        project = self.factory.makeProduct()
+        repositories = [
+            self.factory.makeGitRepository(target=project) for _ in range(3)]
+        self.factory.makeGitRepository(target=self.factory.makeProduct())
+        self.factory.makeGitRepository(
+            owner=repositories[0].owner, target=repositories[0].owner)
+        self.factory.makeGitRepository(
+            target=self.factory.makeDistributionSourcePackage())
+        self.assertContentEqual(
+            repositories,
+            repositories[0].namespace.collection.getRepositories())
+
 
 class TestProjectGitNamespacePrivacyWithInformationType(TestCaseWithFactory):
     """Tests for the privacy aspects of `ProjectGitNamespace`.
@@ -521,6 +644,65 @@
         namespace = PackageGitNamespace(person, dsp)
         self.assertEqual(dsp, namespace.target)
 
+    def test_supports_merge_proposals(self):
+        # Package namespaces support merge proposals.
+        self.assertTrue(self.getNamespace().supports_merge_proposals)
+
+    def test_areRepositoriesMergeable_same_repository(self):
+        # A package repository is mergeable into itself.
+        dsp = self.factory.makeDistributionSourcePackage()
+        repository = self.factory.makeGitRepository(target=dsp)
+        self.assertTrue(
+            repository.namespace.areRepositoriesMergeable(
+                repository, repository))
+
+    def test_areRepositoriesMergeable_same_namespace(self):
+        # Repositories of the same package are mergeable.
+        dsp = self.factory.makeDistributionSourcePackage()
+        this = self.factory.makeGitRepository(target=dsp)
+        other = self.factory.makeGitRepository(target=dsp)
+        self.assertTrue(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_different_namespace(self):
+        # Repositories of a different package are not mergeable.
+        this_dsp = self.factory.makeDistributionSourcePackage()
+        this = self.factory.makeGitRepository(target=this_dsp)
+        other_dsp = self.factory.makeDistributionSourcePackage()
+        other = self.factory.makeGitRepository(target=other_dsp)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_personal(self):
+        # Personal repositories are not mergeable into package repositories.
+        owner = self.factory.makePerson()
+        dsp = self.factory.makeProduct()
+        this = self.factory.makeGitRepository(owner=owner, target=dsp)
+        other = self.factory.makeGitRepository(owner=owner, target=owner)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_project(self):
+        # Project repositories are not mergeable into package repositories.
+        owner = self.factory.makePerson()
+        dsp = self.factory.makeDistributionSourcePackage()
+        this = self.factory.makeGitRepository(owner=owner, target=dsp)
+        project = self.factory.makeProduct()
+        other = self.factory.makeGitRepository(owner=owner, target=project)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_collection(self):
+        # A package namespace's collection is of repositories for the same
+        # package.
+        dsp = self.factory.makeDistributionSourcePackage()
+        repositories = [
+            self.factory.makeGitRepository(target=dsp) for _ in range(3)]
+        self.factory.makeGitRepository(
+            target=self.factory.makeDistributionSourcePackage())
+        self.factory.makeGitRepository(target=self.factory.makeProduct())
+        self.factory.makeGitRepository(
+            owner=repositories[0].owner, target=repositories[0].owner)
+        self.assertContentEqual(
+            repositories,
+            repositories[0].namespace.collection.getRepositories())
+
 
 class BaseCanCreateRepositoriesMixin:
     """Common tests for all namespaces."""
 
=== modified file 'lib/lp/code/model/tests/test_gitref.py'
--- lib/lp/code/model/tests/test_gitref.py	2017-10-04 01:29:35 +0000
+++ lib/lp/code/model/tests/test_gitref.py	2018-07-11 08:48:06 +0000
@@ -301,14 +301,25 @@
         else:
             self.assertEqual(review_type, vote.review_type)
 
-    def test_personal_source(self):
-        """Personal repositories cannot be used as a source for MPs."""
+    def test_personal_source_project_target(self):
+        """Personal repositories cannot be used as a source for MPs to
+        project repositories.
+        """
         self.source.repository.setTarget(
             target=self.source.owner, user=self.source.owner)
         self.assertRaises(
             InvalidBranchMergeProposal, self.source.addLandingTarget,
             self.user, self.target)
 
+    def test_personal_source_personal_target(self):
+        """A branch in a personal repository can be used as a source for MPs
+        to another branch in the same personal repository.
+        """
+        self.target.repository.setTarget(
+            target=self.target.owner, user=self.target.owner)
+        [source] = self.factory.makeGitRefs(repository=self.target.repository)
+        source.addLandingTarget(self.user, self.target)
+
     def test_target_repository_same_target(self):
         """The target repository's target must match that of the source."""
         self.target.repository.setTarget(