def makeBranches(self, branch_count, official_count=0):
"""Make some package branches.
Make `branch_count` branches, and make `official_count` of those
official branches.
"""
distroseries = self.distro.series[0]
# Make the branches created in the past in order.
time_gen = time_counter(delta=timedelta(days=-1))
branches = [
self.factory.makePackageBranch(
distroseries=distroseries,
sourcepackagename=self.sourcepackagename,
date_created=time_gen.next())
for i in range(branch_count)]
official = []
# Sort the pocket items so RELEASE is last, and thus first popped.
pockets = sorted(PackagePublishingPocket.items, reverse=True)
for i in range(official_count):
branch = branches.pop()
pocket = pockets.pop()
SeriesSourcePackageBranchSet.new(
distroseries, pocket, self.sourcepackagename,
branch, branch.owner)
official.append(branch)
return distroseries, branches, official
def setUp(self):
super(TestGetBranchTips, self).setUp()
self.distro = self.factory.makeDistribution()
series_1 = self.series_1 = self.factory.makeDistroSeries(self.distro)
series_2 = self.series_2 = self.factory.makeDistroSeries(self.distro)
source_package = self.factory.makeSourcePackage(distroseries=series_1)
branch = self.factory.makeBranch(sourcepackage=source_package)
unofficial_branch = self.factory.makeBranch(
sourcepackage=source_package)
registrant = self.factory.makePerson()
now = datetime.now(pytz.UTC)
sourcepackagename = self.factory.makeSourcePackageName()
SeriesSourcePackageBranchSet.new(
series_1, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant, now)
SeriesSourcePackageBranchSet.new(
series_2, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant, now)
self.factory.makeRevisionsForBranch(branch)
self.branch_name = branch.unique_name
self.unofficial_branch_name = unofficial_branch.unique_name
self.branch_last_scanned_id = branch.last_scanned_id
endInteraction()
self.lp = launchpadlib_for("anonymous-access")
self.lp_distro = self.lp.distributions[self.distro.name]
def setUp(self):
super(TestGetBranchTips, self).setUp()
self.distro = self.factory.makeDistribution()
series_1 = self.series_1 = self.factory.makeDistroSeries(self.distro)
series_2 = self.series_2 = self.factory.makeDistroSeries(self.distro)
source_package = self.factory.makeSourcePackage(distroseries=series_1)
branch = self.factory.makeBranch(sourcepackage=source_package)
unofficial_branch = self.factory.makeBranch(
sourcepackage=source_package)
registrant = self.factory.makePerson()
now = datetime.now(pytz.UTC)
sourcepackagename = self.factory.makeSourcePackageName()
SeriesSourcePackageBranchSet.new(series_1,
PackagePublishingPocket.RELEASE,
sourcepackagename, branch, registrant,
now)
SeriesSourcePackageBranchSet.new(series_2,
PackagePublishingPocket.RELEASE,
sourcepackagename, branch, registrant,
now)
self.factory.makeRevisionsForBranch(branch)
self.branch_name = branch.unique_name
self.unofficial_branch_name = unofficial_branch.unique_name
self.branch_last_scanned_id = branch.last_scanned_id
endInteraction()
self.lp = launchpadlib_for("anonymous-access")
self.lp_distro = self.lp.distributions[self.distro.name]
def makeBranches(self, branch_count, official_count=0):
"""Make some package branches.
Make `branch_count` branches, and make `official_count` of those
official branches.
"""
distroseries = self.distro.series[0]
# Make the branches created in the past in order.
time_gen = time_counter(delta=timedelta(days=-1))
branches = [
self.factory.makePackageBranch(
distroseries=distroseries,
sourcepackagename=self.sourcepackagename,
date_created=time_gen.next()) for i in range(branch_count)
]
official = []
# Sort the pocket items so RELEASE is last, and thus first popped.
pockets = sorted(PackagePublishingPocket.items, reverse=True)
for i in range(official_count):
branch = branches.pop()
pocket = pockets.pop()
SeriesSourcePackageBranchSet.new(distroseries, pocket,
self.sourcepackagename, branch,
branch.owner)
official.append(branch)
return distroseries, branches, official
def make_package_branches(factory, series, sourcepackagename, branch_count,
official_count=0, owner=None, registrant=None):
"""Make some package branches.
Make `branch_count` branches, and make `official_count` of those
official branches.
"""
if zisinstance(sourcepackagename, basestring):
sourcepackagename = factory.getOrMakeSourcePackageName(
sourcepackagename)
# Make the branches created in the past in order.
time_gen = time_counter(delta=timedelta(days=-1))
branch_names = consistent_branch_names()
branches = [
factory.makePackageBranch(
distroseries=series,
sourcepackagename=sourcepackagename,
date_created=time_gen.next(),
name=branch_names.next(), owner=owner, registrant=registrant)
for i in range(branch_count)]
official = []
# Sort the pocket items so RELEASE is last, and thus first popped.
pockets = sorted(PackagePublishingPocket.items, reverse=True)
# Since there can be only one link per pocket, max out the number of
# official branches at the pocket count.
for i in range(min(official_count, len(pockets))):
branch = branches.pop()
pocket = pockets.pop()
SeriesSourcePackageBranchSet.new(
series, pocket, sourcepackagename, branch, branch.owner)
official.append(branch)
return series, branches, official
def make_linked_package_branch(factory, distribution=None, sourcepackagename=None):
"""Make a new package branch and make it official."""
distro_series = factory.makeDistroSeries(distribution)
source_package = factory.makeSourcePackage(sourcepackagename=sourcepackagename, distroseries=distro_series)
branch = factory.makePackageBranch(sourcepackage=source_package)
pocket = PackagePublishingPocket.RELEASE
# It is possible for the param to be None, so reset to the factory
# generated one.
sourcepackagename = source_package.sourcepackagename
SeriesSourcePackageBranchSet.new(distro_series, pocket, sourcepackagename, branch, branch.owner)
return branch
def test_getBranch_exists(self):
# If there is a SeriesSourcePackageBranch entry for that source
# package and pocket, then return the branch.
sourcepackage = self.factory.makeSourcePackage()
registrant = self.factory.makePerson()
branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)
SeriesSourcePackageBranchSet.new(
sourcepackage.distroseries, PackagePublishingPocket.RELEASE,
sourcepackage.sourcepackagename, branch, registrant)
official_branch = sourcepackage.getBranch(
PackagePublishingPocket.RELEASE)
self.assertEqual(branch, official_branch)
def test_delete(self):
# `delete` ensures that there is no branch associated with that
# sourcepackage and pocket.
branch = self.factory.makePackageBranch()
package = branch.sourcepackage
SeriesSourcePackageBranchSet.new(
package.distroseries, PackagePublishingPocket.RELEASE,
package.sourcepackagename, branch, self.factory.makePerson())
SeriesSourcePackageBranchSet.delete(
package, PackagePublishingPocket.RELEASE)
find_branch_links = getUtility(IFindOfficialBranchLinks)
self.assertEqual(
[], list(find_branch_links.findForSourcePackage(package)))
def test_getBranch_exists(self):
# If there is a SeriesSourcePackageBranch entry for that source
# package and pocket, then return the branch.
sourcepackage = self.factory.makeSourcePackage()
registrant = self.factory.makePerson()
branch = self.factory.makePackageBranch(sourcepackage=sourcepackage)
SeriesSourcePackageBranchSet.new(sourcepackage.distroseries,
PackagePublishingPocket.RELEASE,
sourcepackage.sourcepackagename,
branch, registrant)
official_branch = sourcepackage.getBranch(
PackagePublishingPocket.RELEASE)
self.assertEqual(branch, official_branch)
def make_linked_package_branch(factory, distribution=None,
sourcepackagename=None):
"""Make a new package branch and make it official."""
distro_series = factory.makeDistroSeries(distribution)
source_package = factory.makeSourcePackage(
sourcepackagename=sourcepackagename, distroseries=distro_series)
branch = factory.makePackageBranch(sourcepackage=source_package)
pocket = PackagePublishingPocket.RELEASE
# It is possible for the param to be None, so reset to the factory
# generated one.
sourcepackagename = source_package.sourcepackagename
SeriesSourcePackageBranchSet.new(
distro_series, pocket, sourcepackagename, branch, branch.owner)
return branch
def test_delete(self):
# `delete` ensures that there is no branch associated with that
# sourcepackage and pocket.
branch = self.factory.makePackageBranch()
package = branch.sourcepackage
SeriesSourcePackageBranchSet.new(package.distroseries,
PackagePublishingPocket.RELEASE,
package.sourcepackagename, branch,
self.factory.makePerson())
SeriesSourcePackageBranchSet.delete(package,
PackagePublishingPocket.RELEASE)
find_branch_links = getUtility(IFindOfficialBranchLinks)
self.assertEqual([],
list(find_branch_links.findForSourcePackage(package)))
def setBranch(self, pocket, branch, registrant):
"""See `ISourcePackage`."""
SeriesSourcePackageBranchSet.delete(self, pocket)
if branch is not None:
SeriesSourcePackageBranchSet.new(self.distroseries, pocket,
self.sourcepackagename, branch,
registrant)
# Avoid circular imports.
from lp.registry.model.distributionsourcepackage import (
DistributionSourcePackage, )
DistributionSourcePackage.ensure(sourcepackage=self)
else:
# Delete the official DSP if there is no publishing history.
self.distribution_sourcepackage.delete()
def test_findForBranch(self):
# IFindOfficialBranchLinks.findForBranch returns a result set of
# links from the branch to source packages & pockets. Each link is an
# ISeriesSourcePackageBranch.
branch = self.factory.makePackageBranch()
package = branch.sourcepackage
SeriesSourcePackageBranchSet.new(
package.distroseries, PackagePublishingPocket.RELEASE,
package.sourcepackagename, branch, self.factory.makePerson())
find_branch_links = getUtility(IFindOfficialBranchLinks)
[link] = list(find_branch_links.findForBranch(branch))
self.assertEqual(PackagePublishingPocket.RELEASE, link.pocket)
self.assertEqual(branch, link.branch)
self.assertEqual(link.distroseries, package.distroseries)
self.assertEqual(link.sourcepackagename, package.sourcepackagename)
def test_findForBranch(self):
# IFindOfficialBranchLinks.findForBranch returns a result set of
# links from the branch to source packages & pockets. Each link is an
# ISeriesSourcePackageBranch.
branch = self.factory.makePackageBranch()
package = branch.sourcepackage
SeriesSourcePackageBranchSet.new(package.distroseries,
PackagePublishingPocket.RELEASE,
package.sourcepackagename, branch,
self.factory.makePerson())
find_branch_links = getUtility(IFindOfficialBranchLinks)
[link] = list(find_branch_links.findForBranch(branch))
self.assertEqual(PackagePublishingPocket.RELEASE, link.pocket)
self.assertEqual(branch, link.branch)
self.assertEqual(link.distroseries, package.distroseries)
self.assertEqual(link.sourcepackagename, package.sourcepackagename)
def test_package_development_focus(self):
# Check the bzr_identity of a development focus package branch.
branch = self.factory.makePackageBranch()
SeriesSourcePackageBranchSet.new(
branch.distroseries, PackagePublishingPocket.RELEASE,
branch.sourcepackagename, branch, branch.owner)
identity = "lp://dev/%s/%s" % (
branch.distribution.name, branch.sourcepackagename.name)
self.assertEqual(identity, branch.bzr_identity)
# Now confirm that we get the same through the view.
view = create_initialized_view(
branch.distribution, name='+branches', rootsite='code')
# There is only one branch.
batch = view.branches()
[view_branch] = batch.branches
self.assertStatementCount(0, getattr, view_branch, 'bzr_identity')
self.assertEqual(identity, view_branch.bzr_identity)
def test_package_development_focus(self):
# Check the bzr_identity of a development focus package branch.
branch = self.factory.makePackageBranch()
SeriesSourcePackageBranchSet.new(branch.distroseries,
PackagePublishingPocket.RELEASE,
branch.sourcepackagename, branch,
branch.owner)
identity = "lp://dev/%s/%s" % (branch.distribution.name,
branch.sourcepackagename.name)
self.assertEqual(identity, branch.bzr_identity)
# Now confirm that we get the same through the view.
view = create_initialized_view(branch.distribution,
name='+branches',
rootsite='code')
# There is only one branch.
batch = view.branches()
[view_branch] = batch.branches
self.assertStatementCount(0, getattr, view_branch, 'bzr_identity')
self.assertEqual(identity, view_branch.bzr_identity)
def test_new_returns_ISeriesSourcePackageBranch(self):
# SeriesSourcePackageBranchSet.new returns an
# ISeriesSourcePackageBranch, know what I mean?
distroseries = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
registrant = self.factory.makePerson()
branch = self.factory.makeAnyBranch()
sspb = SeriesSourcePackageBranchSet.new(
distroseries, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant)
self.assertProvides(sspb, ISeriesSourcePackageBranch)
def test_new_returns_ISeriesSourcePackageBranch(self):
# SeriesSourcePackageBranchSet.new returns an
# ISeriesSourcePackageBranch, know what I mean?
distroseries = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
registrant = self.factory.makePerson()
branch = self.factory.makeAnyBranch()
sspb = SeriesSourcePackageBranchSet.new(
distroseries, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant)
self.assertProvides(sspb, ISeriesSourcePackageBranch)
def test_new_inserts_into_db(self):
# SeriesSourcePackageBranchSet.new inserts the new object into the
# database, giving it an ID.
distroseries = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
registrant = self.factory.makePerson()
branch = self.factory.makeAnyBranch()
sspb = SeriesSourcePackageBranchSet.new(
distroseries, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant)
transaction.commit()
self.assertIsNot(sspb.id, None)
def test_new_inserts_into_db(self):
# SeriesSourcePackageBranchSet.new inserts the new object into the
# database, giving it an ID.
distroseries = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
registrant = self.factory.makePerson()
branch = self.factory.makeAnyBranch()
sspb = SeriesSourcePackageBranchSet.new(
distroseries, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant)
transaction.commit()
self.assertIsNot(sspb.id, None)
def make_package_branches(
factory, series, sourcepackagename, branch_count, official_count=0, owner=None, registrant=None
):
"""Make some package branches.
Make `branch_count` branches, and make `official_count` of those
official branches.
"""
if zisinstance(sourcepackagename, basestring):
sourcepackagename = factory.getOrMakeSourcePackageName(sourcepackagename)
# Make the branches created in the past in order.
time_gen = time_counter(delta=timedelta(days=-1))
branch_names = consistent_branch_names()
branches = [
factory.makePackageBranch(
distroseries=series,
sourcepackagename=sourcepackagename,
date_created=time_gen.next(),
name=branch_names.next(),
owner=owner,
registrant=registrant,
)
for i in range(branch_count)
]
official = []
# Sort the pocket items so RELEASE is last, and thus first popped.
pockets = sorted(PackagePublishingPocket.items, reverse=True)
# Since there can be only one link per pocket, max out the number of
# official branches at the pocket count.
for i in range(min(official_count, len(pockets))):
branch = branches.pop()
pocket = pockets.pop()
SeriesSourcePackageBranchSet.new(series, pocket, sourcepackagename, branch, branch.owner)
official.append(branch)
return series, branches, official
def test_new_sets_attributes(self):
# SeriesSourcePackageBranchSet.new sets all the defined attributes on
# the interface.
distroseries = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
registrant = self.factory.makePerson()
branch = self.factory.makeAnyBranch()
now = datetime.now(pytz.UTC)
sspb = SeriesSourcePackageBranchSet.new(
distroseries, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant, now)
self.assertEqual(distroseries, sspb.distroseries)
self.assertEqual(PackagePublishingPocket.RELEASE, sspb.pocket)
self.assertEqual(sourcepackagename, sspb.sourcepackagename)
self.assertEqual(branch, sspb.branch)
self.assertEqual(registrant, sspb.registrant)
self.assertEqual(now, sspb.date_created)
def test_new_sets_attributes(self):
# SeriesSourcePackageBranchSet.new sets all the defined attributes on
# the interface.
distroseries = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
registrant = self.factory.makePerson()
branch = self.factory.makeAnyBranch()
now = datetime.now(pytz.UTC)
sspb = SeriesSourcePackageBranchSet.new(
distroseries, PackagePublishingPocket.RELEASE, sourcepackagename,
branch, registrant, now)
self.assertEqual(distroseries, sspb.distroseries)
self.assertEqual(PackagePublishingPocket.RELEASE, sspb.pocket)
self.assertEqual(sourcepackagename, sspb.sourcepackagename)
self.assertEqual(branch, sspb.branch)
self.assertEqual(registrant, sspb.registrant)
self.assertEqual(now, sspb.date_created)
class TestSeriesSourcePackageBranchSet(TestCaseWithFactory):
"""Tests for `SeriesSourcePackageBranchSet`."""
layer = DatabaseFunctionalLayer
def setUp(self):
TestCaseWithFactory.setUp(self)
self.link_set = SeriesSourcePackageBranchSet()
def makeLinkedPackageBranch(self, distribution, sourcepackagename):
"""Make a new package branch and make it official."""
return make_linked_package_branch(
self.factory, distribution, sourcepackagename)
def test_findForDistributionSourcePackage(self):
# Make sure that the find method finds official links for all distro
# series for the distribution source package.
distro_source_package = self.factory.makeDistributionSourcePackage()
distribution = distro_source_package.distribution
sourcepackagename = distro_source_package.sourcepackagename
# Make two package branches in different series of the same distro.
b1 = self.makeLinkedPackageBranch(distribution, sourcepackagename)
b2 = self.makeLinkedPackageBranch(distribution, sourcepackagename)
# Make one more on same source package on different distro.
self.makeLinkedPackageBranch(None, sourcepackagename)
# Make one more on different source package, same different distro.
self.makeLinkedPackageBranch(distribution, None)
# And one more unrelated linked package branch.
self.makeLinkedPackageBranch(None, None)
links = self.link_set.findForDistributionSourcePackage(
distro_source_package)
self.assertEqual(
sorted([b1, b2]), sorted([link.branch for link in links]))
def test_delete(self):
# SeriesSourcePackageBranchSet.delete removes the link between a
# particular branch and a (distro_series, pocket, sourcepackagename)
# tupled.
distro_series = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
sourcepackage = self.factory.makeSourcePackage(
sourcepackagename=sourcepackagename, distroseries=distro_series)
branch_release = self.factory.makePackageBranch(
distroseries=distro_series, sourcepackagename=sourcepackagename)
branch_updates = self.factory.makePackageBranch(
distroseries=distro_series, sourcepackagename=sourcepackagename)
self.link_set.new(
distro_series, PackagePublishingPocket.RELEASE, sourcepackagename,
branch_release, branch_release.owner)
self.link_set.new(
distro_series, PackagePublishingPocket.UPDATES, sourcepackagename,
branch_updates, branch_updates.owner)
self.link_set.delete(sourcepackage, PackagePublishingPocket.UPDATES)
links = self.link_set.findForSourcePackage(sourcepackage)
self.assertEqual(
sorted([branch_release]), sorted([link.branch for link in links]))
def setUp(self):
TestCaseWithFactory.setUp(self)
self.link_set = SeriesSourcePackageBranchSet()
class TestSeriesSourcePackageBranchSet(TestCaseWithFactory):
"""Tests for `SeriesSourcePackageBranchSet`."""
layer = DatabaseFunctionalLayer
def setUp(self):
TestCaseWithFactory.setUp(self)
self.link_set = SeriesSourcePackageBranchSet()
def makeLinkedPackageBranch(self, distribution, sourcepackagename):
"""Make a new package branch and make it official."""
return make_linked_package_branch(self.factory, distribution,
sourcepackagename)
def test_findForDistributionSourcePackage(self):
# Make sure that the find method finds official links for all distro
# series for the distribution source package.
distro_source_package = self.factory.makeDistributionSourcePackage()
distribution = distro_source_package.distribution
sourcepackagename = distro_source_package.sourcepackagename
# Make two package branches in different series of the same distro.
b1 = self.makeLinkedPackageBranch(distribution, sourcepackagename)
b2 = self.makeLinkedPackageBranch(distribution, sourcepackagename)
# Make one more on same source package on different distro.
self.makeLinkedPackageBranch(None, sourcepackagename)
# Make one more on different source package, same different distro.
self.makeLinkedPackageBranch(distribution, None)
# And one more unrelated linked package branch.
self.makeLinkedPackageBranch(None, None)
links = self.link_set.findForDistributionSourcePackage(
distro_source_package)
self.assertEqual(sorted([b1, b2]),
sorted([link.branch for link in links]))
def test_delete(self):
# SeriesSourcePackageBranchSet.delete removes the link between a
# particular branch and a (distro_series, pocket, sourcepackagename)
# tupled.
distro_series = self.factory.makeDistroSeries()
sourcepackagename = self.factory.makeSourcePackageName()
sourcepackage = self.factory.makeSourcePackage(
sourcepackagename=sourcepackagename, distroseries=distro_series)
branch_release = self.factory.makePackageBranch(
distroseries=distro_series, sourcepackagename=sourcepackagename)
branch_updates = self.factory.makePackageBranch(
distroseries=distro_series, sourcepackagename=sourcepackagename)
self.link_set.new(distro_series, PackagePublishingPocket.RELEASE,
sourcepackagename, branch_release,
branch_release.owner)
self.link_set.new(distro_series, PackagePublishingPocket.UPDATES,
sourcepackagename, branch_updates,
branch_updates.owner)
self.link_set.delete(sourcepackage, PackagePublishingPocket.UPDATES)
links = self.link_set.findForSourcePackage(sourcepackage)
self.assertEqual(sorted([branch_release]),
sorted([link.branch for link in links]))
def setUp(self):
TestCaseWithFactory.setUp(self)
self.link_set = SeriesSourcePackageBranchSet()
