Merge ~twom/launchpad:oci-gitrepository into launchpad:master

[Tom Wardill]

Add GitNamespace for OCIProjects

The addition of the ociprojectname column to GitRepository requires a working Namespace implementation.

Add the model, following the pattern from DistributionSourcePackage.
Add tests for the model
Add required helper methods to IDistribution

[Colin Watson (cjwatson)]

There's a bit of an impedance mismatch between the design of OCIProject and what various things here expect, isn't there? Probably not much we can do about that (it's better than duplicating the table for project-based OCIProjects), but let's tighten things up a bit.

You've also missed a few bits, some of which should be done now and some of which can probably be done later, but I'll list all the ones I can think of so that they make it onto your to-do list somewhere:

 * GenericGitCollection.preloadDataForRepositories needs to preload related OCIProjectName rows.
 * The third paragraph of the docstring of IGitRepositoryView.getRepositoryIdentities needs updating.
 * It doesn't look like you've touched the lookup machinery that allows you to get a repository by its unique name or path. It's fine to do that in a separate merge proposal if you prefer, but it should come soon. When you do, remember to update the docstrings of IGitLookup.getByUniqueName and IGitRepositorySet.getByPath.
 * lp.code.browser.gitlisting will need attention so that it's possible to list repositories for an OCIProject. This will probably have to be in a separate merge proposal, since I don't think you have the navigation machinery for OCIProjects yet.
 * lp.code.browser.widgets.gitrepositorytarget will need attention. This can definitely be later, once we're ready for people to create these repositories.

review: Needs Fixing

55011ed... by Tom Wardill on 2019-11-01

Rename OCIProjectGitNamespace to DistributionOCIGitNamespace

43c54f9... by Tom Wardill on 2019-11-01

Assert for IDistribution in gitcollection

50f513c... by Tom Wardill on 2019-11-01

Ensure we have a distribution in gitnamespace

0874f50... by Tom Wardill on 2019-11-01

Add name property to OCIProject

575049c... by Tom Wardill on 2019-11-04

At most one target

a1fa70f... by Tom Wardill on 2019-11-04

Assert we have the right thing

824d2b9... by Tom Wardill on 2019-11-04

Gitnamespace test fixes

07ce4ee... by Tom Wardill on 2019-11-04

Test cleanups, no need to use ociprojectname everywhere

77ce71f... by Tom Wardill on 2019-11-04

Preload OCIProjectName

95cf373... by Tom Wardill on 2019-11-04

Update docstring to mention OCI projects

[Colin Watson (cjwatson)]

review: Approve

[Colin Watson (cjwatson)]

Note that the corresponding DB patch is still pending review (https://code.launchpad.net/~cjwatson/launchpad/+git/launchpad/+merge/374672).

da868e2... by Tom Wardill on 2019-11-04

Ordering tweaks

2c4646f... by Tom Wardill on 2019-11-04

Better AssertionError

6e6544c... by Tom Wardill on 2019-11-04

Add more test, inherit in the right place

689f5e6... by Tom Wardill on 2019-11-25

Don't export this yet

635ea87... by Tom Wardill on 2019-11-25

Remove interface declaration for ociprojectname entirely

d921f65... by Tom Wardill on 2019-11-27

Fix failing distribution test

diff --git a/lib/lp/code/configure.zcml b/lib/lp/code/configure.zcml
index 0ae4a3c..ef98d7f 100644
--- a/lib/lp/code/configure.zcml
+++ b/lib/lp/code/configure.zcml
@@ -894,6 +894,10 @@
     <allow interface="lp.code.interfaces.gitnamespace.IGitNamespace" />
     <allow interface="lp.code.interfaces.gitnamespace.IGitNamespacePolicy" />
   </class>
+  <class class="lp.code.model.gitnamespace.DistributionOCIGitNamespace">
+    <allow interface="lp.code.interfaces.gitnamespace.IGitNamespace" />
+    <allow interface="lp.code.interfaces.gitnamespace.IGitNamespacePolicy" />
+  </class>
   <securedutility
       class="lp.code.model.gitnamespace.GitNamespaceSet"
       provides="lp.code.interfaces.gitnamespace.IGitNamespaceSet">
diff --git a/lib/lp/code/interfaces/gitcollection.py b/lib/lp/code/interfaces/gitcollection.py
index 4ab976b..90ab25e 100644
--- a/lib/lp/code/interfaces/gitcollection.py
+++ b/lib/lp/code/interfaces/gitcollection.py
@@ -138,6 +138,9 @@ class IGitCollection(Interface):
     def inDistributionSourcePackage(distro_source_package):
         """Restrict to repositories in a package for a distribution."""
 
+    def inOCIProject(oci_project):
+        """Restrict to repositories in an OCI Project."""
+
     def isPersonal():
         """Restrict the collection to personal repositories."""
 
diff --git a/lib/lp/code/interfaces/gitnamespace.py b/lib/lp/code/interfaces/gitnamespace.py
index 99841d7..eb4ebc4 100644
--- a/lib/lp/code/interfaces/gitnamespace.py
+++ b/lib/lp/code/interfaces/gitnamespace.py
@@ -22,6 +22,7 @@ from lp.code.errors import InvalidNamespace
 from lp.registry.interfaces.distributionsourcepackage import (
     IDistributionSourcePackage,
     )
+from lp.registry.interfaces.ociproject import IOCIProject
 from lp.registry.interfaces.person import IPerson
 from lp.registry.interfaces.product import IProduct
 
@@ -198,7 +199,8 @@ class IGitNamespacePolicy(Interface):
 class IGitNamespaceSet(Interface):
     """Interface for getting Git repository namespaces."""
 
-    def get(person, project=None, distribution=None, sourcepackagename=None):
+    def get(person, project=None, distribution=None, sourcepackagename=None,
+            ociprojectname=None):
         """Return the appropriate `IGitNamespace` for the given objects."""
 
 
@@ -209,6 +211,12 @@ def get_git_namespace(target, owner):
         return getUtility(IGitNamespaceSet).get(
             owner, distribution=target.distribution,
             sourcepackagename=target.sourcepackagename)
+    elif IOCIProject.providedBy(target):
+        # This will eventually be allowable, but is not right now.
+        assert target.distribution is not None
+        return getUtility(IGitNamespaceSet).get(
+            owner, distribution=target.distribution,
+            ociprojectname=target.ociprojectname)
     elif target is None or IPerson.providedBy(target):
         return getUtility(IGitNamespaceSet).get(owner)
     else:
diff --git a/lib/lp/code/interfaces/gitrepository.py b/lib/lp/code/interfaces/gitrepository.py
index 2fca251..25be4a5 100644
--- a/lib/lp/code/interfaces/gitrepository.py
+++ b/lib/lp/code/interfaces/gitrepository.py
@@ -73,6 +73,7 @@ from lp.code.interfaces.hasrecipes import IHasRecipes
 from lp.registry.interfaces.distributionsourcepackage import (
     IDistributionSourcePackage,
     )
+from lp.registry.interfaces.ociprojectname import IOCIProjectName
 from lp.registry.interfaces.person import IPerson
 from lp.registry.interfaces.persondistributionsourcepackage import (
     IPersonDistributionSourcePackageFactory,
@@ -406,9 +407,10 @@ class IGitRepositoryView(IHasRecipes):
         itself.  For default repositories, the context object is the
         appropriate default object.
 
-        Where a repository is the default for a product or a distribution
-        source package, the repository is available through a number of
-        different URLs.  These URLs are the aliases for the repository.
+        Where a repository is the default for a product, distribution
+        source package or OCI project, the repository is available
+        through a number of different URLs.
+        These URLs are the aliases for the repository.
 
         For example, a repository which is the default for the 'fooix'
         project and which is also its owner's default repository for that
diff --git a/lib/lp/code/model/gitcollection.py b/lib/lp/code/model/gitcollection.py
index 70f6d01..552ea24 100644
--- a/lib/lp/code/model/gitcollection.py
+++ b/lib/lp/code/model/gitcollection.py
@@ -52,7 +52,9 @@ from lp.code.model.gitrepository import (
 from lp.code.model.gitrule import GitRuleGrant
 from lp.code.model.gitsubscription import GitSubscription
 from lp.registry.enums import EXCLUSIVE_TEAM_POLICY
+from lp.registry.interfaces.distribution import IDistribution
 from lp.registry.model.distribution import Distribution
+from lp.registry.model.ociprojectname import OCIProjectName
 from lp.registry.model.person import Person
 from lp.registry.model.product import Product
 from lp.registry.model.sourcepackagename import SourcePackageName
@@ -199,6 +201,7 @@ class GenericGitCollection:
         load_related(Distribution, repositories, ['distribution_id'])
         load_related(SourcePackageName, repositories, ['sourcepackagename_id'])
         load_related(Product, repositories, ['project_id'])
+        load_related(OCIProjectName, repositories, ['ociprojectname_id'])
         caches = {
             repository.id: get_property_cache(repository)
             for repository in repositories}
@@ -458,6 +461,16 @@ class GenericGitCollection:
             [GitRepository.distribution == distribution,
              GitRepository.sourcepackagename == sourcepackagename])
 
+    def inOCIProject(self, oci_project):
+        """See `IGitCollection`."""
+        # XXX twom 2019-11-01 This will eventually have project support
+        assert IDistribution.providedBy(oci_project.pillar)
+        distribution = oci_project.pillar
+        ociprojectname = oci_project.ociprojectname
+        return self._filterBy(
+            [GitRepository.distribution == distribution,
+             GitRepository.ociprojectname == ociprojectname])
+
     def isPersonal(self):
         """See `IGitCollection`."""
         return self._filterBy(
diff --git a/lib/lp/code/model/gitnamespace.py b/lib/lp/code/model/gitnamespace.py
index 4fb56e3..a255c5a 100644
--- a/lib/lp/code/model/gitnamespace.py
+++ b/lib/lp/code/model/gitnamespace.py
@@ -5,6 +5,7 @@
 
 __metaclass__ = type
 __all__ = [
+    'DistributionOCIGitNamespace',
     'GitNamespaceSet',
     'PackageGitNamespace',
     'PersonalGitNamespace',
@@ -316,6 +317,7 @@ class PersonalGitNamespace(_BaseGitNamespace):
         repository.project = None
         repository.distribution = None
         repository.sourcepackagename = None
+        repository.ociprojectname = None
         repository.target_default = False
         repository.owner_default = False
 
@@ -396,6 +398,7 @@ class ProjectGitNamespace(_BaseGitNamespace):
         repository.project = self.project
         repository.distribution = None
         repository.sourcepackagename = None
+        repository.ociprojectname = None
 
     def getAllowedInformationTypes(self, who=None):
         """See `IGitNamespace`."""
@@ -491,6 +494,7 @@ class PackageGitNamespace(_BaseGitNamespace):
         repository.project = None
         repository.distribution = dsp.distribution
         repository.sourcepackagename = dsp.sourcepackagename
+        repository.ociprojectname = None
 
     def getAllowedInformationTypes(self, who=None):
         """See `IGitNamespace`."""
@@ -538,24 +542,121 @@ class PackageGitNamespace(_BaseGitNamespace):
             self_dsp.sourcepackagename == other_dsp.sourcepackagename)
 
 
+@implementer(IGitNamespace, IGitNamespacePolicy)
+class DistributionOCIGitNamespace(_BaseGitNamespace):
+    """A namespace for OCI Project repositories.
+
+    This namespace is for all the repositories owned by a particular person
+    in a particular OCI Project in a particular distribution.
+    """
+
+    has_defaults = True
+    allow_push_to_set_default = False
+    supports_merge_proposals = True
+    supports_code_imports = True
+    allow_recipe_name_from_target = True
+
+    def __init__(self, person, oci_project):
+        self.owner = person
+        # Ensure we have a valid target for this namespace
+        assert oci_project.distribution is not None
+        self.oci_project = oci_project
+
+    def _getRepositoriesClause(self):
+        return And(
+            GitRepository.owner == self.owner,
+            GitRepository.distribution == self.oci_project.distribution,
+            GitRepository.ociprojectname == self.oci_project.ociprojectname)
+
+    # Marker for references to Git URL layouts: ##GITNAMESPACE##
+    @property
+    def name(self):
+        """See `IGitNamespace`."""
+        ocip = self.oci_project
+        return '~%s/%s/+oci/%s' % (
+            self.owner.name, ocip.pillar.name, ocip.name)
+
+    @property
+    def target(self):
+        """See `IGitNamespace`."""
+        return IHasGitRepositories(self.oci_project)
+
+    def _retargetRepository(self, repository):
+        ocip = self.oci_project
+        repository.project = None
+        repository.distribution = ocip.distribution
+        repository.sourcepackagename = None
+        repository.ociprojectname = ocip.ociprojectname
+
+    def getAllowedInformationTypes(self, who=None):
+        """See `IGitNamespace`."""
+        return PUBLIC_INFORMATION_TYPES
+
+    def getDefaultInformationType(self, who=None):
+        """See `IGitNamespace`."""
+        return InformationType.PUBLIC
+
+    def areRepositoriesMergeable(self, this, other):
+        """See `IGitNamespacePolicy`."""
+        # Repositories are mergeable into an OCI Project repository if the
+        # OCI Project is the same.
+        # XXX cjwatson 2015-04-18: Allow merging from a project repository
+        # if any (active?) series links this OCI Project 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, DistributionOCIGitNamespace):
+            return self.target == other_namespace.target
+        else:
+            return False
+
+    @property
+    def collection(self):
+        """See `IGitNamespacePolicy`."""
+        return getUtility(IAllGitRepositories).inOCIProject(
+            self.oci_project)
+
+    def assignKarma(self, person, action_name, date_created=None):
+        """See `IGitNamespacePolicy`."""
+        # Does nothing. Currently no karma for OCI Project Namespaces.
+        return None
+
+
 @implementer(IGitNamespaceSet)
 class GitNamespaceSet:
     """Only implementation of `IGitNamespaceSet`."""
 
     def get(self, person, project=None, distribution=None,
-            sourcepackagename=None):
+            sourcepackagename=None, ociprojectname=None):
         """See `IGitNamespaceSet`."""
         if project is not None:
-            assert distribution is None and sourcepackagename is None, (
-                "project implies no distribution or sourcepackagename. "
-                "Got %r, %r, %r."
-                % (project, distribution, sourcepackagename))
+            assert (distribution is None and sourcepackagename is None
+                    and ociprojectname is None), (
+                "project implies no distribution, sourcepackagename"
+                " or ociprojectname. "
+                "Got %r, %r, %r, %r."
+                % (project, distribution, sourcepackagename, ociprojectname))
             return ProjectGitNamespace(person, project)
         elif distribution is not None:
-            assert sourcepackagename is not None, (
-                "distribution implies sourcepackagename. Got %r, %r"
-                % (distribution, sourcepackagename))
-            return PackageGitNamespace(
-                person, distribution.getSourcePackage(sourcepackagename))
+            assert (sourcepackagename is None or ociprojectname is None), (
+                "One of sourcepackagename and ociprojectname must be set."
+                "Got %r, %r."
+                % (sourcepackagename, ociprojectname))
+            assert not (sourcepackagename and ociprojectname), (
+                "Only one of sourcepackagename and ociprojectname can be set."
+                "Got %r, %r."
+                % (sourcepackagename, ociprojectname))
+            if sourcepackagename is not None:
+                return PackageGitNamespace(
+                    person, distribution.getSourcePackage(sourcepackagename))
+            elif ociprojectname is not None:
+                return DistributionOCIGitNamespace(
+                    person, distribution.getOCIProject(ociprojectname.name))
+            else:
+                raise AssertionError(
+                    "distribution implies sourcepackagename or "
+                    "ociprojectname. Got %r, %r, %r"
+                    % (distribution, sourcepackagename, ociprojectname))
         else:
             return PersonalGitNamespace(person)
diff --git a/lib/lp/code/model/gitrepository.py b/lib/lp/code/model/gitrepository.py
index 93a2d16..92b6308 100644
--- a/lib/lp/code/model/gitrepository.py
+++ b/lib/lp/code/model/gitrepository.py
@@ -150,9 +150,11 @@ from lp.registry.interfaces.accesspolicy import (
     IAccessArtifactSource,
     IAccessPolicySource,
     )
+from lp.registry.interfaces.distribution import IDistribution
 from lp.registry.interfaces.distributionsourcepackage import (
     IDistributionSourcePackage,
     )
+from lp.registry.interfaces.ociproject import IOCIProject
 from lp.registry.interfaces.person import (
     IPerson,
     IPersonSet,
@@ -308,6 +310,9 @@ class GitRepository(StormBase, WebhookTargetMixin, GitIdentityMixin):
     sourcepackagename_id = Int(name='sourcepackagename', allow_none=True)
     sourcepackagename = Reference(sourcepackagename_id, 'SourcePackageName.id')
 
+    ociprojectname_id = Int(name='ociprojectname', allow_none=True)
+    ociprojectname = Reference(ociprojectname_id, 'OCIProjectName.id')
+
     name = Unicode(name='name', allow_none=False)
 
     description = Unicode(name='description', allow_none=True)
@@ -339,6 +344,11 @@ class GitRepository(StormBase, WebhookTargetMixin, GitIdentityMixin):
         elif IDistributionSourcePackage.providedBy(target):
             self.distribution = target.distribution
             self.sourcepackagename = target.sourcepackagename
+        elif IOCIProject.providedBy(target):
+            # XXX twom 2019-10-28 This should have support for product
+            assert IDistribution.providedBy(target.pillar)
+            self.ociprojectname = target.ociprojectname
+            self.distribution = target.pillar
         self.owner_default = False
         self.target_default = False
 
@@ -367,10 +377,16 @@ class GitRepository(StormBase, WebhookTargetMixin, GitIdentityMixin):
         if self.project is not None:
             fmt = "~%(owner)s/%(project)s"
             names["project"] = self.project.name
-        elif self.distribution is not None:
+        elif (self.distribution is not None
+              and self.sourcepackagename is not None):
             fmt = "~%(owner)s/%(distribution)s/+source/%(source)s"
             names["distribution"] = self.distribution.name
             names["source"] = self.sourcepackagename.name
+        elif (self.distribution is not None
+              and self.ociprojectname is not None):
+            fmt = "~%(owner)s/%(distribution)s/+oci/%(ociproject)s"
+            names["distribution"] = self.distribution.name
+            names["ociproject"] = self.ociprojectname.name
         else:
             fmt = "~%(owner)s"
         fmt += "/+git/%(repository)s"
@@ -384,8 +400,12 @@ class GitRepository(StormBase, WebhookTargetMixin, GitIdentityMixin):
         """See `IGitRepository`."""
         if self.project is not None:
             return self.project
-        elif self.distribution is not None:
+        elif (self.distribution is not None
+              and self.sourcepackagename is not None):
             return self.distribution.getSourcePackage(self.sourcepackagename)
+        elif (self.distribution is not None
+              and self.ociprojectname is not None):
+            return self.distribution.getOCIProject(self.ociprojectname.name)
         else:
             return self.owner
 
diff --git a/lib/lp/code/model/tests/test_gitcollection.py b/lib/lp/code/model/tests/test_gitcollection.py
index bd80685..91f6e4b 100644
--- a/lib/lp/code/model/tests/test_gitcollection.py
+++ b/lib/lp/code/model/tests/test_gitcollection.py
@@ -381,6 +381,20 @@ class TestGitCollectionFilters(TestCaseWithFactory):
             sorted([repository, repository2]),
             sorted(collection.getRepositories()))
 
+    def test_in_oci_project(self):
+        # 'inOCIProject' returns a new collection that only
+        # has repositories for the oci project in the distribution.
+        ocip = self.factory.makeOCIProject()
+        ocip_other_distro = self.factory.makeOCIProject()
+        repository = self.factory.makeGitRepository(target=ocip)
+        repository2 = self.factory.makeGitRepository(target=ocip)
+        self.factory.makeGitRepository(target=ocip_other_distro)
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.inOCIProject(ocip)
+        self.assertEqual(
+            sorted([repository, repository2]),
+            sorted(collection.getRepositories()))
+
     def test_withIds(self):
         # 'withIds' returns a new collection that only has repositories with
         # the given ids.
diff --git a/lib/lp/code/model/tests/test_gitnamespace.py b/lib/lp/code/model/tests/test_gitnamespace.py
index 8e8696f..4f18523 100644
--- a/lib/lp/code/model/tests/test_gitnamespace.py
+++ b/lib/lp/code/model/tests/test_gitnamespace.py
@@ -31,6 +31,7 @@ from lp.code.interfaces.gitnamespace import (
     )
 from lp.code.interfaces.gitrepository import IGitRepositorySet
 from lp.code.model.gitnamespace import (
+    DistributionOCIGitNamespace,
     PackageGitNamespace,
     PersonalGitNamespace,
     ProjectGitNamespace,
@@ -325,6 +326,15 @@ class TestPersonalGitNamespace(TestCaseWithFactory, NamespaceMixin):
         other = self.factory.makeGitRepository(owner=owner, target=dsp)
         self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
 
+    def test_areRepositoriesMergeable_oci_project(self):
+        # OCI Project repositories are not mergeable into personal
+        # repositories.
+        owner = self.factory.makePerson()
+        this = self.factory.makeGitRepository(owner=owner, target=owner)
+        oci_project = self.factory.makeOCIProject()
+        other = self.factory.makeGitRepository(owner=owner, target=oci_project)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
     def test_collection(self):
         # A personal namespace's collection is of personal repositories with
         # the same owner.
@@ -420,6 +430,15 @@ class TestProjectGitNamespace(TestCaseWithFactory, NamespaceMixin):
         other = self.factory.makeGitRepository(owner=owner, target=dsp)
         self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
 
+    def test_areRepositoriesMergeable_oci_project(self):
+        # OCI Project repositories are not mergeable into project repositories.
+        owner = self.factory.makePerson()
+        project = self.factory.makeProduct()
+        this = self.factory.makeGitRepository(owner=owner, target=project)
+        oci_project = self.factory.makeOCIProject()
+        other = self.factory.makeGitRepository(owner=owner, target=oci_project)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
     def test_collection(self):
         # A project namespace's collection is of repositories for the same
         # project.
@@ -436,6 +455,111 @@ class TestProjectGitNamespace(TestCaseWithFactory, NamespaceMixin):
             repositories[0].namespace.collection.getRepositories())
 
 
+class TestDistributionOCIGitNamespace(TestCaseWithFactory, NamespaceMixin):
+    """Tests for `DistributionOCIGitNamespace`."""
+
+    layer = DatabaseFunctionalLayer
+
+    def getNamespace(self, person=None):
+        if person is None:
+            person = self.factory.makePerson()
+        return get_git_namespace(self.factory.makeOCIProject(), person)
+
+    def test_name(self):
+        person = self.factory.makePerson()
+        oci_project = self.factory.makeOCIProject()
+        namespace = DistributionOCIGitNamespace(person, oci_project)
+        self.assertEqual(
+            "~%s/%s/+oci/%s" % (
+                person.name, oci_project.distribution.name,
+                oci_project.ociprojectname.name),
+            namespace.name)
+
+    def test_owner(self):
+        # The person passed to an oci project namespace is the owner.
+        person = self.factory.makePerson()
+        oci_project = self.factory.makeOCIProject()
+        namespace = DistributionOCIGitNamespace(person, oci_project)
+        self.assertEqual(person, removeSecurityProxy(namespace).owner)
+
+    def test_target(self):
+        # The target for an oci project namespace is the oci project.
+        person = self.factory.makePerson()
+        oci_project = self.factory.makeOCIProject()
+        namespace = DistributionOCIGitNamespace(person, oci_project)
+        self.assertEqual(oci_project, namespace.target)
+
+    def test_supports_merge_proposals(self):
+        # OCI Project namespaces support merge proposals.
+        self.assertTrue(self.getNamespace().supports_merge_proposals)
+
+    def test_areRepositoriesMergeable_same_repository(self):
+        # An OCI Project repository is mergeable into itself.
+        oci_project = self.factory.makeOCIProject()
+        repository = self.factory.makeGitRepository(target=oci_project)
+        self.assertTrue(
+            repository.namespace.areRepositoriesMergeable(
+                repository, repository))
+
+    def test_areRepositoriesMergeable_same_namespace(self):
+        # Repositories of the same OCI Project are mergeable.
+        oci_project = self.factory.makeOCIProject()
+        this = self.factory.makeGitRepository(target=oci_project)
+        other = self.factory.makeGitRepository(target=oci_project)
+        self.assertTrue(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_different_namespace(self):
+        # Repositories of a different OCI Project are not mergeable.
+        this_oci_project = self.factory.makeOCIProject()
+        this = self.factory.makeGitRepository(target=this_oci_project)
+        other_oci_project = self.factory.makeOCIProject()
+        other = self.factory.makeGitRepository(target=other_oci_project)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_areRepositoriesMergeable_personal(self):
+        # Personal repositories are not mergeable into OCI Project
+        # repositories.
+        owner = self.factory.makePerson()
+        oci_project = self.factory.makeOCIProject()
+        this = self.factory.makeGitRepository(owner=owner, target=oci_project)
+        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 OCI Project repositories.
+        owner = self.factory.makePerson()
+        oci_project = self.factory.makeOCIProject()
+        this = self.factory.makeGitRepository(owner=owner, target=oci_project)
+        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 OCI Project repositories.
+        owner = self.factory.makePerson()
+        oci_project = self.factory.makeOCIProject()
+        this = self.factory.makeGitRepository(owner=owner, target=oci_project)
+        package = self.factory.makeDistributionSourcePackage()
+        other = self.factory.makeGitRepository(owner=owner, target=package)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
+    def test_collection(self):
+        # An OCI Project namespace's collection is of
+        # repositories for the same oci project.
+        oci_project = self.factory.makeOCIProject()
+        repositories = [
+            self.factory.makeGitRepository(target=oci_project)
+            for _ in range(3)]
+        self.factory.makeGitRepository(
+            target=self.factory.makeOCIProject())
+        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 TestProjectGitNamespacePrivacyWithInformationType(TestCaseWithFactory):
     """Tests for the privacy aspects of `ProjectGitNamespace`.
 
@@ -688,6 +812,15 @@ class TestPackageGitNamespace(TestCaseWithFactory, NamespaceMixin):
         other = self.factory.makeGitRepository(owner=owner, target=project)
         self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
 
+    def test_areRepositoriesMergeable_oci_project(self):
+        # OCI Project repositories are not mergeable into package repositories.
+        owner = self.factory.makePerson()
+        dsp = self.factory.makeDistributionSourcePackage()
+        this = self.factory.makeGitRepository(owner=owner, target=dsp)
+        oci_project = self.factory.makeOCIProject()
+        other = self.factory.makeGitRepository(owner=owner, target=oci_project)
+        self.assertFalse(this.namespace.areRepositoriesMergeable(this, other))
+
     def test_collection(self):
         # A package namespace's collection is of repositories for the same
         # package.
diff --git a/lib/lp/code/model/tests/test_gitrepository.py b/lib/lp/code/model/tests/test_gitrepository.py
index f1a80ed..1577038 100644
--- a/lib/lp/code/model/tests/test_gitrepository.py
+++ b/lib/lp/code/model/tests/test_gitrepository.py
@@ -222,6 +222,15 @@ class TestGitRepository(TestCaseWithFactory):
                 dsp.sourcepackagename.name, repository.name),
             repository.unique_name)
 
+    def test_unique_name_oci_project(self):
+        oci_project = self.factory.makeOCIProject()
+        repository = self.factory.makeGitRepository(target=oci_project)
+        self.assertEqual(
+            "~%s/%s/+oci/%s/+git/%s" % (
+                repository.owner.name, oci_project.distribution.name,
+                oci_project.ociprojectname.name, repository.name),
+            repository.unique_name)
+
     def test_unique_name_personal(self):
         owner = self.factory.makePerson()
         repository = self.factory.makeGitRepository(owner=owner, target=owner)
@@ -239,6 +248,11 @@ class TestGitRepository(TestCaseWithFactory):
         repository = self.factory.makeGitRepository(target=dsp)
         self.assertEqual(dsp, repository.target)
 
+    def test_target_ociproject(self):
+        oci_project = self.factory.makeOCIProject()
+        repository = self.factory.makeGitRepository(target=oci_project)
+        self.assertEqual(oci_project, repository.target)
+
     def test_target_personal(self):
         owner = self.factory.makePerson()
         repository = self.factory.makeGitRepository(owner=owner, target=owner)
diff --git a/lib/lp/registry/interfaces/distribution.py b/lib/lp/registry/interfaces/distribution.py
index 88a0545..c7ddb95 100644
--- a/lib/lp/registry/interfaces/distribution.py
+++ b/lib/lp/registry/interfaces/distribution.py
@@ -500,6 +500,11 @@ class IDistributionPublic(
         order to create a mirror.
         """
 
+    def getOCIProject(name):
+        """Return a `OCIProject` with the given name for this
+        distribution, or None.
+        """
+
     @operation_parameters(
         name=TextLine(title=_("Package name"), required=True))
     # Really returns IDistributionSourcePackage, see
diff --git a/lib/lp/registry/interfaces/ociproject.py b/lib/lp/registry/interfaces/ociproject.py
index 100dccd..64261b9 100644
--- a/lib/lp/registry/interfaces/ociproject.py
+++ b/lib/lp/registry/interfaces/ociproject.py
@@ -15,7 +15,10 @@ from lazr.restful.fields import (
     CollectionField,
     Reference,
     )
-from zope.interface import Interface
+from zope.interface import (
+    Attribute,
+    Interface,
+    )
 from zope.schema import (
     Datetime,
     Int,
@@ -24,6 +27,7 @@ from zope.schema import (
 
 from lp import _
 from lp.bugs.interfaces.bugtarget import IBugTarget
+from lp.code.interfaces.hasgitrepositories import IHasGitRepositories
 from lp.registry.interfaces.distribution import IDistribution
 from lp.registry.interfaces.ociprojectname import IOCIProjectName
 from lp.registry.interfaces.series import SeriesStatus
@@ -31,7 +35,7 @@ from lp.services.database.constants import DEFAULT
 from lp.services.fields import PublicPersonChoice
 
 
-class IOCIProjectView(Interface):
+class IOCIProjectView(IHasGitRepositories, Interface):
     """IOCIProject attributes that require launchpad.View permission."""
 
     id = Int(title=_("ID"), required=True, readonly=True)
@@ -50,6 +54,8 @@ class IOCIProjectView(Interface):
         # Really IOCIProjectSeries
         value_type=Reference(schema=Interface))
 
+    name = Attribute(_("Name"))
+
 
 class IOCIProjectEditableAttributes(IBugTarget):
     """IOCIProject attributes that can be edited.
diff --git a/lib/lp/registry/model/distribution.py b/lib/lp/registry/model/distribution.py
index 3bdedbe..2288d0e 100644
--- a/lib/lp/registry/model/distribution.py
+++ b/lib/lp/registry/model/distribution.py
@@ -101,6 +101,7 @@ from lp.registry.interfaces.distributionmirror import (
     MirrorFreshness,
     MirrorStatus,
     )
+from lp.registry.interfaces.ociproject import IOCIProjectSet
 from lp.registry.interfaces.oopsreferences import IHasOOPSReferences
 from lp.registry.interfaces.person import (
     validate_person,
@@ -826,6 +827,11 @@ class Distribution(SQLBase, BugTargetBase, MakesAnnouncements,
             name = %s
             """ % sqlvalues(self.id, name))
 
+    def getOCIProject(self, name):
+        oci_project = getUtility(IOCIProjectSet).getByDistributionAndName(
+            self, name)
+        return oci_project
+
     def getSourcePackage(self, name):
         """See `IDistribution`."""
         if ISourcePackageName.providedBy(name):
diff --git a/lib/lp/registry/model/ociproject.py b/lib/lp/registry/model/ociproject.py
index 7250692..e718881 100644
--- a/lib/lp/registry/model/ociproject.py
+++ b/lib/lp/registry/model/ociproject.py
@@ -67,6 +67,10 @@ class OCIProject(BugTargetBase, StormBase):
         name="enable_bugfiling_duplicate_search")
 
     @property
+    def name(self):
+        return self.ociprojectname.name
+
+    @property
     def pillar(self):
         """See `IBugTarget`."""
         return self.distribution
diff --git a/lib/lp/registry/tests/test_distribution.py b/lib/lp/registry/tests/test_distribution.py
index 8e0b5ba..c7bf86f 100644
--- a/lib/lp/registry/tests/test_distribution.py
+++ b/lib/lp/registry/tests/test_distribution.py
@@ -304,6 +304,14 @@ class TestDistribution(TestCaseWithFactory):
             InformationType.PUBLIC,
             distro.getDefaultSpecificationInformationType())
 
+    def test_getOCIProject(self):
+        distro = self.factory.makeDistribution()
+        first_project = self.factory.makeOCIProject(pillar=distro)
+        # make another project to ensure we don't default
+        self.factory.makeOCIProject(pillar=distro)
+        result = distro.getOCIProject(first_project.name)
+        self.assertEqual(first_project, result)
+
 
 class TestDistributionCurrentSourceReleases(
     CurrentSourceReleasesMixin, TestCase):
diff --git a/lib/lp/registry/tests/test_ociproject.py b/lib/lp/registry/tests/test_ociproject.py
index d170bbb..174b12b 100644
--- a/lib/lp/registry/tests/test_ociproject.py
+++ b/lib/lp/registry/tests/test_ociproject.py
@@ -67,6 +67,12 @@ class TestOCIProject(TestCaseWithFactory):
                 oci_project=second_oci_project)
             self.assertContentEqual([first_series], first_oci_project.series)
 
+    def test_name(self):
+        oci_project_name = self.factory.makeOCIProjectName(name='test-name')
+        oci_project = self.factory.makeOCIProject(
+            ociprojectname=oci_project_name)
+        self.assertEqual(oci_project.name, 'test-name')
+
 
 class TestOCIProjectSet(TestCaseWithFactory):
 
diff --git a/lib/lp/security.py b/lib/lp/security.py
index 21caa71..66c7f73 100644
--- a/lib/lp/security.py
+++ b/lib/lp/security.py
@@ -3434,6 +3434,11 @@ class EditSnapBaseSet(EditByRegistryExpertsOrAdmins):
     usedfor = ISnapBaseSet
 
 
+class ViewOCIProject(AnonymousAuthorization):
+    """Anyone can view an `IOCIProject`."""
+    usedfor = IOCIProject
+
+
 class EditOCIProject(AuthorizationBase):
     permission = 'launchpad.Edit'
     usedfor = IOCIProject