def addSummaryToDifference(self, distro_series_difference):
"""Helper that adds binaries with summary info to the source pubs."""
# Avoid circular import.
from lp.soyuz.tests.test_publishing import SoyuzTestPublisher
distro_series = distro_series_difference.derived_series
parent_series = distro_series_difference.parent_series
source_package_name_str = (
distro_series_difference.source_package_name.name)
stp = SoyuzTestPublisher()
if distro_series_difference.difference_type == (
DistroSeriesDifferenceType.MISSING_FROM_DERIVED_SERIES):
source_pub = distro_series_difference.parent_source_pub
else:
source_pub = distro_series_difference.source_pub
stp.makeSourcePackageSummaryData(source_pub)
stp.updateDistroSeriesPackageCache(source_pub.distroseries)
# updateDistroSeriesPackageCache reconnects the db, so the
# objects need to be reloaded.
dsd_source = getUtility(IDistroSeriesDifferenceSource)
ds_diff = dsd_source.getByDistroSeriesNameAndParentSeries(
distro_series, source_package_name_str, parent_series)
return ds_diff
def create_child(factory):
processor = factory.makeProcessor()
parent = factory.makeDistroSeries()
parent_das = factory.makeDistroArchSeries(distroseries=parent, processor=processor)
lf = factory.makeLibraryFileAlias()
# Since the LFA needs to be in the librarian, commit.
transaction.commit()
parent_das.addOrUpdateChroot(lf)
with celebrity_logged_in("admin"):
parent_das.supports_virtualized = True
parent.nominatedarchindep = parent_das
publisher = SoyuzTestPublisher()
publisher.prepareBreezyAutotest()
packages = {"udev": "0.1-1", "libc6": "2.8-1"}
for package in packages.keys():
publisher.getPubBinaries(
distroseries=parent,
binaryname=package,
version=packages[package],
status=PackagePublishingStatus.PUBLISHED,
)
test1 = getUtility(IPackagesetSet).new(u"test1", u"test 1 packageset", parent.owner, distroseries=parent)
test1_packageset_id = str(test1.id)
test1.addSources("udev")
parent.updatePackageCount()
child = factory.makeDistroSeries()
getUtility(ISourcePackageFormatSelectionSet).add(child, SourcePackageFormat.FORMAT_1_0)
# Make sure everything hits the database, switching db users aborts.
transaction.commit()
return parent, child, test1_packageset_id
class TestBuildJobBase(TestCaseWithFactory):
"""Setup the test publisher and some builders."""
layer = LaunchpadZopelessLayer
def setUp(self):
super(TestBuildJobBase, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.i8 = self.factory.makeBuilder(name='i386-n-8', virtualized=False)
self.i9 = self.factory.makeBuilder(name='i386-n-9', virtualized=False)
processor = getUtility(IProcessorSet).getByName('hppa')
self.h6 = self.factory.makeBuilder(
name='hppa-n-6', processor=processor, virtualized=False)
self.h7 = self.factory.makeBuilder(
name='hppa-n-7', processor=processor, virtualized=False)
self.builders = dict()
# x86 native
self.builders[(1, False)] = [self.i8, self.i9]
# hppa native
self.builders[(3, True)] = [self.h6, self.h7]
# Ensure all builders are operational.
for builders in self.builders.values():
for builder in builders:
builder.builderok = True
builder.manual = False
# Disable the sample data builders.
getUtility(IBuilderSet)['bob'].builderok = False
getUtility(IBuilderSet)['frog'].builderok = False
def test_dispatchBuildToSlave(self):
# Ensure dispatchBuildToSlave will make the right calls to the slave
job = self.makeJob()
test_publisher = SoyuzTestPublisher()
test_publisher.addFakeChroots(job.build.distroseries)
slave = OkSlave()
builder = MockBuilder("bob-de-bouwer")
builder.processor = getUtility(IProcessorSet).getByName("386")
job.setBuilder(builder, slave)
logger = BufferLogger()
d = defer.maybeDeferred(job.dispatchBuildToSlave, "someid", logger)
def check_dispatch(ignored):
self.assertThat(
logger.getLogBuffer(),
StartsWith(
dedent(
"""\
INFO Sending chroot file for recipe build to bob-de-bouwer
INFO Initiating build 1-someid on http://fake:0000
"""
)
),
)
self.assertEquals(["ensurepresent", "build"], [call[0] for call in slave.call_log])
build_args = slave.call_log[1][1:]
self.assertEquals(build_args[0], job.getBuildCookie())
self.assertEquals(build_args[1], "sourcepackagerecipe")
self.assertEquals(build_args[3], [])
distroarchseries = job.build.distroseries.architectures[0]
self.assertEqual(build_args[4], job._extraBuildArgs(distroarchseries))
return d.addCallback(check_dispatch)
def setUp(self):
"""Make a PPA and publish some sources that need builds."""
TestCaseWithFactory.setUp(self)
self.stp = SoyuzTestPublisher()
self.stp.prepareBreezyAutotest()
# i386 and hppa are enabled by STP but we need to mark hppa as
# PPA-enabled.
self.stp.breezy_autotest_hppa.supports_virtualized = True
# Create an arch-any and an arch-all source in a PPA.
self.ppa = self.factory.makeArchive(purpose=ArchivePurpose.PPA,
distribution=self.stp.ubuntutest)
self.all = self.stp.getPubSource(
sourcename="all",
architecturehintlist="all",
archive=self.ppa,
status=PackagePublishingStatus.PUBLISHED)
self.any = self.stp.getPubSource(
sourcename="any",
architecturehintlist="any",
archive=self.ppa,
status=PackagePublishingStatus.PUBLISHED)
self.required_arches = [
self.stp.breezy_autotest_hppa, self.stp.breezy_autotest_i386
]
def setUp(self):
super(TestDistributionHasBuildRecords, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create the machinery we need to create builds, such as
# DistroArchSeries and builders.
self.processor_one = self.factory.makeProcessor()
self.processor_two = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.distribution = self.distroseries.distribution
self.das_one = self.factory.makeDistroArchSeries(
distroseries=self.distroseries,
processor=self.processor_one,
supports_virtualized=True)
self.das_two = self.factory.makeDistroArchSeries(
distroseries=self.distroseries,
processor=self.processor_two,
supports_virtualized=True)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
self.arch_ids = [arch.id for arch in self.distroseries.architectures]
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das_one
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder_one = self.factory.makeBuilder(
processor=self.processor_one)
self.builder_two = self.factory.makeBuilder(
processor=self.processor_two)
self.builds = []
self.createBuilds()
def test_dispatchBuildToSlave(self):
# Ensure dispatchBuildToSlave will make the right calls to the slave
job = self.makeJob()
test_publisher = SoyuzTestPublisher()
test_publisher.addFakeChroots(job.build.distroseries)
slave = OkSlave()
builder = MockBuilder("bob-de-bouwer")
builder.processor = getUtility(IProcessorSet).getByName('386')
job.setBuilder(builder, slave)
logger = BufferLogger()
d = defer.maybeDeferred(job.dispatchBuildToSlave, "someid", logger)
def check_dispatch(ignored):
self.assertThat(
logger.getLogBuffer(),
StartsWith(
dedent("""\
INFO Sending chroot file for recipe build to bob-de-bouwer
INFO Initiating build 1-someid on http://fake:0000
""")))
self.assertEquals(["ensurepresent", "build"],
[call[0] for call in slave.call_log])
build_args = slave.call_log[1][1:]
self.assertEquals(build_args[0], job.getBuildCookie())
self.assertEquals(build_args[1], "sourcepackagerecipe")
self.assertEquals(build_args[3], [])
distroarchseries = job.build.distroseries.architectures[0]
self.assertEqual(build_args[4],
job._extraBuildArgs(distroarchseries))
return d.addCallback(check_dispatch)
class TestDistributionHasBuildRecords(TestCaseWithFactory):
"""Populate a distroseries with builds"""
layer = LaunchpadZopelessLayer
def setUp(self):
super(TestDistributionHasBuildRecords, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create the machinery we need to create builds, such as
# DistroArchSeries and builders.
self.processor_one = self.factory.makeProcessor()
self.processor_two = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.distribution = self.distroseries.distribution
self.das_one = self.factory.makeDistroArchSeries(
distroseries=self.distroseries,
processor=self.processor_one,
supports_virtualized=True)
self.das_two = self.factory.makeDistroArchSeries(
distroseries=self.distroseries,
processor=self.processor_two,
supports_virtualized=True)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
self.arch_ids = [arch.id for arch in self.distroseries.architectures]
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das_one
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder_one = self.factory.makeBuilder(
processor=self.processor_one)
self.builder_two = self.factory.makeBuilder(
processor=self.processor_two)
self.builds = []
self.createBuilds()
def createBuilds(self):
for i in range(5):
# Create some test builds.
spph = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
version="%s.%s" % (self.factory.getUniqueInteger(), i),
distroseries=self.distroseries,
architecturehintlist='any')
builds = spph.createMissingBuilds()
for b in builds:
b.updateStatus(BuildStatus.BUILDING)
if i == 4:
b.updateStatus(BuildStatus.FAILEDTOBUILD)
else:
b.updateStatus(BuildStatus.FULLYBUILT)
b.buildqueue_record.destroySelf()
self.builds += builds
def test_get_build_records(self):
# A Distribution also implements IHasBuildRecords.
builds = self.distribution.getBuildRecords().count()
self.assertEquals(10, builds)
def test_copy_archive_without_leak(self):
# If source publications are copied to a .COPY archive, they don't
# "leak" into SourcePackage.getBuildRecords().
admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Set up a distroseries and related bits, so we can create builds.
source_name = self.factory.getUniqueString()
spn = self.factory.makeSourcePackageName(name=source_name)
processor = self.factory.makeProcessor()
distroseries = self.factory.makeDistroSeries()
das = self.factory.makeDistroArchSeries(
distroseries=distroseries, processor=processor,
supports_virtualized=True)
with person_logged_in(admin):
publisher = SoyuzTestPublisher()
publisher.prepareBreezyAutotest()
publisher.addFakeChroots(distroseries=distroseries)
distroseries.nominatedarchindep = das
self.factory.makeBuilder(processor=processor)
spph = self.factory.makeSourcePackagePublishingHistory(
sourcepackagename=spn, distroseries=distroseries)
spph.createMissingBuilds()
# Create a copy archive.
copy = self.factory.makeArchive(
purpose=ArchivePurpose.COPY,
distribution=distroseries.distribution)
# And copy the publication into it.
copy_spph = spph.copyTo(
distroseries, PackagePublishingPocket.RELEASE, copy)
[copy_build] = copy_spph.createMissingBuilds()
builds = copy.getBuildRecords()
self.assertEquals([copy_build], list(builds))
source = SourcePackage(spn, spph.distroseries)
# SourcePackage.getBuildRecords() doesn't have two build records.
builds = source.getBuildRecords().count()
self.assertEquals(1, builds)
def test_handles_packaging_references(self):
person = self.factory.makePerson()
person_id = person.id
account_id = person.account.id
self.factory.makeGPGKey(person)
publisher = SoyuzTestPublisher()
publisher.person = person
ubuntu = getUtility(ILaunchpadCelebrities).ubuntu
spph = publisher.getPubSource(status=PackagePublishingStatus.PUBLISHED,
distroseries=ubuntu.currentseries,
maintainer=person,
creator=person)
with dbuser('garbo_frequently'):
job = PopulateLatestPersonSourcePackageReleaseCache(
DevNullLogger())
while not job.isDone():
job(chunk_size=100)
self.assertTrue(person.hasMaintainedPackages())
script = self.makeScript([six.ensure_str(person.name)])
with dbuser('launchpad'):
self.runScript(script)
self.assertRemoved(account_id, person_id)
self.assertEqual(person, spph.package_maintainer)
self.assertEqual(person, spph.package_creator)
self.assertFalse(person.hasMaintainedPackages())
def setUp(self):
super(TestBuildSet, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
self.processor_one = self.factory.makeProcessor(
supports_virtualized=True)
self.processor_two = self.factory.makeProcessor(
supports_virtualized=True)
self.distroseries = self.factory.makeDistroSeries()
self.distribution = self.distroseries.distribution
self.das_one = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_one)
self.das_two = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_two)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das_one
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.factory.makeBuilder(processors=[self.processor_one])
self.factory.makeBuilder(processors=[self.processor_two])
self.builds = []
self.spphs = []
def _prepareMergeCopy(self):
"""Add a fresher and a new package to ubuntu/hoary.
This is used to test merge copy functionality."""
test_publisher = SoyuzTestPublisher()
ubuntu = getUtility(IDistributionSet).getByName('ubuntu')
hoary = ubuntu.getSeries('hoary')
test_publisher.addFakeChroots(hoary)
test_publisher.setUpDefaultDistroSeries(hoary)
test_publisher.getPubSource(sourcename="new-in-second-round",
version="1.0",
distroseries=hoary,
archive=ubuntu.main_archive)
test_publisher.getPubSource(sourcename="alsa-utils",
version="2.0",
distroseries=hoary,
archive=ubuntu.main_archive)
sources = ubuntu.main_archive.getPublishedSources(
distroseries=hoary,
status=self.pending_statuses,
name=u'alsa-utils')
for src in sources:
if src.source_package_version != '2.0':
src.supersede()
LaunchpadZopelessLayer.txn.commit()
def setUp(self):
super(TestBuildNotify, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create all of the items we need to create builds
self.processor = self.factory.makeProcessor(supports_virtualized=True)
self.distroseries = self.factory.makeDistroSeries()
self.das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor)
self.creator = self.factory.makePerson(email='*****@*****.**')
self.gpgkey = self.factory.makeGPGKey(owner=self.creator)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
self.ppa = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PPA)
buildd_admins = getUtility(IPersonSet).getByName(
'launchpad-buildd-admins')
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder = self.factory.makeBuilder(
processors=[self.processor])
self.buildd_admins_members = list(buildd_admins.activemembers)
self.builds = []
def setUp(self):
"""Create the Soyuz test publisher."""
TestCaseWithFactory.setUp(self)
self.stp = SoyuzTestPublisher()
self.stp.prepareBreezyAutotest()
self.test_package_name = u"accept-test"
self.distro = self.factory.makeDistribution()
def setUp(self):
super(TestBuildJobBase, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.i8 = self.factory.makeBuilder(name='i386-n-8', virtualized=False)
self.i9 = self.factory.makeBuilder(name='i386-n-9', virtualized=False)
processor = getUtility(IProcessorSet).getByName('hppa')
self.h6 = self.factory.makeBuilder(name='hppa-n-6',
processor=processor,
virtualized=False)
self.h7 = self.factory.makeBuilder(name='hppa-n-7',
processor=processor,
virtualized=False)
self.builders = dict()
# x86 native
self.builders[(1, False)] = [self.i8, self.i9]
# hppa native
self.builders[(3, True)] = [self.h6, self.h7]
# Ensure all builders are operational.
for builders in self.builders.values():
for builder in builders:
builder.builderok = True
builder.manual = False
# Disable the sample data builders.
getUtility(IBuilderSet)['bob'].builderok = False
getUtility(IBuilderSet)['frog'].builderok = False
def setUp(self):
super(TestDetermineArchitecturesToBuild, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
armel = self.factory.makeProcessor('armel', 'armel', 'armel')
self.publisher.breezy_autotest.newArch(
'armel', armel, False, self.publisher.person)
self.publisher.addFakeChroots()
class TestDistributionHasBuildRecords(TestCaseWithFactory):
"""Populate a distroseries with builds"""
layer = LaunchpadZopelessLayer
def setUp(self):
super(TestDistributionHasBuildRecords, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create the machinery we need to create builds, such as
# DistroArchSeries and builders.
self.processor_one = self.factory.makeProcessor()
self.processor_two = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.distribution = self.distroseries.distribution
self.das_one = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_one,
supports_virtualized=True)
self.das_two = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_two,
supports_virtualized=True)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
self.arch_ids = [arch.id for arch in self.distroseries.architectures]
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das_one
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder_one = self.factory.makeBuilder(
processor=self.processor_one)
self.builder_two = self.factory.makeBuilder(
processor=self.processor_two)
self.builds = []
self.createBuilds()
def createBuilds(self):
for i in range(5):
# Create some test builds.
spph = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
version="%s.%s" % (self.factory.getUniqueInteger(), i),
distroseries=self.distroseries, architecturehintlist='any')
builds = spph.createMissingBuilds()
for b in builds:
b.updateStatus(BuildStatus.BUILDING)
if i == 4:
b.updateStatus(BuildStatus.FAILEDTOBUILD)
else:
b.updateStatus(BuildStatus.FULLYBUILT)
b.buildqueue_record.destroySelf()
self.builds += builds
def test_get_build_records(self):
# A Distribution also implements IHasBuildRecords.
builds = self.distribution.getBuildRecords().count()
self.assertEquals(10, builds)
def test_composeBuildRequest(self):
job = self.makeJob(with_builder=True)
test_publisher = SoyuzTestPublisher()
test_publisher.addFakeChroots(job.build.distroseries)
das = job.build.distroseries.nominatedarchindep
build_request = yield job.composeBuildRequest(None)
extra_args = yield job.extraBuildArgs()
self.assertEqual(
('sourcepackagerecipe', das, job.build.pocket, {}, extra_args),
build_request)
def setUp(self):
super(TestSourcesList, self).setUp()
self.publisher = SoyuzTestPublisher()
self.ubuntu = getUtility(IDistributionSet).getByName("ubuntu")
self.hoary = self.ubuntu.getSeries("hoary")
self.publisher.addFakeChroots(self.hoary)
self.publisher.setUpDefaultDistroSeries(self.hoary)
for component_name in self.ubuntu_components:
component = getUtility(IComponentSet)[component_name]
if component not in self.hoary.components:
self.factory.makeComponentSelection(self.hoary, component)
def setUp(self):
# Log in as an admin, so that we can create distributions.
super(CurrentSourceReleasesMixin, self).setUp()
login('*****@*****.**')
self.publisher = SoyuzTestPublisher()
self.factory = self.publisher.factory
self.development_series = self.publisher.setUpDefaultDistroSeries()
self.distribution = self.development_series.distribution
self.published_package = self.target.getSourcePackage(
self.publisher.default_package_name)
login(ANONYMOUS)
def _makePublishedSourcePackage(self):
test_publisher = SoyuzTestPublisher()
test_data = test_publisher.makeSourcePackageSummaryData()
source_package_name = test_data["source_package"].sourcepackagename.name
distroseries_id = test_data["distroseries"].id
test_publisher.updateDistroSeriesPackageCache(test_data["distroseries"])
# updateDistroSeriesPackageCache reconnects the db, so the
# objects need to be reloaded.
distroseries = getUtility(IDistroSeriesSet).get(distroseries_id)
return distroseries.getSourcePackage(source_package_name)
def _makePublishedSourcePackage(self):
test_publisher = SoyuzTestPublisher()
test_data = test_publisher.makeSourcePackageSummaryData()
source_package_name = (
test_data['source_package'].sourcepackagename.name)
distroseries_id = test_data['distroseries'].id
test_publisher.updatePackageCache(test_data['distroseries'])
# updatePackageCache reconnects the db, so the objects need to be
# reloaded.
distroseries = getUtility(IDistroSeriesSet).get(distroseries_id)
return distroseries.getSourcePackage(source_package_name)
def setUp(self):
"""Set up some test publications."""
super(ArchiveExpiryTestBase, self).setUp()
# Configure the test publisher.
switch_dbuser("launchpad")
self.stp = SoyuzTestPublisher()
self.stp.prepareBreezyAutotest()
# Prepare some date properties for the tests to use.
self.now = datetime.now(pytz.UTC)
self.under_threshold_date = self.now - timedelta(days=29)
self.over_threshold_date = self.now - timedelta(days=31)
def test_can_run_twice(self):
test_publisher = SoyuzTestPublisher()
distroseries = test_publisher.setUpDefaultDistroSeries()
distro = distroseries.distribution
self.factory.makeComponentSelection(
distroseries=distroseries, component="main")
self.factory.makeArchive(
distribution=distro, purpose=ArchivePurpose.PARTNER)
test_publisher.getPubSource()
self.setUpForScriptRun(distro)
self.makeScript(distro).main()
self.makeScript(distro).main()
def test_can_run_twice(self):
test_publisher = SoyuzTestPublisher()
distroseries = test_publisher.setUpDefaultDistroSeries()
distro = distroseries.distribution
self.factory.makeComponentSelection(distroseries=distroseries,
component="main")
self.factory.makeArchive(distribution=distro,
purpose=ArchivePurpose.PARTNER)
test_publisher.getPubSource()
self.setUpForScriptRun(distro)
self.makeScript(distro).main()
self.makeScript(distro).main()
def test_publishes_package(self):
test_publisher = SoyuzTestPublisher()
distroseries = test_publisher.setUpDefaultDistroSeries()
distro = distroseries.distribution
pub_config = get_pub_config(distro)
self.factory.makeComponentSelection(distroseries=distroseries,
component="main")
self.factory.makeArchive(distribution=distro,
purpose=ArchivePurpose.PARTNER)
test_publisher.getPubSource()
self.setUpForScriptRun(distro)
self.makeScript(distro).main()
archive_root = get_archive_root(pub_config)
dists_root = get_dists_root(pub_config)
dsc = os.path.join(archive_root, 'pool', 'main', 'f', 'foo',
'foo_666.dsc')
self.assertEqual("I do not care about sources.", file(dsc).read())
overrides = os.path.join(archive_root + '-overrides',
distroseries.name + '_main_source')
self.assertEqual(dsc, file(overrides).read().rstrip())
self.assertTrue(
path_exists(dists_root, distroseries.name, 'main', 'source',
'Sources.gz'))
self.assertTrue(
path_exists(dists_root, distroseries.name, 'main', 'source',
'Sources.bz2'))
distcopyseries = os.path.join(dists_root, distroseries.name)
release = self.readReleaseFile(os.path.join(distcopyseries, "Release"))
self.assertEqual(distro.displayname, release['Origin'])
self.assertEqual(distro.displayname, release['Label'])
self.assertEqual(distroseries.name, release['Suite'])
self.assertEqual(distroseries.name, release['Codename'])
self.assertEqual("main", release['Components'])
self.assertEqual("", release["Architectures"])
self.assertIn("Date", release)
self.assertIn("Description", release)
self.assertNotEqual("", release["MD5Sum"])
self.assertNotEqual("", release["SHA1"])
self.assertNotEqual("", release["SHA256"])
main_release = self.readReleaseFile(
os.path.join(distcopyseries, 'main', 'source', "Release"))
self.assertEqual(distroseries.name, main_release["Archive"])
self.assertEqual("main", main_release["Component"])
self.assertEqual(distro.displayname, main_release["Origin"])
self.assertEqual(distro.displayname, main_release["Label"])
self.assertEqual("source", main_release["Architecture"])
def setUp(self):
"""Create a distroseriesbinarypackage to play with."""
super(TestDistroSeriesBinaryPackage, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries = self.publisher.distroseries
self.distribution = self.distroseries.distribution
binaries = self.publisher.getPubBinaries(binaryname='foo-bin',
summary='Foo is the best')
binary_pub = binaries[0]
self.binary_package_name = (
binary_pub.binarypackagerelease.binarypackagename)
self.distroseries_binary_package = DistroSeriesBinaryPackage(
self.distroseries, self.binary_package_name)
def test_publishes_package(self):
test_publisher = SoyuzTestPublisher()
distroseries = test_publisher.setUpDefaultDistroSeries()
distro = distroseries.distribution
pub_config = get_pub_config(distro)
self.factory.makeComponentSelection(
distroseries=distroseries, component="main")
self.factory.makeArchive(
distribution=distro, purpose=ArchivePurpose.PARTNER)
test_publisher.getPubSource()
self.setUpForScriptRun(distro)
self.makeScript(distro).main()
archive_root = get_archive_root(pub_config)
dists_root = get_dists_root(pub_config)
dsc = os.path.join(
archive_root, 'pool', 'main', 'f', 'foo', 'foo_666.dsc')
self.assertEqual("I do not care about sources.", file(dsc).read())
overrides = os.path.join(
archive_root + '-overrides', distroseries.name + '_main_source')
self.assertEqual(dsc, file(overrides).read().rstrip())
self.assertTrue(path_exists(
dists_root, distroseries.name, 'main', 'source', 'Sources.gz'))
self.assertTrue(path_exists(
dists_root, distroseries.name, 'main', 'source', 'Sources.bz2'))
distcopyseries = os.path.join(dists_root, distroseries.name)
release = self.readReleaseFile(
os.path.join(distcopyseries, "Release"))
self.assertEqual(distro.displayname, release['Origin'])
self.assertEqual(distro.displayname, release['Label'])
self.assertEqual(distroseries.name, release['Suite'])
self.assertEqual(distroseries.name, release['Codename'])
self.assertEqual("main", release['Components'])
self.assertEqual("", release["Architectures"])
self.assertIn("Date", release)
self.assertIn("Description", release)
self.assertNotEqual("", release["MD5Sum"])
self.assertNotEqual("", release["SHA1"])
self.assertNotEqual("", release["SHA256"])
main_release = self.readReleaseFile(
os.path.join(distcopyseries, 'main', 'source', "Release"))
self.assertEqual(distroseries.name, main_release["Archive"])
self.assertEqual("main", main_release["Component"])
self.assertEqual(distro.displayname, main_release["Origin"])
self.assertEqual(distro.displayname, main_release["Label"])
self.assertEqual("source", main_release["Architecture"])
def setUp(self):
super(TestBuildPrivacy, self).setUp()
# Add everything we need to create builds.
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
processor = self.factory.makeProcessor(supports_virtualized=True)
distroseries = self.factory.makeDistroSeries()
das = self.factory.makeDistroArchSeries(
distroseries=distroseries, processor=processor)
with person_logged_in(self.admin):
publisher = SoyuzTestPublisher()
publisher.prepareBreezyAutotest()
distroseries.nominatedarchindep = das
publisher.addFakeChroots(distroseries=distroseries)
self.factory.makeBuilder(processors=[processor])
self.public_archive = self.factory.makeArchive()
self.private_archive = self.factory.makeArchive(private=True)
# Create one public and one private build.
public_spph = publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
version="%s.1" % self.factory.getUniqueInteger(),
distroseries=distroseries, archive=self.public_archive)
[public_build] = public_spph.createMissingBuilds()
private_spph = publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
version="%s.1" % self.factory.getUniqueInteger(),
distroseries=distroseries, archive=self.private_archive)
with person_logged_in(self.admin):
[private_build] = private_spph.createMissingBuilds()
self.expected_title = '%s build of %s %s in %s %s RELEASE' % (
das.architecturetag, private_spph.source_package_name,
private_spph.source_package_version,
distroseries.distribution.name, distroseries.name)
def setUp(self):
super(TestBuild, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
self.processor = self.factory.makeProcessor(supports_virtualized=True)
self.distroseries = self.factory.makeDistroSeries()
self.das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder = self.factory.makeBuilder(
processors=[self.processor])
self.now = datetime.now(pytz.UTC)
def setUp(self):
"""Create the Soyuz test publisher."""
TestCaseWithFactory.setUp(self)
self.stp = SoyuzTestPublisher()
self.stp.prepareBreezyAutotest()
self.test_package_name = u"accept-test"
self.distro = self.factory.makeDistribution()
def setUp(self):
super(TestBuildNotify, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create all of the items we need to create builds
self.processor = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor,
supports_virtualized=True)
self.creator = self.factory.makePerson(email='*****@*****.**')
self.gpgkey = self.factory.makeGPGKey(owner=self.creator)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
self.ppa = self.factory.makeArchive()
buildd_admins = getUtility(IPersonSet).getByName(
'launchpad-buildd-admins')
self.buildd_admins_email = []
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder = self.factory.makeBuilder(processor=self.processor)
for member in buildd_admins.activemembers:
self.buildd_admins_email.append(member.preferredemail.email)
self.builds = []
def setUp(self):
super(TestDistributionHasBuildRecords, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create the machinery we need to create builds, such as
# DistroArchSeries and builders.
self.processor_one = self.factory.makeProcessor()
self.processor_two = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.distribution = self.distroseries.distribution
self.das_one = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_one,
supports_virtualized=True)
self.das_two = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_two,
supports_virtualized=True)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
self.arch_ids = [arch.id for arch in self.distroseries.architectures]
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das_one
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder_one = self.factory.makeBuilder(
processor=self.processor_one)
self.builder_two = self.factory.makeBuilder(
processor=self.processor_two)
self.builds = []
self.createBuilds()
def setUp(self):
super(TestBuildSet, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
self.processor_one = self.factory.makeProcessor()
self.processor_two = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.distribution = self.distroseries.distribution
self.das_one = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_one,
supports_virtualized=True)
self.das_two = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor_two,
supports_virtualized=True)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution,
purpose=ArchivePurpose.PRIMARY)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das_one
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder_one = self.factory.makeBuilder(
processor=self.processor_one)
self.builder_two = self.factory.makeBuilder(
processor=self.processor_two)
self.builds = []
self.spphs = []
def setUp(self):
super(TestBuildStartEstimation, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
for buildd in getUtility(IBuilderSet):
buildd.builderok = True
self.distroseries = self.factory.makeDistroSeries()
self.bob = getUtility(IBuilderSet).getByName(BOB_THE_BUILDER_NAME)
das = self.factory.makeDistroArchSeries(distroseries=self.distroseries,
processor=self.bob.processor,
architecturetag='i386')
with person_logged_in(self.admin):
self.distroseries.nominatedarchindep = das
self.publisher.addFakeChroots(distroseries=self.distroseries)
def setUp(self):
super(TestDistroSourcePackageReleaseFiles, self).setUp()
# The package must be published for the page to render.
stp = SoyuzTestPublisher()
distroseries = stp.setUpDefaultDistroSeries()
naked_distroseries = remove_security_proxy_and_shout_at_engineer(
distroseries)
# XXX Abel Deuring, 2010-07-21, bug 608240. This is scary. But
# if we use distroseries.distribution instead,
# test_spr_files_deleted() and test_spr_files_one() fail.
distro = naked_distroseries.distribution
source_package_release = stp.getPubSource().sourcepackagerelease
self.dspr = DistributionSourcePackageRelease(distro,
source_package_release)
self.library_file = self.factory.makeLibraryFileAlias(
filename='test_file.dsc', content='0123456789')
source_package_release.addFile(self.library_file)
def test_script_creates_indexes(self):
# End-to-end test: the script creates indexes for distroseries
# that need them.
test_publisher = SoyuzTestPublisher()
series = test_publisher.setUpDefaultDistroSeries()
series.status = SeriesStatus.FROZEN
self.factory.makeComponentSelection(distroseries=series,
component="main")
self.layer.txn.commit()
self.setUpForScriptRun(series.distribution)
script = self.makeScript(series.distribution)
script.main()
self.assertEqual([], script.listSuitesNeedingIndexes(series))
sources = os.path.join(
getPubConfig(series.main_archive).distsroot, series.name, "main",
"source", "Sources")
self.assertTrue(file_exists(sources))
def setUp(self):
super(TestDistroSourcePackageReleaseFiles, self).setUp()
# The package must be published for the page to render.
stp = SoyuzTestPublisher()
distroseries = stp.setUpDefaultDistroSeries()
naked_distroseries = remove_security_proxy_and_shout_at_engineer(
distroseries)
# XXX Abel Deuring, 2010-07-21, bug 608240. This is scary. But
# if we use distroseries.distribution instead,
# test_spr_files_deleted() and test_spr_files_one() fail.
distro = naked_distroseries.distribution
source_package_release = stp.getPubSource().sourcepackagerelease
self.dspr = DistributionSourcePackageRelease(
distro, source_package_release)
self.library_file = self.factory.makeLibraryFileAlias(
filename='test_file.dsc', content='0123456789')
source_package_release.addFile(self.library_file)
def test_script_creates_indexes(self):
# End-to-end test: the script creates indexes for distroseries
# that need them.
test_publisher = SoyuzTestPublisher()
series = test_publisher.setUpDefaultDistroSeries()
series.status = SeriesStatus.FROZEN
self.factory.makeComponentSelection(
distroseries=series, component="main")
self.layer.txn.commit()
self.setUpForScriptRun(series.distribution)
script = self.makeScript(series.distribution)
script.main()
self.assertEqual([], script.listSuitesNeedingIndexes(series))
sources = os.path.join(
getPubConfig(series.main_archive).distsroot,
series.name, "main", "source", "Sources")
self.assertTrue(file_exists(sources))
def setUp(self):
"""Publish some gedit sources in main and PPAs."""
super(TestDistributionSourcePackageFindRelatedArchives, self).setUp()
self.distribution = getUtility(IDistributionSet)['ubuntutest']
# Create two PPAs for gedit.
self.archives = {}
self.archives['ubuntu-main'] = self.distribution.main_archive
self.archives['gedit-nightly'] = self.factory.makeArchive(
name="gedit-nightly", distribution=self.distribution)
self.archives['gedit-beta'] = self.factory.makeArchive(
name="gedit-beta", distribution=self.distribution)
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
# Publish gedit in all three archives.
self.person_nightly = self.factory.makePerson()
self.gedit_nightly_src_hist = self.publisher.getPubSource(
sourcename="gedit",
archive=self.archives['gedit-nightly'],
creator=self.person_nightly,
status=PackagePublishingStatus.PUBLISHED)
self.person_beta = self.factory.makePerson()
self.gedit_beta_src_hist = self.publisher.getPubSource(
sourcename="gedit",
archive=self.archives['gedit-beta'],
creator=self.person_beta,
status=PackagePublishingStatus.PUBLISHED)
self.gedit_main_src_hist = self.publisher.getPubSource(
sourcename="gedit",
archive=self.archives['ubuntu-main'],
status=PackagePublishingStatus.PUBLISHED)
# Save the gedit source package for easy access.
self.source_package = self.distribution.getSourcePackage('gedit')
# Add slightly more soyuz karma for person_nightly for this package.
switch_dbuser('karma')
self.person_beta_karma = KarmaTotalCache(person=self.person_beta,
karma_total=200)
self.person_nightly_karma = KarmaTotalCache(person=self.person_nightly,
karma_total=201)
switch_dbuser('launchpad')
def setUp(self):
super(TestBuildPrivacy, self).setUp()
# Add everything we need to create builds.
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
processor = self.factory.makeProcessor()
distroseries = self.factory.makeDistroSeries()
das = self.factory.makeDistroArchSeries(
distroseries=distroseries, processor=processor,
supports_virtualized=True)
with person_logged_in(self.admin):
publisher = SoyuzTestPublisher()
publisher.prepareBreezyAutotest()
distroseries.nominatedarchindep = das
publisher.addFakeChroots(distroseries=distroseries)
self.factory.makeBuilder(processor=processor)
self.public_archive = self.factory.makeArchive()
self.private_archive = self.factory.makeArchive(private=True)
# Create one public and one private build.
public_spph = publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
version="%s.1" % self.factory.getUniqueInteger(),
distroseries=distroseries, archive=self.public_archive)
[public_build] = public_spph.createMissingBuilds()
private_spph = publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
version="%s.1" % self.factory.getUniqueInteger(),
distroseries=distroseries, archive=self.private_archive)
with person_logged_in(self.admin):
[private_build] = private_spph.createMissingBuilds()
self.expected_title = '%s build of %s %s in %s %s RELEASE' % (
das.architecturetag, private_spph.source_package_name,
private_spph.source_package_version,
distroseries.distribution.name, distroseries.name)
class TestBuildStartEstimation(TestCaseWithFactory):
layer = LaunchpadFunctionalLayer
def setUp(self):
super(TestBuildStartEstimation, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
for buildd in getUtility(IBuilderSet):
buildd.builderok = True
self.distroseries = self.factory.makeDistroSeries()
self.bob = getUtility(IBuilderSet).getByName(BOB_THE_BUILDER_NAME)
das = self.factory.makeDistroArchSeries(distroseries=self.distroseries,
processor=self.bob.processor,
architecturetag='i386')
with person_logged_in(self.admin):
self.distroseries.nominatedarchindep = das
self.publisher.addFakeChroots(distroseries=self.distroseries)
def job_start_estimate(self, build):
return build.buildqueue_record.getEstimatedJobStartTime()
def test_estimation(self):
pkg = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
distroseries=self.distroseries)
build = pkg.createMissingBuilds()[0]
now = datetime.now(pytz.UTC)
estimate = self.job_start_estimate(build)
self.assertTrue(estimate > now)
def test_disabled_archives(self):
pkg1 = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
distroseries=self.distroseries)
[build1] = pkg1.createMissingBuilds()
build1.buildqueue_record.lastscore = 1000
# No user-serviceable parts inside
removeSecurityProxy(
build1.buildqueue_record).estimated_duration = (timedelta(
minutes=10))
pkg2 = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
distroseries=self.distroseries)
[build2] = pkg2.createMissingBuilds()
build2.buildqueue_record.lastscore = 100
now = datetime.now(pytz.UTC)
# Since build1 is higher priority, it's estimated dispatch time is now
estimate = self.job_start_estimate(build1)
self.assertEqual(5, (estimate - now).seconds)
# And build2 is next, so must take build1's duration into account
estimate = self.job_start_estimate(build2)
self.assertEqual(600, (estimate - now).seconds)
# If we disable build1's archive, build2 is next
with person_logged_in(self.admin):
build1.archive.disable()
estimate = self.job_start_estimate(build2)
self.assertEqual(5, (estimate - now).seconds)
class TestBuildStartEstimation(TestCaseWithFactory):
layer = LaunchpadFunctionalLayer
def setUp(self):
super(TestBuildStartEstimation, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
for buildd in getUtility(IBuilderSet):
buildd.builderok = True
self.distroseries = self.factory.makeDistroSeries()
self.bob = getUtility(IBuilderSet).getByName(BOB_THE_BUILDER_NAME)
das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.bob.processor,
architecturetag='i386', supports_virtualized=True)
with person_logged_in(self.admin):
self.distroseries.nominatedarchindep = das
self.publisher.addFakeChroots(distroseries=self.distroseries)
def job_start_estimate(self, build):
return build.buildqueue_record.getEstimatedJobStartTime()
def test_estimation(self):
pkg = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
distroseries=self.distroseries)
build = pkg.createMissingBuilds()[0]
now = datetime.now(pytz.UTC)
estimate = self.job_start_estimate(build)
self.assertTrue(estimate > now)
def test_disabled_archives(self):
pkg1 = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
distroseries=self.distroseries)
[build1] = pkg1.createMissingBuilds()
build1.buildqueue_record.lastscore = 1000
# No user-serviceable parts inside
removeSecurityProxy(build1.buildqueue_record).estimated_duration = (
timedelta(minutes=10))
pkg2 = self.publisher.getPubSource(
sourcename=self.factory.getUniqueString(),
distroseries=self.distroseries)
[build2] = pkg2.createMissingBuilds()
build2.buildqueue_record.lastscore = 100
now = datetime.now(pytz.UTC)
# Since build1 is higher priority, it's estimated dispatch time is now
estimate = self.job_start_estimate(build1)
self.assertEquals(5, (estimate - now).seconds)
# And build2 is next, so must take build1's duration into account
estimate = self.job_start_estimate(build2)
self.assertEquals(600, (estimate - now).seconds)
# If we disable build1's archive, build2 is next
with person_logged_in(self.admin):
build1.archive.disable()
estimate = self.job_start_estimate(build2)
self.assertEquals(5, (estimate - now).seconds)
def setUp(self):
super(TestSourcePublicationListingExtra, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create everything we need to create builds, such as a
# DistroArchSeries and a builder.
self.processor = self.factory.makeProcessor(supports_virtualized=True)
self.distroseries = self.factory.makeDistroSeries(
distribution=getUtility(IDistributionSet)['ubuntu'])
self.das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder = self.factory.makeBuilder(
processors=[self.processor])
class TestPlatformData(TestCaseWithFactory):
"""Tests covering the processor/virtualized properties."""
layer = LaunchpadZopelessLayer
def setUp(self):
"""Set up a native x86 build for the test archive."""
super(TestPlatformData, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
# First mark all builds in the sample data as already built.
sample_data = IStore(BinaryPackageBuild).find(BinaryPackageBuild)
for build in sample_data:
build.buildstate = BuildStatus.FULLYBUILT
IStore(BinaryPackageBuild).flush()
# We test builds that target a primary archive.
self.non_ppa = self.factory.makeArchive(
name="primary", purpose=ArchivePurpose.PRIMARY)
self.non_ppa.require_virtualized = False
self.builds = []
self.builds.extend(
self.publisher.getPubSource(
sourcename="gedit", status=PackagePublishingStatus.PUBLISHED,
archive=self.non_ppa).createMissingBuilds())
def test_JobPlatformSettings(self):
"""The `BuildQueue` instance shares the processor/virtualized
properties with the associated `Build`."""
build, bq = find_job(self, 'gedit')
# Make sure the 'processor' properties are the same.
self.assertEqual(
bq.processor, build.processor,
"The 'processor' property deviates.")
# Make sure the 'virtualized' properties are the same.
self.assertEqual(
bq.virtualized, build.virtualized,
"The 'virtualized' property deviates.")
def updatePackageCache(self):
# Create package cache records for new binary packages.
#
# SoyuzTestPublisher.updatePackageCache() creates a
# DistroSeriesPackageCache record for the new binary package.
# The method closes the current DB connection, making references
# to DB objects in other DB objects unusable. Starting with
# the distroarchseries, we can create new, valid, instances of
# objects required later in the test again.
# of the objects we need later.
sourcepackagename = self.sourcepackagerelease.sourcepackagename
publisher = SoyuzTestPublisher()
publisher.updatePackageCache(self.distroarchseries.distroseries)
self.distroarchseries = DistroArchSeries.get(self.distroarchseries.id)
distribution = self.distroarchseries.distroseries.distribution
releases = distribution.getCurrentSourceReleases([sourcepackagename])
[(distribution_sourcepackage, dsp_release)] = releases.items()
self.dsp_release = dsp_release
self.sourcepackagerelease = dsp_release.sourcepackagerelease
def setUp(self):
super(TestScriptRunning, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.store = IStore(BinaryPackageReleaseDownloadCount)
self.archive = getUtility(IPersonSet).getByName('cprov').archive
self.archive.require_virtualized = False
self.foo_i386, self.foo_hppa = self.publisher.getPubBinaries(
archive=self.archive, architecturespecific=True)
self.bar_i386, self.bar_hppa = self.publisher.getPubBinaries(
binaryname='bar-bin',
archive=self.archive,
architecturespecific=False)
# Commit so the script can see our changes.
import transaction
transaction.commit()
def setUp(self):
# Log in as an admin, so that we can create distributions.
super(CurrentSourceReleasesMixin, self).setUp()
login('*****@*****.**')
self.publisher = SoyuzTestPublisher()
self.factory = self.publisher.factory
self.development_series = self.publisher.setUpDefaultDistroSeries()
self.distribution = self.development_series.distribution
self.published_package = self.target.getSourcePackage(
self.publisher.default_package_name)
login(ANONYMOUS)
def updateDistroSeriesPackageCache(self):
# Create DistroSeriesPackageCache records for new binary
# packages.
#
# SoyuzTestPublisher.updateDistroSeriesPackageCache() creates
# a DistroSeriesPackageCache record for the new binary package.
# The method closes the current DB connection, making references
# to DB objects in other DB objects unusable. Starting with
# the distroarchseries, we can create new, valid, instances of
# objects required later in the test again.
# of the objects we need later.
sourcepackagename = self.sourcepackagerelease.sourcepackagename
publisher = SoyuzTestPublisher()
publisher.updateDistroSeriesPackageCache(
self.distroarchseries.distroseries)
self.distroarchseries = DistroArchSeries.get(self.distroarchseries.id)
distribution = self.distroarchseries.distroseries.distribution
releases = distribution.getCurrentSourceReleases([sourcepackagename])
[(distribution_sourcepackage, dsp_release)] = releases.items()
self.dsp_release = dsp_release
self.sourcepackagerelease = dsp_release.sourcepackagerelease
def setUp(self):
"""Create a distroseriesbinarypackage to play with."""
super(TestDistroSeriesBinaryPackage, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries = self.publisher.distroseries
self.distribution = self.distroseries.distribution
binaries = self.publisher.getPubBinaries(
binaryname='foo-bin', summary='Foo is the best')
binary_pub = binaries[0]
self.binary_package_name = (
binary_pub.binarypackagerelease.binarypackagename)
self.distroseries_binary_package = DistroSeriesBinaryPackage(
self.distroseries, self.binary_package_name)
def setUp(self):
super(TestBuild, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
self.processor = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor,
supports_virtualized=True)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder = self.factory.makeBuilder(processor=self.processor)
self.now = datetime.now(pytz.UTC)
def setUp(self):
super(TestBuildStartEstimation, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
for buildd in getUtility(IBuilderSet):
buildd.builderok = True
self.distroseries = self.factory.makeDistroSeries()
self.bob = getUtility(IBuilderSet).getByName(BOB_THE_BUILDER_NAME)
das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.bob.processor,
architecturetag='i386', supports_virtualized=True)
with person_logged_in(self.admin):
self.distroseries.nominatedarchindep = das
self.publisher.addFakeChroots(distroseries=self.distroseries)
def _prepareMergeCopy(self):
"""Add a fresher and a new package to ubuntu/hoary.
This is used to test merge copy functionality."""
test_publisher = SoyuzTestPublisher()
ubuntu = getUtility(IDistributionSet).getByName('ubuntu')
hoary = ubuntu.getSeries('hoary')
test_publisher.addFakeChroots(hoary)
test_publisher.setUpDefaultDistroSeries(hoary)
test_publisher.getPubSource(
sourcename="new-in-second-round", version="1.0",
distroseries=hoary, archive=ubuntu.main_archive)
test_publisher.getPubSource(
sourcename="alsa-utils", version="2.0", distroseries=hoary,
archive=ubuntu.main_archive)
sources = ubuntu.main_archive.getPublishedSources(
distroseries=hoary, status=self.pending_statuses,
name=u'alsa-utils')
for src in sources:
if src.source_package_version != '2.0':
src.supersede()
LaunchpadZopelessLayer.txn.commit()
def test_switch_privacy_with_pubs_fails(self):
# Changing the privacy is not possible when the archive already
# has published sources.
public_ppa = self.factory.makeArchive(private=False)
publisher = SoyuzTestPublisher()
publisher.prepareBreezyAutotest()
private_ppa = self.factory.makeArchive(private=True)
publisher.getPubSource(archive=public_ppa)
publisher.getPubSource(archive=private_ppa)
self.assertRaises(
CannotSwitchPrivacy, setattr, public_ppa, 'private', True)
self.assertRaises(
CannotSwitchPrivacy, setattr, private_ppa, 'private', False)
def setUp(self):
super(TestSourcePublicationListingExtra, self).setUp()
self.admin = getUtility(IPersonSet).getByEmail(ADMIN_EMAIL)
# Create everything we need to create builds, such as a
# DistroArchSeries and a builder.
self.processor = self.factory.makeProcessor()
self.distroseries = self.factory.makeDistroSeries()
self.das = self.factory.makeDistroArchSeries(
distroseries=self.distroseries, processor=self.processor,
supports_virtualized=True)
self.archive = self.factory.makeArchive(
distribution=self.distroseries.distribution)
with person_logged_in(self.admin):
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.distroseries.nominatedarchindep = self.das
self.publisher.addFakeChroots(distroseries=self.distroseries)
self.builder = self.factory.makeBuilder(processor=self.processor)
def setUp(self):
super(TestScriptRunning, self).setUp()
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
self.store = IStore(BinaryPackageReleaseDownloadCount)
self.archive = getUtility(IPersonSet).getByName('cprov').archive
self.archive.require_virtualized = False
self.foo_i386, self.foo_hppa = self.publisher.getPubBinaries(
archive=self.archive, architecturespecific=True)
self.bar_i386, self.bar_hppa = self.publisher.getPubBinaries(
binaryname='bar-bin', archive=self.archive,
architecturespecific=False)
# Commit so the script can see our changes.
import transaction
transaction.commit()
def setUp(self):
"""Publish some gedit sources in main and PPAs."""
super(TestDistributionSourcePackageFindRelatedArchives, self).setUp()
self.distribution = getUtility(IDistributionSet)['ubuntutest']
# Create two PPAs for gedit.
self.archives = {}
self.archives['ubuntu-main'] = self.distribution.main_archive
self.archives['gedit-nightly'] = self.factory.makeArchive(
name="gedit-nightly", distribution=self.distribution)
self.archives['gedit-beta'] = self.factory.makeArchive(
name="gedit-beta", distribution=self.distribution)
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
# Publish gedit in all three archives.
self.person_nightly = self.factory.makePerson()
self.gedit_nightly_src_hist = self.publisher.getPubSource(
sourcename="gedit", archive=self.archives['gedit-nightly'],
creator=self.person_nightly,
status=PackagePublishingStatus.PUBLISHED)
self.person_beta = self.factory.makePerson()
self.gedit_beta_src_hist = self.publisher.getPubSource(
sourcename="gedit", archive=self.archives['gedit-beta'],
creator=self.person_beta,
status=PackagePublishingStatus.PUBLISHED)
self.gedit_main_src_hist = self.publisher.getPubSource(
sourcename="gedit", archive=self.archives['ubuntu-main'],
status=PackagePublishingStatus.PUBLISHED)
# Save the gedit source package for easy access.
self.source_package = self.distribution.getSourcePackage('gedit')
# Add slightly more soyuz karma for person_nightly for this package.
switch_dbuser('karma')
self.person_beta_karma = KarmaTotalCache(
person=self.person_beta, karma_total=200)
self.person_nightly_karma = KarmaTotalCache(
person=self.person_nightly, karma_total=201)
switch_dbuser('launchpad')
def _setupSimpleDepwaitContext(self):
"""Use `SoyuzTestPublisher` to setup a simple depwait context.
Return an `IBinaryPackageBuild` in MANUALDEWAIT state and depending
on a binary that exists and is reachable.
"""
self.publisher = SoyuzTestPublisher()
self.publisher.prepareBreezyAutotest()
depwait_source = self.publisher.getPubSource(
sourcename='depwait-source')
self.publisher.getPubBinaries(
binaryname='dep-bin', status=PackagePublishingStatus.PUBLISHED)
[depwait_build] = depwait_source.createMissingBuilds()
depwait_build.updateStatus(
BuildStatus.MANUALDEPWAIT,
slave_status={'dependencies': u'dep-bin'})
return depwait_build