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

[Colin Watson]

Add support for collections of Git repositories.

Add support for collections of Git repositories.

This is mostly a much-reduced version of BranchLookup. It's also the last of the big core chunks of the Git repository model; after this it should be possible to work in more digestible pieces rather than thousand-line sections of entirely new code.

[William Grant (wgrant)]

review: Approve (code)

=== added file 'lib/lp/code/adapters/gitcollection.py'
--- lib/lp/code/adapters/gitcollection.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/adapters/gitcollection.py	2015-02-26 17:21:27 +0000
@@ -0,0 +1,62 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Adapters for different objects to Git repository collections."""
+
+__metaclass__ = type
+__all__ = [
+    'git_collection_for_distribution',
+    'git_collection_for_distro_source_package',
+    'git_collection_for_person',
+    'git_collection_for_person_distro_source_package',
+    'git_collection_for_person_product',
+    'git_collection_for_project',
+    'git_collection_for_project_group',
+    ]
+
+
+from zope.component import getUtility
+
+from lp.code.interfaces.gitcollection import IAllGitRepositories
+
+
+def git_collection_for_project(project):
+    """Adapt a product to a Git repository collection."""
+    return getUtility(IAllGitRepositories).inProject(project)
+
+
+def git_collection_for_project_group(project_group):
+    """Adapt a project group to a Git repository collection."""
+    return getUtility(IAllGitRepositories).inProjectGroup(project_group)
+
+
+def git_collection_for_distribution(distribution):
+    """Adapt a distribution to a Git repository collection."""
+    return getUtility(IAllGitRepositories).inDistribution(distribution)
+
+
+def git_collection_for_distro_source_package(distro_source_package):
+    """Adapt a distro_source_package to a Git repository collection."""
+    return getUtility(IAllGitRepositories).inDistributionSourcePackage(
+        distro_source_package)
+
+
+def git_collection_for_person(person):
+    """Adapt a person to a Git repository collection."""
+    return getUtility(IAllGitRepositories).ownedBy(person)
+
+
+def git_collection_for_person_product(person_product):
+    """Adapt a PersonProduct to a Git repository collection."""
+    collection = getUtility(IAllGitRepositories).ownedBy(person_product.person)
+    collection = collection.inProject(person_product.product)
+    return collection
+
+
+def git_collection_for_person_distro_source_package(person_dsp):
+    """Adapt a PersonDistributionSourcePackage to a Git repository
+    collection."""
+    collection = getUtility(IAllGitRepositories).ownedBy(person_dsp.person)
+    collection = collection.inDistributionSourcePackage(
+        person_dsp.distro_source_package)
+    return collection

=== modified file 'lib/lp/code/configure.zcml'
--- lib/lp/code/configure.zcml	2015-02-26 17:21:27 +0000
+++ lib/lp/code/configure.zcml	2015-02-26 17:21:27 +0000
@@ -858,6 +858,55 @@
     <allow interface="lp.code.interfaces.gitnamespace.IGitNamespaceSet" />
   </securedutility>
 
+  <!-- GitCollection -->
+
+  <class class="lp.code.model.gitcollection.GenericGitCollection">
+    <allow interface="lp.code.interfaces.gitcollection.IGitCollection"/>
+  </class>
+  <class class="lp.code.model.gitcollection.AnonymousGitCollection">
+    <allow interface="lp.code.interfaces.gitcollection.IGitCollection"/>
+  </class>
+  <class class="lp.code.model.gitcollection.VisibleGitCollection">
+    <allow interface="lp.code.interfaces.gitcollection.IGitCollection"/>
+  </class>
+  <adapter
+      for="storm.store.Store"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.model.gitcollection.GenericGitCollection"/>
+  <adapter
+      for="lp.registry.interfaces.product.IProduct"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.adapters.gitcollection.git_collection_for_project"/>
+  <adapter
+      for="lp.registry.interfaces.projectgroup.IProjectGroup"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.adapters.gitcollection.git_collection_for_project_group"/>
+  <adapter
+      for="lp.registry.interfaces.distribution.IDistribution"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.adapters.gitcollection.git_collection_for_distribution"/>
+  <adapter
+      for="lp.registry.interfaces.distributionsourcepackage.IDistributionSourcePackage"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.adapters.gitcollection.git_collection_for_distro_source_package"/>
+  <adapter
+      for="lp.registry.interfaces.person.IPerson"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.adapters.gitcollection.git_collection_for_person"/>
+  <adapter
+      for="lp.registry.interfaces.personproduct.IPersonProduct"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.adapters.gitcollection.git_collection_for_person_product"/>
+  <adapter
+      for="lp.registry.interfaces.persondistributionsourcepackage.IPersonDistributionSourcePackage"
+      provides="lp.code.interfaces.gitcollection.IGitCollection"
+      factory="lp.code.adapters.gitcollection.git_collection_for_person_distro_source_package"/>
+  <securedutility
+      class="lp.code.model.gitcollection.GenericGitCollection"
+      provides="lp.code.interfaces.gitcollection.IAllGitRepositories">
+    <allow interface="lp.code.interfaces.gitcollection.IAllGitRepositories"/>
+  </securedutility>
+
   <!-- Default Git repositories -->
 
   <adapter factory="lp.code.model.defaultgit.ProjectDefaultGitRepository" />

=== added file 'lib/lp/code/interfaces/gitcollection.py'
--- lib/lp/code/interfaces/gitcollection.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/interfaces/gitcollection.py	2015-02-26 17:21:27 +0000
@@ -0,0 +1,125 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""A collection of Git repositories.
+
+See `IGitCollection` for more details.
+"""
+
+__metaclass__ = type
+__all__ = [
+    'IAllGitRepositories',
+    'IGitCollection',
+    'InvalidGitFilter',
+    ]
+
+from zope.interface import Interface
+
+
+class InvalidGitFilter(Exception):
+    """Raised when an `IGitCollection` cannot apply the given filter."""
+
+
+class IGitCollection(Interface):
+    """A collection of Git repositories.
+
+    An `IGitCollection` is an immutable collection of Git repositories. It
+    has two kinds of methods: filter methods and query methods.
+
+    Query methods get information about the contents of the collection. See
+    `IGitCollection.count` and `IGitCollection.getRepositories`.
+
+    Filter methods return new IGitCollection instances that have some sort
+    of restriction. Examples include `ownedBy`, `visibleByUser` and
+    `inProject`.
+
+    Implementations of this interface are not 'content classes'. That is, they
+    do not correspond to a particular row in the database.
+
+    This interface is intended for use within Launchpad, not to be exported as
+    a public API.
+    """
+
+    def count():
+        """The number of repositories in this collection."""
+
+    def is_empty():
+        """Is this collection empty?"""
+
+    def ownerCounts():
+        """Return the number of different repository owners.
+
+        :return: a tuple (individual_count, team_count) containing the
+            number of individuals and teams that own repositories in this
+            collection.
+        """
+
+    def getRepositories(eager_load=False):
+        """Return a result set of all repositories in this collection.
+
+        The returned result set will also join across the specified tables
+        as defined by the arguments to this function.  These extra tables
+        are joined specifically to allow the caller to sort on values not in
+        the GitRepository table itself.
+
+        :param eager_load: If True trigger eager loading of all the related
+            objects in the collection.
+        """
+
+    def getRepositoryIds():
+        """Return a result set of all repository ids in this collection."""
+
+    def getTeamsWithRepositories(person):
+        """Return the teams that person is a member of that have
+        repositories."""
+
+    def inProject(project):
+        """Restrict the collection to repositories in 'project'."""
+
+    def inProjectGroup(projectgroup):
+        """Restrict the collection to repositories in 'projectgroup'."""
+
+    def inDistribution(distribution):
+        """Restrict the collection to repositories in 'distribution'."""
+
+    def inDistributionSourcePackage(distro_source_package):
+        """Restrict to repositories in a package for a distribution."""
+
+    def isPersonal():
+        """Restrict the collection to personal repositories."""
+
+    def isPrivate():
+        """Restrict the collection to private repositories."""
+
+    def isExclusive():
+        """Restrict the collection to repositories owned by exclusive
+        people."""
+
+    def ownedBy(person):
+        """Restrict the collection to repositories owned by 'person'."""
+
+    def ownedByTeamMember(person):
+        """Restrict the collection to repositories owned by 'person' or a
+        team of which person is a member.
+        """
+
+    def registeredBy(person):
+        """Restrict the collection to repositories registered by 'person'."""
+
+    def search(term):
+        """Search the collection for repositories matching 'term'.
+
+        :param term: A string.
+        :return: A `ResultSet` of repositories that matched.
+        """
+
+    def visibleByUser(person):
+        """Restrict the collection to repositories that person is allowed to
+        see."""
+
+    def withIds(*repository_ids):
+        """Restrict the collection to repositories with the specified ids."""
+
+
+class IAllGitRepositories(IGitCollection):
+    """A `IGitCollection` representing all Git repositories in Launchpad."""

=== added file 'lib/lp/code/model/gitcollection.py'
--- lib/lp/code/model/gitcollection.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/model/gitcollection.py	2015-02-26 17:21:27 +0000
@@ -0,0 +1,327 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Implementations of `IGitCollection`."""
+
+__metaclass__ = type
+__all__ = [
+    'GenericGitCollection',
+    ]
+
+from lazr.uri import (
+    InvalidURIError,
+    URI,
+    )
+from storm.expr import (
+    Count,
+    In,
+    Join,
+    Select,
+    )
+from zope.component import getUtility
+from zope.interface import implements
+
+from lp.app.enums import PRIVATE_INFORMATION_TYPES
+from lp.code.interfaces.codehosting import LAUNCHPAD_SERVICES
+from lp.code.interfaces.gitcollection import (
+    IGitCollection,
+    InvalidGitFilter,
+    )
+from lp.code.interfaces.gitlookup import IGitLookup
+from lp.code.interfaces.gitrepository import (
+    user_has_special_git_repository_access,
+    )
+from lp.code.model.gitrepository import (
+    GitRepository,
+    get_git_repository_privacy_filter,
+    )
+from lp.registry.enums import EXCLUSIVE_TEAM_POLICY
+from lp.registry.model.person import Person
+from lp.registry.model.product import Product
+from lp.registry.model.teammembership import TeamParticipation
+from lp.services.database.bulk import load_related
+from lp.services.database.decoratedresultset import DecoratedResultSet
+from lp.services.database.interfaces import IStore
+from lp.services.propertycache import get_property_cache
+
+
+class GenericGitCollection:
+    """See `IGitCollection`."""
+
+    implements(IGitCollection)
+
+    def __init__(self, store=None, filter_expressions=None, tables=None):
+        """Construct a `GenericGitCollection`.
+
+        :param store: The store to look in for repositories. If not
+            specified, use the default store.
+        :param filter_expressions: A list of Storm expressions to
+            restrict the repositories in the collection. If unspecified,
+            then there will be no restrictions on the result set. That is,
+            all repositories in the store will be in the collection.
+        :param tables: A dict of Storm tables to the Join expression.  If an
+            expression in filter_expressions refers to a table, then that
+            table *must* be in this list.
+        """
+        self._store = store
+        if filter_expressions is None:
+            filter_expressions = []
+        self._filter_expressions = list(filter_expressions)
+        if tables is None:
+            tables = {}
+        self._tables = tables
+        self._user = None
+
+    def count(self):
+        """See `IGitCollection`."""
+        return self.getRepositories(eager_load=False).count()
+
+    def is_empty(self):
+        """See `IGitCollection`."""
+        return self.getRepositories(eager_load=False).is_empty()
+
+    def ownerCounts(self):
+        """See `IGitCollection`."""
+        is_team = Person.teamowner != None
+        owners = self._getRepositorySelect((GitRepository.owner_id,))
+        counts = dict(self.store.find(
+            (is_team, Count(Person.id)),
+            Person.id.is_in(owners)).group_by(is_team))
+        return (counts.get(False, 0), counts.get(True, 0))
+
+    @property
+    def store(self):
+        # Although you might think we could set the default value for store
+        # in the constructor, we can't.  The IStore utility is not available
+        # at the time that the ZCML is parsed, which means we get an error
+        # if this code is in the constructor.
+        # -- JonathanLange 2009-02-17.
+        if self._store is None:
+            return IStore(GitRepository)
+        else:
+            return self._store
+
+    def _filterBy(self, expressions, table=None, join=None):
+        """Return a subset of this collection, filtered by 'expressions'."""
+        # NOTE: JonathanLange 2009-02-17: We might be able to avoid the need
+        # for explicit 'tables' by harnessing Storm's table inference system.
+        # See http://paste.ubuntu.com/118711/ for one way to do that.
+        if table is not None and join is None:
+            raise InvalidGitFilter("Cannot specify a table without a join.")
+        if expressions is None:
+            expressions = []
+        tables = self._tables.copy()
+        if table is not None:
+            tables[table] = join
+        return self.__class__(
+            self.store, self._filter_expressions + expressions, tables)
+
+    def _getRepositorySelect(self, columns=(GitRepository.id,)):
+        """Return a Storm 'Select' for columns in this collection."""
+        repositories = self.getRepositories(
+            eager_load=False, find_expr=columns)
+        return repositories.get_plain_result_set()._get_select()
+
+    def _getRepositoryExpressions(self):
+        """Return the where expressions for this collection."""
+        return (self._filter_expressions +
+            self._getRepositoryVisibilityExpression())
+
+    def _getRepositoryVisibilityExpression(self):
+        """Return the where clauses for visibility."""
+        return []
+
+    def getRepositories(self, find_expr=GitRepository, eager_load=False):
+        """See `IGitCollection`."""
+        tables = [GitRepository] + list(set(self._tables.values()))
+        expressions = self._getRepositoryExpressions()
+        resultset = self.store.using(*tables).find(find_expr, *expressions)
+
+        def do_eager_load(rows):
+            repository_ids = set(repository.id for repository in rows)
+            if not repository_ids:
+                return
+            load_related(Product, rows, ['project_id'])
+            # So far have only needed the persons for their canonical_url - no
+            # need for validity etc in the API call.
+            load_related(Person, rows, ['owner_id', 'registrant_id'])
+
+        def cache_permission(repository):
+            if self._user:
+                get_property_cache(repository)._known_viewers = set(
+                    [self._user.id])
+            return repository
+
+        eager_load_hook = (
+            do_eager_load if eager_load and find_expr == GitRepository
+            else None)
+        return DecoratedResultSet(
+            resultset, pre_iter_hook=eager_load_hook,
+            result_decorator=cache_permission)
+
+    def getRepositoryIds(self):
+        """See `IGitCollection`."""
+        return self.getRepositories(
+            find_expr=GitRepository.id).get_plain_result_set()
+
+    def getTeamsWithRepositories(self, person):
+        """See `IGitCollection`."""
+        # This method doesn't entirely fit with the intent of the
+        # GitCollection conceptual model, but we're not quite sure how to
+        # fix it just yet.
+        repository_query = self._getRepositorySelect((GitRepository.owner_id,))
+        return self.store.find(
+            Person,
+            Person.id == TeamParticipation.teamID,
+            TeamParticipation.person == person,
+            TeamParticipation.team != person,
+            Person.id.is_in(repository_query))
+
+    def inProject(self, project):
+        """See `IGitCollection`."""
+        return self._filterBy([GitRepository.project == project])
+
+    def inProjectGroup(self, projectgroup):
+        """See `IGitCollection`."""
+        return self._filterBy(
+            [Product.projectgroup == projectgroup.id],
+            table=Product,
+            join=Join(Product, GitRepository.project == Product.id))
+
+    def inDistribution(self, distribution):
+        """See `IGitCollection`."""
+        return self._filterBy([GitRepository.distribution == distribution])
+
+    def inDistributionSourcePackage(self, distro_source_package):
+        """See `IGitCollection`."""
+        distribution = distro_source_package.distribution
+        sourcepackagename = distro_source_package.sourcepackagename
+        return self._filterBy(
+            [GitRepository.distribution == distribution,
+             GitRepository.sourcepackagename == sourcepackagename])
+
+    def isPersonal(self):
+        """See `IGitCollection`."""
+        return self._filterBy(
+            [GitRepository.project == None,
+             GitRepository.distribution == None])
+
+    def isPrivate(self):
+        """See `IGitCollection`."""
+        return self._filterBy(
+            [GitRepository.information_type.is_in(PRIVATE_INFORMATION_TYPES)])
+
+    def isExclusive(self):
+        """See `IGitCollection`."""
+        return self._filterBy(
+            [Person.membership_policy.is_in(EXCLUSIVE_TEAM_POLICY)],
+            table=Person,
+            join=Join(Person, GitRepository.owner_id == Person.id))
+
+    def ownedBy(self, person):
+        """See `IGitCollection`."""
+        return self._filterBy([GitRepository.owner == person])
+
+    def ownedByTeamMember(self, person):
+        """See `IGitCollection`."""
+        subquery = Select(
+            TeamParticipation.teamID,
+            where=TeamParticipation.personID == person.id)
+        return self._filterBy([In(GitRepository.owner_id, subquery)])
+
+    def registeredBy(self, person):
+        """See `IGitCollection`."""
+        return self._filterBy([GitRepository.registrant == person])
+
+    def _getExactMatch(self, term):
+        # Look up the repository by its URL, which handles both shortcuts
+        # and unique names.
+        repository = getUtility(IGitLookup).getByUrl(term)
+        if repository is not None:
+            return repository
+        # Fall back to searching by unique_name, stripping out the path if
+        # it's a URI.
+        try:
+            path = URI(term).path.strip("/")
+        except InvalidURIError:
+            path = term
+        return getUtility(IGitLookup).getByUniqueName(path)
+
+    def search(self, term):
+        """See `IGitCollection`."""
+        repository = self._getExactMatch(term)
+        if repository:
+            collection = self._filterBy([GitRepository.id == repository.id])
+        else:
+            term = unicode(term)
+            # Filter by name.
+            field = GitRepository.name
+            # Except if the term contains /, when we use unique_name.
+            # XXX cjwatson 2015-02-06: Disabled until the URL format settles
+            # down, at which point we can make GitRepository.unique_name a
+            # trigger-maintained column rather than a property.
+            #if '/' in term:
+            #    field = GitRepository.unique_name
+            collection = self._filterBy(
+                [field.lower().contains_string(term.lower())])
+        return collection.getRepositories(eager_load=False).order_by(
+            GitRepository.name, GitRepository.id)
+
+    def visibleByUser(self, person):
+        """See `IGitCollection`."""
+        if (person == LAUNCHPAD_SERVICES or
+            user_has_special_git_repository_access(person)):
+            return self
+        if person is None:
+            return AnonymousGitCollection(
+                self._store, self._filter_expressions, self._tables)
+        return VisibleGitCollection(
+            person, self._store, self._filter_expressions, self._tables)
+
+    def withIds(self, *repository_ids):
+        """See `IGitCollection`."""
+        return self._filterBy([GitRepository.id.is_in(repository_ids)])
+
+
+class AnonymousGitCollection(GenericGitCollection):
+    """Repository collection that only shows public repositories."""
+
+    def _getRepositoryVisibilityExpression(self):
+        """Return the where clauses for visibility."""
+        return get_git_repository_privacy_filter(None)
+
+
+class VisibleGitCollection(GenericGitCollection):
+    """A repository collection that has special logic for visibility."""
+
+    def __init__(self, user, store=None, filter_expressions=None, tables=None):
+        super(VisibleGitCollection, self).__init__(
+            store=store, filter_expressions=filter_expressions, tables=tables)
+        self._user = user
+
+    def _filterBy(self, expressions, table=None, join=None):
+        """Return a subset of this collection, filtered by 'expressions'."""
+        # NOTE: JonathanLange 2009-02-17: We might be able to avoid the need
+        # for explicit 'tables' by harnessing Storm's table inference system.
+        # See http://paste.ubuntu.com/118711/ for one way to do that.
+        if table is not None and join is None:
+            raise InvalidGitFilter("Cannot specify a table without a join.")
+        if expressions is None:
+            expressions = []
+        tables = self._tables.copy()
+        if table is not None:
+            tables[table] = join
+        return self.__class__(
+            self._user, self.store, self._filter_expressions + expressions)
+
+    def _getRepositoryVisibilityExpression(self):
+        """Return the where clauses for visibility."""
+        return get_git_repository_privacy_filter(self._user)
+
+    def visibleByUser(self, person):
+        """See `IGitCollection`."""
+        if person == self._user:
+            return self
+        raise InvalidGitFilter(
+            "Cannot filter for Git repositories visible by user %r, already "
+            "filtering for %r" % (person, self._user))

=== added file 'lib/lp/code/model/tests/test_gitcollection.py'
--- lib/lp/code/model/tests/test_gitcollection.py	1970-01-01 00:00:00 +0000
+++ lib/lp/code/model/tests/test_gitcollection.py	2015-02-26 17:21:27 +0000
@@ -0,0 +1,716 @@
+# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for Git repository collections."""
+
+__metaclass__ = type
+
+from testtools.matchers import Equals
+from zope.component import getUtility
+from zope.security.proxy import removeSecurityProxy
+
+from lp.app.enums import InformationType
+from lp.app.interfaces.launchpad import ILaunchpadCelebrities
+from lp.app.interfaces.services import IService
+from lp.code.interfaces.codehosting import LAUNCHPAD_SERVICES
+from lp.code.interfaces.gitcollection import (
+    IAllGitRepositories,
+    IGitCollection,
+    )
+from lp.code.interfaces.gitrepository import IGitRepositorySet
+from lp.code.model.gitcollection import GenericGitCollection
+from lp.code.model.gitrepository import GitRepository
+from lp.registry.enums import PersonVisibility
+from lp.registry.interfaces.person import TeamMembershipPolicy
+from lp.registry.model.persondistributionsourcepackage import (
+    PersonDistributionSourcePackage,
+    )
+from lp.registry.model.personproduct import PersonProduct
+from lp.services.database.interfaces import IStore
+from lp.testing import (
+    person_logged_in,
+    StormStatementRecorder,
+    TestCaseWithFactory,
+    )
+from lp.testing.layers import DatabaseFunctionalLayer
+from lp.testing.matchers import HasQueryCount
+
+
+class TestGitCollectionAdaptation(TestCaseWithFactory):
+    """Check that certain objects can be adapted to a Git repository
+    collection."""
+
+    layer = DatabaseFunctionalLayer
+
+    def assertCollection(self, target):
+        self.assertIsNotNone(IGitCollection(target, None))
+
+    def test_project(self):
+        # A project can be adapted to a Git repository collection.
+        self.assertCollection(self.factory.makeProduct())
+
+    def test_project_group(self):
+        # A project group can be adapted to a Git repository collection.
+        self.assertCollection(self.factory.makeProject())
+
+    def test_distribution(self):
+        # A distribution can be adapted to a Git repository collection.
+        self.assertCollection(self.factory.makeDistribution())
+
+    def test_distribution_source_package(self):
+        # A distribution source package can be adapted to a Git repository
+        # collection.
+        self.assertCollection(self.factory.makeDistributionSourcePackage())
+
+    def test_person(self):
+        # A person can be adapted to a Git repository collection.
+        self.assertCollection(self.factory.makePerson())
+
+    def test_person_product(self):
+        # A PersonProduct can be adapted to a Git repository collection.
+        project = self.factory.makeProduct()
+        self.assertCollection(PersonProduct(project.owner, project))
+
+    def test_person_distribution_source_package(self):
+        # A PersonDistributionSourcePackage can be adapted to a Git
+        # repository collection.
+        dsp = self.factory.makeDistributionSourcePackage()
+        self.assertCollection(
+            PersonDistributionSourcePackage(dsp.distribution.owner, dsp))
+
+
+class TestGenericGitCollection(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        super(TestGenericGitCollection, self).setUp()
+        self.store = IStore(GitRepository)
+
+    def test_provides_gitcollection(self):
+        # `GenericGitCollection` provides the `IGitCollection`
+        # interface.
+        self.assertProvides(GenericGitCollection(self.store), IGitCollection)
+
+    def test_getRepositories_no_filter_no_repositories(self):
+        # If no filter is specified, then the collection is of all
+        # repositories in Launchpad.  By default, there are no repositories.
+        collection = GenericGitCollection(self.store)
+        self.assertEqual([], list(collection.getRepositories()))
+
+    def test_getRepositories_no_filter(self):
+        # If no filter is specified, then the collection is of all
+        # repositories in Launchpad.
+        collection = GenericGitCollection(self.store)
+        repository = self.factory.makeGitRepository()
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_getRepositories_project_filter(self):
+        # If the specified filter is for the repositories of a particular
+        # project, then the collection contains only repositories of that
+        # project.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        collection = GenericGitCollection(
+            self.store, [GitRepository.project == repository.target])
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_getRepositories_caches_viewers(self):
+        # getRepositories() caches the user as a known viewer so that
+        # repository.visibleByUser() does not have to hit the database.
+        collection = GenericGitCollection(self.store)
+        owner = self.factory.makePerson()
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(
+            owner=owner, target=project,
+            information_type=InformationType.USERDATA)
+        someone = self.factory.makePerson()
+        with person_logged_in(owner):
+            getUtility(IService, 'sharing').ensureAccessGrants(
+                [someone], owner, gitrepositories=[repository],
+                ignore_permissions=True)
+        [repository] = list(collection.visibleByUser(
+            someone).getRepositories())
+        with StormStatementRecorder() as recorder:
+            self.assertTrue(repository.visibleByUser(someone))
+            self.assertThat(recorder, HasQueryCount(Equals(0)))
+
+    def test_getRepositoryIds(self):
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        collection = GenericGitCollection(
+            self.store, [GitRepository.project == repository.target])
+        self.assertEqual([repository.id], list(collection.getRepositoryIds()))
+
+    def test_count(self):
+        # The 'count' property of a collection is the number of elements in
+        # the collection.
+        collection = GenericGitCollection(self.store)
+        self.assertEqual(0, collection.count())
+        for i in range(3):
+            self.factory.makeGitRepository()
+        self.assertEqual(3, collection.count())
+
+    def test_count_respects_filter(self):
+        # If a collection is a subset of all possible repositories, then the
+        # count will be the size of that subset.  That is, 'count' respects
+        # any filters that are applied.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        collection = GenericGitCollection(
+            self.store, [GitRepository.project == repository.target])
+        self.assertEqual(1, collection.count())
+
+
+class TestGitCollectionFilters(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        self.all_repositories = getUtility(IAllGitRepositories)
+
+    def test_order_by_repository_name(self):
+        # The result of getRepositories() can be ordered by
+        # `GitRepository.name`, no matter what filters are applied.
+        aardvark = self.factory.makeProduct(name='aardvark')
+        badger = self.factory.makeProduct(name='badger')
+        repository_a = self.factory.makeGitRepository(target=aardvark)
+        repository_b = self.factory.makeGitRepository(target=badger)
+        person = self.factory.makePerson()
+        repository_c = self.factory.makeGitRepository(
+            owner=person, target=person)
+        self.assertEqual(
+            sorted([repository_a, repository_b, repository_c]),
+            sorted(self.all_repositories.getRepositories()
+                 .order_by(GitRepository.name)))
+
+    def test_count_respects_visibleByUser_filter(self):
+        # IGitCollection.count() returns the number of repositories that
+        # getRepositories() yields, even when the visibleByUser filter is
+        # applied.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository(
+            information_type=InformationType.USERDATA)
+        collection = self.all_repositories.visibleByUser(repository.owner)
+        self.assertEqual(1, collection.getRepositories().count())
+        self.assertEqual(1, len(list(collection.getRepositories())))
+        self.assertEqual(1, collection.count())
+
+    def test_ownedBy(self):
+        # 'ownedBy' returns a new collection restricted to repositories
+        # owned by the given person.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.ownedBy(repository.owner)
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_ownedByTeamMember(self):
+        # 'ownedBy' returns a new collection restricted to repositories
+        # owned by any team of which the given person is a member.
+        person = self.factory.makePerson()
+        team = self.factory.makeTeam(members=[person])
+        repository = self.factory.makeGitRepository(owner=team)
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.ownedByTeamMember(person)
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_in_project(self):
+        # 'inProject' returns a new collection restricted to repositories in
+        # the given project.
+        #
+        # NOTE: JonathanLange 2009-02-11: Maybe this should be a more
+        # generic method called 'onTarget' that takes a person, package or
+        # project.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.inProject(repository.target)
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_inProjectGroup(self):
+        # 'inProjectGroup' returns a new collection restricted to
+        # repositories in the given project group.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        projectgroup = self.factory.makeProject()
+        removeSecurityProxy(repository.target).projectgroup = projectgroup
+        collection = self.all_repositories.inProjectGroup(projectgroup)
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_isExclusive(self):
+        # 'isExclusive' is restricted to repositories owned by exclusive
+        # teams and users.
+        user = self.factory.makePerson()
+        team = self.factory.makeTeam(
+            membership_policy=TeamMembershipPolicy.RESTRICTED)
+        other_team = self.factory.makeTeam(
+            membership_policy=TeamMembershipPolicy.OPEN)
+        team_repository = self.factory.makeGitRepository(owner=team)
+        user_repository = self.factory.makeGitRepository(owner=user)
+        self.factory.makeGitRepository(owner=other_team)
+        collection = self.all_repositories.isExclusive()
+        self.assertContentEqual(
+            [team_repository, user_repository],
+            list(collection.getRepositories()))
+
+    def test_inProject_and_isExclusive(self):
+        # 'inProject' and 'isExclusive' can combine to form a collection
+        # that is restricted to repositories of a particular project owned
+        # by exclusive teams and users.
+        team = self.factory.makeTeam(
+            membership_policy=TeamMembershipPolicy.RESTRICTED)
+        other_team = self.factory.makeTeam(
+            membership_policy=TeamMembershipPolicy.OPEN)
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(target=project, owner=team)
+        self.factory.makeGitRepository(owner=team)
+        self.factory.makeGitRepository(target=project, owner=other_team)
+        collection = self.all_repositories.inProject(project).isExclusive()
+        self.assertEqual([repository], list(collection.getRepositories()))
+        collection = self.all_repositories.isExclusive().inProject(project)
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_ownedBy_and_inProject(self):
+        # 'ownedBy' and 'inProject' can combine to form a collection that is
+        # restricted to repositories of a particular project owned by a
+        # particular person.
+        person = self.factory.makePerson()
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(
+            target=project, owner=person)
+        self.factory.makeGitRepository(owner=person)
+        self.factory.makeGitRepository(target=project)
+        collection = self.all_repositories.inProject(project).ownedBy(person)
+        self.assertEqual([repository], list(collection.getRepositories()))
+        collection = self.all_repositories.ownedBy(person).inProject(project)
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_ownedBy_and_isPrivate(self):
+        # 'ownedBy' and 'isPrivate' can combine to form a collection that is
+        # restricted to private repositories owned by a particular person.
+        person = self.factory.makePerson()
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(
+            target=project, owner=person,
+            information_type=InformationType.USERDATA)
+        self.factory.makeGitRepository(owner=person)
+        self.factory.makeGitRepository(target=project)
+        collection = self.all_repositories.isPrivate().ownedBy(person)
+        self.assertEqual([repository], list(collection.getRepositories()))
+        collection = self.all_repositories.ownedBy(person).isPrivate()
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+    def test_ownedByTeamMember_and_inProject(self):
+        # 'ownedBy' and 'inProject' can combine to form a collection that is
+        # restricted to repositories of a particular project owned by a
+        # particular person or team of which the person is a member.
+        person = self.factory.makePerson()
+        team = self.factory.makeTeam(members=[person])
+        project = self.factory.makeProduct()
+        repository = self.factory.makeGitRepository(
+            target=project, owner=person)
+        repository2 = self.factory.makeGitRepository(
+            target=project, owner=team)
+        self.factory.makeGitRepository(owner=person)
+        self.factory.makeGitRepository(target=project)
+        project_repositories = self.all_repositories.inProject(project)
+        collection = project_repositories.ownedByTeamMember(person)
+        self.assertContentEqual(
+            [repository, repository2], collection.getRepositories())
+        person_repositories = self.all_repositories.ownedByTeamMember(person)
+        collection = person_repositories.inProject(project)
+        self.assertContentEqual(
+            [repository, repository2], collection.getRepositories())
+
+    def test_in_distribution(self):
+        # 'inDistribution' returns a new collection that only has
+        # repositories that are package repositories associated with the
+        # distribution specified.
+        distro = self.factory.makeDistribution()
+        # Make two repositories in the same distribution, but different
+        # source packages.
+        dsp = self.factory.makeDistributionSourcePackage(distribution=distro)
+        repository = self.factory.makeGitRepository(target=dsp)
+        dsp2 = self.factory.makeDistributionSourcePackage(distribution=distro)
+        repository2 = self.factory.makeGitRepository(target=dsp2)
+        # Another repository in a different distribution.
+        self.factory.makeGitRepository(
+            target=self.factory.makeDistributionSourcePackage())
+        # And a project repository.
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.inDistribution(distro)
+        self.assertEqual(
+            sorted([repository, repository2]),
+            sorted(collection.getRepositories()))
+
+    def test_in_distribution_source_package(self):
+        # 'inDistributionSourcePackage' returns a new collection that only
+        # has repositories for the source package in the distribution.
+        distro = self.factory.makeDistribution()
+        dsp = self.factory.makeDistributionSourcePackage(distribution=distro)
+        dsp_other_distro = self.factory.makeDistributionSourcePackage()
+        repository = self.factory.makeGitRepository(target=dsp)
+        repository2 = self.factory.makeGitRepository(target=dsp)
+        self.factory.makeGitRepository(target=dsp_other_distro)
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.inDistributionSourcePackage(dsp)
+        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.
+        repository1 = self.factory.makeGitRepository()
+        repository2 = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        ids = [repository1.id, repository2.id]
+        collection = self.all_repositories.withIds(*ids)
+        self.assertEqual(
+            sorted([repository1, repository2]),
+            sorted(collection.getRepositories()))
+
+    def test_registeredBy(self):
+        # 'registeredBy' returns a new collection that only has repositories
+        # that were registered by the given user.
+        registrant = self.factory.makePerson()
+        repository = self.factory.makeGitRepository(
+            owner=registrant, registrant=registrant)
+        removeSecurityProxy(repository).owner = self.factory.makePerson()
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.registeredBy(registrant)
+        self.assertEqual([repository], list(collection.getRepositories()))
+
+
+class TestGenericGitCollectionVisibleFilter(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        self.public_repository = self.factory.makeGitRepository(name=u'public')
+        self.private_repository = self.factory.makeGitRepository(
+            name=u'private', information_type=InformationType.USERDATA)
+        self.all_repositories = getUtility(IAllGitRepositories)
+
+    def test_all_repositories(self):
+        # Without the visibleByUser filter, all repositories are in the
+        # collection.
+        self.assertEqual(
+            sorted([self.public_repository, self.private_repository]),
+            sorted(self.all_repositories.getRepositories()))
+
+    def test_anonymous_sees_only_public(self):
+        # Anonymous users can see only public repositories.
+        repositories = self.all_repositories.visibleByUser(None)
+        self.assertEqual(
+            [self.public_repository], list(repositories.getRepositories()))
+
+    def test_visibility_then_project(self):
+        # We can apply other filters after applying the visibleByUser filter.
+        # Create another public repository.
+        self.factory.makeGitRepository()
+        repositories = self.all_repositories.visibleByUser(None).inProject(
+            self.public_repository.target).getRepositories()
+        self.assertEqual([self.public_repository], list(repositories))
+
+    def test_random_person_sees_only_public(self):
+        # Logged in users with no special permissions can see only public
+        # repositories.
+        person = self.factory.makePerson()
+        repositories = self.all_repositories.visibleByUser(person)
+        self.assertEqual(
+            [self.public_repository], list(repositories.getRepositories()))
+
+    def test_owner_sees_own_repositories(self):
+        # Users can always see the repositories that they own, as well as public
+        # repositories.
+        owner = removeSecurityProxy(self.private_repository).owner
+        repositories = self.all_repositories.visibleByUser(owner)
+        self.assertEqual(
+            sorted([self.public_repository, self.private_repository]),
+            sorted(repositories.getRepositories()))
+
+    def test_launchpad_services_sees_all(self):
+        # The LAUNCHPAD_SERVICES special user sees *everything*.
+        repositories = self.all_repositories.visibleByUser(LAUNCHPAD_SERVICES)
+        self.assertEqual(
+            sorted(self.all_repositories.getRepositories()),
+            sorted(repositories.getRepositories()))
+
+    def test_admins_see_all(self):
+        # Launchpad administrators see *everything*.
+        admin = self.factory.makePerson()
+        admin_team = removeSecurityProxy(
+            getUtility(ILaunchpadCelebrities).admin)
+        admin_team.addMember(admin, admin_team.teamowner)
+        repositories = self.all_repositories.visibleByUser(admin)
+        self.assertEqual(
+            sorted(self.all_repositories.getRepositories()),
+            sorted(repositories.getRepositories()))
+
+    def test_private_teams_see_own_private_personal_repositories(self):
+        # Private teams are given an access grant to see their private
+        # personal repositories.
+        team_owner = self.factory.makePerson()
+        team = self.factory.makeTeam(
+            visibility=PersonVisibility.PRIVATE,
+            membership_policy=TeamMembershipPolicy.MODERATED,
+            owner=team_owner)
+        with person_logged_in(team_owner):
+            personal_repository = self.factory.makeGitRepository(
+                owner=team, target=team,
+                information_type=InformationType.USERDATA)
+            # The team is automatically subscribed to the repository since
+            # they are the owner.  We want to unsubscribe them so that they
+            # lose access conferred via subscription and rely instead on the
+            # APG.
+            # XXX cjwatson 2015-02-05: Uncomment this once
+            # GitRepositorySubscriptions exist.
+            #personal_repository.unsubscribe(team, team_owner, True)
+            # Make another personal repository the team can't see.
+            other_person = self.factory.makePerson()
+            self.factory.makeGitRepository(
+                owner=other_person, target=other_person,
+                information_type=InformationType.USERDATA)
+            repositories = self.all_repositories.visibleByUser(team)
+        self.assertEqual(
+            sorted([self.public_repository, personal_repository]),
+            sorted(repositories.getRepositories()))
+
+
+class TestSearch(TestCaseWithFactory):
+    """Tests for IGitCollection.search()."""
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        self.collection = getUtility(IAllGitRepositories)
+
+    def test_exact_match_unique_name(self):
+        # If you search for a unique name of a repository that exists,
+        # you'll get a single result with a repository with that repository
+        # name.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        search_results = self.collection.search(repository.unique_name)
+        self.assertEqual([repository], list(search_results))
+
+    def test_unique_name_match_not_in_collection(self):
+        # If you search for a unique name of a repository that does not
+        # exist, you'll get an empty result set.
+        repository = self.factory.makeGitRepository()
+        collection = self.collection.inProject(self.factory.makeProduct())
+        search_results = collection.search(repository.unique_name)
+        self.assertEqual([], list(search_results))
+
+    def test_exact_match_launchpad_url(self):
+        # If you search for the Launchpad URL of a repository, and there is
+        # a repository with that URL, then you get a single result with that
+        # repository.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        search_results = self.collection.search(repository.getCodebrowseUrl())
+        self.assertEqual([repository], list(search_results))
+
+    def test_exact_match_with_lp_colon_url(self):
+        repository = self.factory.makeGitRepository()
+        lp_name = 'lp:' + repository.unique_name
+        search_results = self.collection.search(lp_name)
+        self.assertEqual([repository], list(search_results))
+
+    def test_exact_match_bad_url(self):
+        search_results = self.collection.search('http:hahafail')
+        self.assertEqual([], list(search_results))
+
+    def test_exact_match_git_identity(self):
+        # If you search for the Git identity of a repository, then you get a
+        # single result with that repository.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        search_results = self.collection.search(repository.git_identity)
+        self.assertEqual([repository], list(search_results))
+
+    def test_exact_match_git_identity_development_focus(self):
+        # If you search for the development focus and it is set, you get a
+        # single result with the development focus repository.
+        fooix = self.factory.makeProduct(name='fooix')
+        repository = self.factory.makeGitRepository(
+            owner=fooix.owner, target=fooix)
+        with person_logged_in(fooix.owner):
+            getUtility(IGitRepositorySet).setDefaultRepository(
+                fooix, repository)
+        self.factory.makeGitRepository()
+        search_results = self.collection.search('lp:fooix')
+        self.assertEqual([repository], list(search_results))
+
+    def test_bad_match_git_identity_development_focus(self):
+        # If you search for the development focus for a project where one
+        # isn't set, you get an empty search result.
+        fooix = self.factory.makeProduct(name='fooix')
+        self.factory.makeGitRepository(target=fooix)
+        self.factory.makeGitRepository()
+        search_results = self.collection.search('lp:fooix')
+        self.assertEqual([], list(search_results))
+
+    def test_bad_match_git_identity_no_project(self):
+        # If you search for the development focus for a project where one
+        # isn't set, you get an empty search result.
+        self.factory.makeGitRepository()
+        search_results = self.collection.search('lp:fooix')
+        self.assertEqual([], list(search_results))
+
+    def test_exact_match_url_trailing_slash(self):
+        # Sometimes, users are inconsiderately unaware of our arbitrary
+        # database restrictions and will put trailing slashes on their
+        # search queries.  Rather bravely, we refuse to explode in this
+        # case.
+        repository = self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        search_results = self.collection.search(
+            repository.getCodebrowseUrl() + '/')
+        self.assertEqual([repository], list(search_results))
+
+    def test_match_exact_repository_name(self):
+        # search returns all repositories with the same name as the search
+        # term.
+        repository1 = self.factory.makeGitRepository(name=u'foo')
+        repository2 = self.factory.makeGitRepository(name=u'foo')
+        self.factory.makeGitRepository()
+        search_results = self.collection.search('foo')
+        self.assertEqual(
+            sorted([repository1, repository2]), sorted(search_results))
+
+    def disabled_test_match_against_unique_name(self):
+        # XXX cjwatson 2015-02-06: Disabled until the URL format settles
+        # down.
+        repository = self.factory.makeGitRepository(name=u'fooa')
+        search_term = repository.target.name + '/foo'
+        search_results = self.collection.search(search_term)
+        self.assertEqual([repository], list(search_results))
+
+    def test_match_sub_repository_name(self):
+        # search returns all repositories which have a name of which the
+        # search term is a substring.
+        repository1 = self.factory.makeGitRepository(name=u'afoo')
+        repository2 = self.factory.makeGitRepository(name=u'foob')
+        self.factory.makeGitRepository()
+        search_results = self.collection.search('foo')
+        self.assertEqual(
+            sorted([repository1, repository2]), sorted(search_results))
+
+    def test_match_ignores_case(self):
+        repository = self.factory.makeGitRepository(name=u'foobar')
+        search_results = self.collection.search('FOOBAR')
+        self.assertEqual([repository], list(search_results))
+
+    def test_dont_match_project_if_in_project(self):
+        # If the container is restricted to the project, then we don't match
+        # the project name.
+        project = self.factory.makeProduct('foo')
+        repository1 = self.factory.makeGitRepository(
+            target=project, name=u'foo')
+        self.factory.makeGitRepository(target=project, name=u'bar')
+        search_results = self.collection.inProject(project).search('foo')
+        self.assertEqual([repository1], list(search_results))
+
+
+class TestGetTeamsWithRepositories(TestCaseWithFactory):
+    """Test the IGitCollection.getTeamsWithRepositories method."""
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        self.all_repositories = getUtility(IAllGitRepositories)
+
+    def test_no_teams(self):
+        # If the user is not a member of any teams, there are no results,
+        # even if the person owns a repository themselves.
+        person = self.factory.makePerson()
+        self.factory.makeGitRepository(owner=person)
+        teams = list(self.all_repositories.getTeamsWithRepositories(person))
+        self.assertEqual([], teams)
+
+    def test_team_repositories(self):
+        # Return the teams that the user is in and that have repositories.
+        person = self.factory.makePerson()
+        team = self.factory.makeTeam(owner=person)
+        self.factory.makeGitRepository(owner=team)
+        # Make another team that person is in that has no repositories.
+        self.factory.makeTeam(owner=person)
+        teams = list(self.all_repositories.getTeamsWithRepositories(person))
+        self.assertEqual([team], teams)
+
+    def test_respects_restrictions(self):
+        # Create a team with repositories on a project, and another
+        # repository in a different namespace owned by a different team that
+        # the person is a member of.  Restricting the collection will return
+        # just the teams that have repositories in that restricted
+        # collection.
+        person = self.factory.makePerson()
+        team1 = self.factory.makeTeam(owner=person)
+        repository = self.factory.makeGitRepository(owner=team1)
+        # Make another team that person is in that owns a repository in a
+        # different namespace to the namespace of the repository owned by team1.
+        team2 = self.factory.makeTeam(owner=person)
+        self.factory.makeGitRepository(owner=team2)
+        collection = self.all_repositories.inProject(repository.target)
+        teams = list(collection.getTeamsWithRepositories(person))
+        self.assertEqual([team1], teams)
+
+
+class TestGitCollectionOwnerCounts(TestCaseWithFactory):
+    """Test IGitCollection.ownerCounts."""
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        TestCaseWithFactory.setUp(self)
+        self.all_repositories = getUtility(IAllGitRepositories)
+
+    def test_no_repositories(self):
+        # If there are no repositories, we should get zero counts for both.
+        person_count, team_count = self.all_repositories.ownerCounts()
+        self.assertEqual(0, person_count)
+        self.assertEqual(0, team_count)
+
+    def test_individual_repository_owners(self):
+        # Repositories owned by an individual are returned as the first part
+        # of the tuple.
+        self.factory.makeGitRepository()
+        self.factory.makeGitRepository()
+        person_count, team_count = self.all_repositories.ownerCounts()
+        self.assertEqual(2, person_count)
+        self.assertEqual(0, team_count)
+
+    def test_team_repository_owners(self):
+        # Repositories owned by teams are returned as the second part of the
+        # tuple.
+        self.factory.makeGitRepository(owner=self.factory.makeTeam())
+        self.factory.makeGitRepository(owner=self.factory.makeTeam())
+        person_count, team_count = self.all_repositories.ownerCounts()
+        self.assertEqual(0, person_count)
+        self.assertEqual(2, team_count)
+
+    def test_multiple_repositories_owned_counted_once(self):
+        # Confirming that a person that owns multiple repositories only gets
+        # counted once.
+        individual = self.factory.makePerson()
+        team = self.factory.makeTeam()
+        for owner in [individual, individual, team, team]:
+            self.factory.makeGitRepository(owner=owner)
+        person_count, team_count = self.all_repositories.ownerCounts()
+        self.assertEqual(1, person_count)
+        self.assertEqual(1, team_count)
+
+    def test_counts_limited_by_collection(self):
+        # For collections that are constrained in some way, we only get
+        # counts for the constrained collection.
+        r1 = self.factory.makeGitRepository()
+        project = r1.target
+        self.factory.makeGitRepository()
+        collection = self.all_repositories.inProject(project)
+        person_count, team_count = collection.ownerCounts()
+        self.assertEqual(1, person_count)