def test_mark_uploaded_unkown_dist(self):
self.make_unuploaded()
cl = Changelog()
v = Version("0.1-1")
cl.new_block(
package='package',
version=Version('0.1-1'),
distributions='UNRELEASED',
urgency='low',
author='James Westby <*****@*****.**>',
date='Thu, 3 Aug 2006 19:16:22 +0100',
)
cl.add_change('')
cl.add_change(' * Initial packaging.')
cl.add_change('')
f = open('debian/changelog', 'wb')
try:
cl.write_to_open_file(f)
finally:
f.close()
self.wt.commit("two")
self.run_bzr_error([
"The changelog still targets 'UNRELEASED', so "
"apparently hasn't been uploaded."
], "mark-uploaded")
def test_find_previous_upload_ubuntu(self):
cl = self.make_changelog([("0.1-1", "lucid"), ("0.1-2", "lucid")])
self.assertEqual(Version("0.1-1"), changelog_find_previous_upload(cl))
cl = self.make_changelog([("0.1-1", "lucid"), ("0.1-1.1", "unstable"),
("0.1-2", "maverick")])
self.requireFeature(DistroInfoFeature)
self.assertEqual(Version("0.1-1"), changelog_find_previous_upload(cl))
def test_find_previous_upload_debian(self):
cl = self.make_changelog([("0.1-1", "unstable"),
("0.1-2", "unstable")])
self.assertEqual(Version("0.1-1"), _find_previous_upload(cl))
cl = self.make_changelog([("0.1-1", "unstable"),
("0.1-1.1", "stable-security"), ("0.1-2", "unstable")])
self.assertEqual(Version("0.1-1"), _find_previous_upload(cl))
def drop_obsolete_maintscript_entries(
editor, should_remove: Callable[[str, Version], bool]
) -> List[Tuple[int, str, Version]]:
"""Drop obsolete entries from a maintscript file.
Args:
editor: editor to use to access the maintscript
should_remove: callable to check whether a package/version tuple is obsolete
Returns:
list of tuples with index, package, version of entries that were removed
"""
remove: List[Tuple[int, str, Version]] = []
comments = []
entries_removed = []
for i, entry in enumerate(list(editor.lines)):
if isinstance(entry, str):
comments.append((i, None, None))
continue
prior_version = getattr(entry, "prior_version", None)
if prior_version is not None:
if should_remove(entry.package, Version(prior_version)):
remove.extend(comments)
remove.append((i, entry.package, Version(prior_version)))
entries_removed.append(i)
comments = []
removed = []
for i, pkg, version in reversed(remove):
removed.append(editor.lines[i])
del editor.lines[i]
return entries_removed
def test__upstream_version_data(self):
ubup_o, debp_n, _ubuu, _debu = self._setup_debian_upstream_newer()
vdata = MP._upstream_version_data(debp_n.branch,
debp_n.last_revision())
self.assertEquals(vdata[0], Version('1.10'))
vdata = MP._upstream_version_data(ubup_o.branch,
ubup_o.last_revision())
self.assertEquals(vdata[0], Version('1.2'))
def test_tarball_name(self):
self.assertEqual(tarball_name("package", "0.1", None),
"package_0.1.orig.tar.gz")
self.assertEqual(tarball_name("package", Version("0.1"), None),
"package_0.1.orig.tar.gz")
self.assertEqual(tarball_name("package", Version("0.1"), None,
format='bz2'), "package_0.1.orig.tar.bz2")
self.assertEqual(tarball_name("package", Version("0.1"), None,
format='xz'), "package_0.1.orig.tar.xz")
self.assertEqual(tarball_name("package", Version("0.1"), "la",
format='xz'), "package_0.1.orig-la.tar.xz")
def fetch_tarballs(self, package, version, target_dir, components=None):
v = Version(version)
v.epoch = None
prefix = '%s_%s.orig' % (package, v)
ret = []
for entry in os.scandir(self.path):
if entry.name.startswith(prefix):
component = (entry.name[len(prefix):].split('.')[0] or None)
shutil.copy(entry.path, target_dir)
if components is None or component in components:
ret.append(os.path.join(target_dir, entry.name))
if ret:
return ret
raise PackageVersionNotPresent(package, version, self)
def test_import_upstream_with_branch_prior_tarball(self):
self.make_upstream_tarball()
upstreamtree = self.make_upstream_tree()
tree = self.make_workingdir()
# XXX: refactor: make this an API call - running blackbox in test prep
# is ugly.
self.run_bzr([
'import-upstream', self.upstream_version,
"../%s" % self.upstream_tarball_name, '../upstream'
],
working_dir='working')
new_version = Version('0.2-1')
self.make_upstream_tarball(new_version.upstream_version)
upstream_parent = self.make_upstream_change(upstreamtree)
self.run_bzr([
'import-upstream', new_version.upstream_version,
"../%s" % self._upstream_tarball_name(
self.package_name, new_version.upstream_version), '../upstream'
],
working_dir='working')
tree.lock_read()
self.addCleanup(tree.unlock)
self.assertFalse(tree.has_changes())
revtree = self.assertHasImportArtifacts(tree,
new_version.upstream_version)
self.assertUpstreamContentAndFileIdFromTree(revtree, upstreamtree)
# Check parents: we want
# [previous_import, upstream_parent] to reflect that the 'branch' is
# the tarball branch aka upstream branch [ugh], and then a merge in
# from upstream so that cherrypicks do the right thing.
tags = tree.branch.tags
self.assertEqual([
tags.lookup_tag(self.upstream_tag(self.upstream_version)),
upstreamtree.branch.last_revision()
], revtree.get_parent_ids())
def changelog(dpath, ctx, env):
change = ctx.get('message', 'Autogenerated by py2dsp v{}'.format(VERSION))
version = ctx['debian_version']
distribution = ctx.get('distribution', 'UNRELEASED')
fpath = join(dpath, 'debian', 'changelog')
if exists(fpath):
with open(fpath, encoding='utf-8') as fp:
line = fp.readline()
if ctx['version'] in line or 'UNRELEASED' in line:
log.debug('changelog doesn\'t need an update')
return
else:
yield from execute([
'dch', '--force-distribution', '--distribution',
distribution, '--newversion', version, '-m', change
],
cwd=dpath)
return
now = datetime.utcnow()
changelog = Changelog()
changelog.new_block(package=ctx['src_name'],
version=Version(version),
distributions=distribution,
urgency='low',
author=ctx['creator'],
date=now.strftime('%a, %d %b %Y %H:%M:%S +0000'))
changelog.add_change('')
changelog.add_change(' * {}'.format(change))
changelog.add_change('')
with open(fpath, 'w', encoding='utf-8') as fp:
changelog.write_to_open_file(fp)
return True
def get_recent_versions(self,
package: str,
since_version: Optional[Version] = None):
versions = []
tags = self.upstream_branch.tags.get_tag_dict()
with self.upstream_branch.repository.lock_read():
graph = self.upstream_branch.repository.get_graph()
if since_version is not None:
try:
since_revision = self.version_as_revision(
package, since_version)
except PackageVersionNotPresent:
raise PreviousVersionTagMissing(package, since_version)
else:
since_revision = None
for tag, revision in tags.items():
version = upstream_tag_to_version(tag, package)
if version is None:
continue
mangled_version = debianize_upstream_version(version, package)
self.upstream_revision_map[mangled_version] = 'tag:%s' % tag
if since_version is not None and mangled_version <= since_version:
continue
if since_revision and not graph.is_ancestor(
since_revision, revision):
continue
versions.append((version, mangled_version))
return sorted(versions, key=lambda v: Version(v[1]))
def test_dget_missing_target(self):
builder = SourcePackageBuilder("package", Version("0.1-1"))
builder.add_upstream_file("foo")
builder.add_default_control()
builder.build()
self.assertRaises(bzr_errors.NotADirectory, dget,
self.get_url(builder.dsc_name()), 'target')
def get_newest_option(opts):
latest_version = None
latest_option = None
for version, option in opts.items():
# If option is not complete, skip
if 'kernel' not in option or 'initrd' not in option:
continue
# If this option is newer, store this option and continue
if latest_version is None or Version(version) > Version(
latest_version):
latest_version = version
latest_option = option
return latest_option, latest_version
def package_version(upstream_version, distribution_name, epoch=None):
"""Determine the package version for a new upstream.
:param upstream_version: Upstream version string
:param distribution_name: Distribution the package is for
:param epoch: Optional epoch
"""
assert isinstance(upstream_version, str), \
"upstream_version should be a str, not %s" % str(
type(upstream_version))
if distribution_name == "ubuntu":
ret = Version("%s-0ubuntu1" % upstream_version)
else:
ret = Version("%s-1" % upstream_version)
ret.epoch = epoch
return ret
def test_dget_missing_dsc(self):
builder = SourcePackageBuilder("package", Version("0.1-1"))
builder.add_upstream_file("foo")
builder.add_default_control()
# No builder.build()
self.build_tree(["target/"])
self.assertRaises(bzr_errors.NoSuchFile, dget,
self.get_url(builder.dsc_name()), 'target')
def conflict_obsolete(latest_version: Version, kind: str,
req_version: Version):
req_version = Version(req_version)
if kind == "<<":
return latest_version >= req_version
elif kind in ("<=", "="):
return latest_version > req_version
return False
def increment_version(v: Version) -> None:
"""Increment a version number.
For native packages, increment the main version number.
For other packages, increment the debian revision.
Args:
v: Version to increment (modified in place)
"""
if v.debian_revision is not None:
v.debian_revision = re.sub(
"\\d+$", lambda x: str(int(x.group()) + 1), v.debian_revision
)
else:
v.upstream_version = re.sub(
"\\d+$", lambda x: str(int(x.group()) + 1), v.upstream_version
)
def test_default(self):
# Upstream source code and a non-native package -> NORMAL
tree = self.make_branch_and_tree('.')
self.assertEquals(
BUILD_TYPE_NORMAL,
guess_build_type(tree,
Version("1.0-1"),
contains_upstream_source=True))
def test_empty(self):
# Empty tree and a non-native package -> NORMAL
tree = self.make_branch_and_tree('.')
self.assertEquals(
BUILD_TYPE_NORMAL,
guess_build_type(tree,
Version("1.0-1"),
contains_upstream_source=None))
def test_prev_version_native(self):
# Native package version -> NATIVE
tree = self.make_branch_and_tree('.')
self.assertEquals(
BUILD_TYPE_NATIVE,
guess_build_type(tree,
Version("1.0"),
contains_upstream_source=True))
def depends_obsolete(latest_version: Version, kind: str, req_version: Version):
req_version = Version(req_version)
if kind == ">=":
return latest_version >= req_version
elif kind == ">>":
return latest_version > req_version
elif kind == "=":
return False
return False
def test_no_upstream_source(self):
# No upstream source code and a non-native package -> MERGE
tree = self.make_branch_and_tree('.')
tree.mkdir("debian")
self.assertEquals(
BUILD_TYPE_MERGE,
guess_build_type(tree,
Version("1.0-1"),
contains_upstream_source=False))
def test_dget_transport(self):
builder = SourcePackageBuilder("package", Version("0.1-1"))
builder.add_upstream_file("foo")
builder.add_default_control()
builder.build()
self.build_tree(["target/"])
dget(self.get_url(builder.dsc_name()), 'target')
self.assertPathExists(os.path.join("target", builder.dsc_name()))
self.assertPathExists(os.path.join("target", builder.tar_name()))
self.assertPathExists(os.path.join("target", builder.diff_name()))
def make_unuploaded(self):
self.wt = self.make_branch_and_tree('.')
self.build_tree(['debian/'])
cl = Changelog()
v = Version("0.1-1")
cl.new_block(package='package',
version=Version('0.1-1'),
distributions='unstable',
urgency='low',
author='James Westby <*****@*****.**>',
date='Thu, 3 Aug 2006 19:16:22 +0100',
)
cl.add_change('');
cl.add_change(' * Initial packaging.');
cl.add_change('');
with open('debian/changelog', 'w') as f:
cl.write_to_open_file(f)
self.wt.add(["debian/", "debian/changelog"])
self.wt.commit("one")
def get_recent_versions(self, package, since_version=None):
versions = {}
for source in self._sources:
for unmangled, mangled in source.get_recent_versions(
package, since_version):
versions[mangled] = unmangled
return [
(u, m)
for (m, u) in sorted(versions.items(), key=lambda v: Version(v[0]))
]
def tree_set_changelog_version(tree: WorkingTree, build_version: Version,
subpath: str) -> None:
cl_path = osutils.pathjoin(subpath, "debian/changelog")
with tree.get_file(cl_path) as f:
cl = Changelog(f)
if Version(str(cl.version) + "~") > build_version:
return
cl.version = build_version
with open(tree.abspath(cl_path), "w") as f:
cl.write_to_open_file(f)
def test_inconsistent(self):
# If version string and source format disagree on whether the package is native,
# raise an exception.
tree = self.make_branch_and_tree('.')
self.writeVersionFile(tree, "3.0 (native)")
e = self.assertRaises(InconsistentSourceFormatError, guess_build_type, tree,
Version("1.0-1"), True)
self.assertEquals(
"Inconsistency between source format and version: version is not native, "
"format is native.", str(e))
def extract(self):
tempdir = self.exit_stack.enter_context(tempfile.TemporaryDirectory())
dsc_filename = os.path.abspath(self.dsc_path)
proc = subprocess.Popen("dpkg-source --skip-debianization -x %s" %
(dsc_filename, ),
shell=True,
cwd=tempdir,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
preexec_fn=subprocess_setup)
(stdout, _) = proc.communicate()
assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \
(stdout,)
name = self.dsc['Source']
version = Version(self.dsc['Version'])
self.extracted_debianised = os.path.join(
tempdir, "%s-%s" % (name, str(version.upstream_version)))
self.extracted_upstream = self.extracted_debianised + ".orig"
os.rename(self.extracted_debianised, self.extracted_upstream)
proc = subprocess.Popen("dpkg-source -x %s" % (dsc_filename, ),
shell=True,
cwd=tempdir,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
preexec_fn=subprocess_setup)
(stdout, _) = proc.communicate()
assert proc.returncode == 0, "dpkg-source -x failed, output:\n%s" % \
(stdout,)
# Check that there are no unreadable files extracted.
subprocess.call([
"find", self.extracted_upstream, "-perm", "0000", "-exec", "chmod",
"644", "{}", ";"
])
subprocess.call([
"find", self.extracted_debianised, "-perm", "0000", "-exec",
"chmod", "644", "{}", ";"
])
for part in self.dsc['files']:
if part['name'].startswith("%s_%s.orig" %
(name, str(version.upstream_version))):
self.upstream_tarballs.append(
(os.path.abspath(
os.path.join(osutils.dirname(self.dsc_path),
part['name'])),
component_from_orig_tarball(
part['name'], name,
str(version.upstream_version)), str(part['md5sum'])))
elif (part['name'].endswith(".debian.tar.gz")
or part['name'].endswith(".debian.tar.bz2")
or part['name'].endswith(".debian.tar.xz")):
self.unextracted_debian_md5 = str(part['md5sum'])
assert self.upstream_tarballs is not None, \
"Can't handle non gz|bz2|xz tarballs yet"
assert self.unextracted_debian_md5 is not None, \
"Can't handle non gz|bz2|xz tarballs yet"
def test_add_new(self):
tree = self.make_branch_and_tree(".")
tree.lock_write()
self.addCleanup(tree.unlock)
tree.mkdir("debian")
changelog_add_new_version(tree, "1.0", "sid", None, "somepkg")
# changelog_add_new_version will version the changelog if it was created
cl = Changelog(open('debian/changelog'))
self.assertEquals(cl._blocks[0].package, "somepkg")
self.assertEquals(cl._blocks[0].distributions, "UNRELEASED")
self.assertEquals(cl._blocks[0].version, Version("1.0-1"))
self.assertEquals([], list(tree.filter_unversioned_files(["debian/changelog"])))
def test_distill_tarball_exists(self):
wt = self.make_branch_and_tree(".")
wt.lock_read()
self.addCleanup(wt.unlock)
name = "package"
version = Version("0.1-1")
self.make_tarball(name, version)
sd = MergeModeDistiller(
wt, '', _SimpleUpstreamProvider(name, version.upstream_version, "."))
sd.distill('target/foo')
self.assertPathExists(
'target/%s_%s.orig.tar.gz' % (name, version.upstream_version))
self.assertPathExists('target/foo/a')
async def _package_version(package: str, release: str) -> Optional[Version]:
from .udd import connect_udd_mirror
try:
async with await connect_udd_mirror() as conn:
version = await conn.fetchval(
"select version from packages where package = $1 and release = $2",
package, release)
except asyncio.TimeoutError:
raise UddTimeout()
if version is not None:
return Version(version)
return None
