def test_packager_sign_all(patches, listdir, utils):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"PackageSigningRunner.sign",
("PackageSigningRunner.signing_utils", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
path = MagicMock()
with patched as (m_sign, m_utils):
_glob = {}
for _path in listdir:
_mock = MagicMock()
_mock.name = _path
_glob[_path] = _mock
path.glob.return_value = _glob.values()
m_utils.return_value = utils
assert not packager.sign_all(path)
assert (
list(path.glob.call_args)
== [('*',), {}])
expected = [x for x in listdir if x in utils]
assert (
list(list(c) for c in m_sign.call_args_list)
== [[(_glob[k], ), {}] for k in expected])
def test_packager_run(patches, extract):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"PackageSigningRunner.sign_tarball",
"PackageSigningRunner.sign_directory",
("PackageSigningRunner.extract", dict(new_callable=PropertyMock)),
("PackageSigningRunner.log", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
assert (
packager.run.__wrapped__.__catches__
== (identity.GPGError, sign.SigningError))
with patched as (m_tarb, m_dir, m_extract, m_log):
m_extract.return_value = extract
assert not packager.run()
assert (
list(m_log.return_value.success.call_args)
== [('Successfully signed packages',), {}])
if extract:
assert (
list(m_tarb.call_args)
== [(), {}])
assert not m_dir.called
return
assert not m_tarb.called
assert (
list(m_dir.call_args)
== [(), {}])
def test_util_pkg_files(patches, files):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
util = sign.DirectorySigningUtil("PATH", maintainer, "LOG")
patched = patches(
("DirectorySigningUtil.ext", dict(new_callable=PropertyMock)),
("DirectorySigningUtil.path", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_ext, m_path):
_glob = {}
for _path in files:
_mock = MagicMock()
_mock.name = _path
_glob[_path] = _mock
m_path.return_value.glob.return_value = _glob.values()
m_ext.return_value = "EXT"
result = util.pkg_files
expected = [fname for fname in files if fname.endswith(".EXT")]
assert (
list(m_path.return_value.glob.call_args)
== [("*",), {}])
assert "pkg_files" not in util.__dict__
assert (
result
== tuple(_glob[k] for k in expected))
def test_util_pkg_files(patches, files):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
util = sign.DirectorySigningUtil("PATH", maintainer, "LOG")
patched = patches(
"os", ("DirectorySigningUtil.ext", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_os, m_ext):
m_ext.return_value = "EXT"
m_os.listdir.return_value = files
result = util.pkg_files
expected = [fname for fname in files if fname.endswith(".EXT")]
assert (list(m_os.listdir.call_args) == [("PATH", ), {}])
if not expected:
assert not m_os.path.join.called
assert not result
else:
assert (result == tuple(m_os.path.join.return_value
for fname in expected))
assert (list(list(c) for c in m_os.path.join.call_args_list) == [[
("PATH", fname), {}
] for fname in expected])
assert "pkg_files" not in util.__dict__
def test_packager_add_arguments():
packager = sign.PackageSigningRunner("x", "y", "z")
parser = MagicMock()
packager.add_arguments(parser)
assert (
list(list(c) for c in parser.add_argument.call_args_list)
== [[('--log-level', '-l'),
{'choices': ['debug', 'info', 'warn', 'error'],
'default': 'info',
'help': 'Log level to display'}],
[('path',),
{'default': '',
'help': 'Path to the directory containing packages to sign'}],
[('--extract',),
{'action': 'store_true',
'help': 'If set, treat the path as a tarball containing directories '
'according to package_type'}],
[('--tar',),
{'help': 'Path to save the signed packages as tar file'}],
[('--type',),
{'choices': ['util1', 'util2', ''],
'default': '',
'help': 'Package type to sign'}],
[('--maintainer-name',),
{'default': '', 'help': 'Maintainer name to match when searching for a GPG key to match with'}],
[('--maintainer-email',),
{'default': '',
'help': 'Maintainer email to match when searching for a GPG key to match with'}]])
def test_packager_sign_tarball(patches, tar):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"utils",
"PackageSigningRunner.archive",
"PackageSigningRunner.sign_all",
("PackageSigningRunner.path", dict(new_callable=PropertyMock)),
("PackageSigningRunner.tar", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_utils, m_archive, m_sign, m_path, m_tar):
m_tar.return_value = tar
if not tar:
with pytest.raises(sign.SigningError) as e:
packager.sign_tarball()
else:
assert not packager.sign_tarball()
if not tar:
assert (
e.value.args[0] ==
'You must set a `--tar` file to save to when `--extract` is set')
assert not m_utils.untar.called
assert not m_sign.called
assert not m_archive.called
return
assert (list(m_utils.untar.call_args) == [(m_path.return_value, ), {}])
assert (list(m_sign.call_args) == [
(m_utils.untar.return_value.__enter__.return_value, ), {}
])
assert (list(m_archive.call_args) == [
(m_utils.untar.return_value.__enter__.return_value, ), {}
])
def test_util_package_type(ext, package_type):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
util = sign.DirectorySigningUtil("PATH", maintainer, "LOG")
util.ext = ext
util._package_type = package_type
assert util.package_type == package_type or ext
def test_packager_tar(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
("PackageSigningRunner.args", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_args, ):
assert packager.tar == m_args.return_value.tar
assert "tar" not in packager.__dict__
def test_debsign_command_args(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
patched = patches(
("identity.GPGIdentity.fingerprint", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_fingerprint, ):
debsign = sign.DebSigningUtil("PATH", maintainer, "LOG")
assert (debsign.command_args == ("-k", m_fingerprint.return_value))
assert "command_args" in debsign.__dict__
def test_util_constructor(command):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
args = ("PATH", maintainer, "LOG")
if command is not None:
args += (command, )
util = sign.DirectorySigningUtil(*args)
assert util.path == "PATH"
assert util.maintainer == maintainer
assert util.log == "LOG"
assert util._command == (command or "")
assert util.command_args == ()
def test_rpmsign_sign_pkg(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
rpmsign = DummyRPMSigningUtil("PATH", maintainer)
patched = patches("os",
"DirectorySigningUtil.sign_pkg",
prefix="tools.distribution.sign")
with patched as (m_os, m_sign):
assert not rpmsign.sign_pkg("FILE")
assert (list(m_os.chmod.call_args) == [('FILE', 0o755), {}])
assert (list(m_sign.call_args) == [('FILE', ), {}])
def test_util_sign_command(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
util = sign.DirectorySigningUtil("PATH", maintainer, "LOG")
patched = patches(
("DirectorySigningUtil.command", dict(new_callable=PropertyMock)),
("DirectorySigningUtil.command_args", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_command, m_args):
m_args.return_value = ("ARG1", "ARG2", "ARG3")
assert (util.sign_command("PACKAGE") == (m_command.return_value, ) +
m_args.return_value + ("PACKAGE", ))
def test_util_path(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
util = sign.DirectorySigningUtil("PATH", maintainer, "LOG")
patched = patches(
"pathlib",
prefix="tools.distribution.sign")
with patched as (m_plib, ):
assert util.path == m_plib.Path.return_value
assert (
list(m_plib.Path.call_args)
== [(util._path,), {}])
def test_debsign_constructor(patches, args):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
debsign = sign.DebSigningUtil("PATH", maintainer, "LOG", *args)
assert isinstance(debsign, sign.DirectorySigningUtil)
assert debsign.ext == "changes"
assert debsign.command_name == "debsign"
assert debsign._package_type == "deb"
assert debsign.changes_files == sign.DebChangesFiles
assert debsign.path == "PATH"
assert debsign.maintainer == maintainer
assert debsign.log == "LOG"
def test_packager_path(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"pathlib",
("PackageSigningRunner.args", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_plib, m_args):
assert packager.path == m_plib.Path.return_value
assert (
list(m_plib.Path.call_args)
== [(m_args.return_value.path, ), {}])
assert "path" not in packager.__dict__
def test_rpmsign_command_args(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
patched = patches(
"RPMSigningUtil.setup",
("identity.GPGIdentity.fingerprint", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_setup, m_fingerprint):
rpmsign = sign.RPMSigningUtil("PATH", maintainer, "LOG")
assert (rpmsign.command_args == ("--key-id",
m_fingerprint.return_value,
"--addsign"))
assert "command_args" in rpmsign.__dict__
def test_util_sign(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
util = sign.DirectorySigningUtil("PATH", maintainer, "LOG")
patched = patches(
"DirectorySigningUtil.sign_pkg",
("DirectorySigningUtil.pkg_files", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_sign, m_pkgs):
m_pkgs.return_value = ("PKG1", "PKG2", "PKG3")
assert not util.sign()
assert (list(list(c) for c in m_sign.call_args_list) == [[('PKG1', ), {}],
[('PKG2', ), {}],
[('PKG3', ), {}]])
def test_rpmsign_constructor(patches, args, kwargs):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
patched = patches("RPMSigningUtil.setup",
"DirectorySigningUtil.__init__",
prefix="tools.distribution.sign")
with patched as (m_setup, m_super):
rpmsign = sign.RPMSigningUtil("PATH", maintainer, *args, **kwargs)
assert isinstance(rpmsign, sign.DirectorySigningUtil)
assert rpmsign.ext == "rpm"
assert rpmsign.command_name == "rpmsign"
assert (list(m_setup.call_args) == [(), {}])
assert (list(m_super.call_args) == [('PATH', maintainer) + args, kwargs])
assert rpmsign.rpmmacro == sign.RPMMacro
def test_packager_sign(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"PackageSigningRunner.get_signing_util",
("PackageSigningRunner.log", dict(new_callable=PropertyMock)),
("PackageSigningRunner.maintainer", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_util, m_log, m_maintainer):
assert not packager.sign("PACKAGE_TYPE", "PATH")
assert (list(m_log.return_value.notice.call_args) == [
(f"Signing PACKAGE_TYPEs ({m_maintainer.return_value}) PATH", ), {}
])
assert (list(m_util.call_args) == [('PACKAGE_TYPE', 'PATH'), {}])
assert (list(m_util.return_value.sign.call_args) == [(), {}])
def test_packager_archive(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"tarfile",
("PackageSigningRunner.tar", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_tarfile, m_tar):
assert not packager.archive("PATH")
assert (
list(m_tarfile.open.call_args)
== [(m_tar.return_value, 'w'), {}])
assert (
list(m_tarfile.open.return_value.__enter__.return_value.add.call_args)
== [('PATH',), {'arcname': '.'}])
def test_packager_maintainer(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
("PackageSigningRunner.log", dict(new_callable=PropertyMock)),
("PackageSigningRunner.maintainer_class", dict(new_callable=PropertyMock)),
("PackageSigningRunner.maintainer_email", dict(new_callable=PropertyMock)),
("PackageSigningRunner.maintainer_name", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_log, m_class, m_email, m_name):
assert packager.maintainer == m_class.return_value.return_value
assert (
list(m_class.return_value.call_args)
== [(m_name.return_value, m_email.return_value, m_log.return_value), {}])
assert "maintainer" in packager.__dict__
def test_packager_get_signing_util(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
("PackageSigningRunner.log", dict(new_callable=PropertyMock)),
("PackageSigningRunner.maintainer", dict(new_callable=PropertyMock)),
("PackageSigningRunner.signing_utils", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
path = MagicMock()
with patched as (m_log, m_maintainer, m_utils):
assert packager.get_signing_util(path) == m_utils.return_value.__getitem__.return_value.return_value
assert (
list(m_utils.return_value.__getitem__.call_args)
== [(path.name,), {}])
assert (
list(m_utils.return_value.__getitem__.return_value.call_args)
== [(path, m_maintainer.return_value, m_log.return_value), {}])
def test_rpmsign_sign_pkg(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
rpmsign = DummyRPMSigningUtil("PATH", maintainer)
patched = patches(
"DirectorySigningUtil.sign_pkg",
prefix="tools.distribution.sign")
file = MagicMock()
with patched as (m_sign, ):
assert not rpmsign.sign_pkg(file)
assert (
list(file.chmod.call_args)
== [(0o755, ), {}])
assert (
list(m_sign.call_args)
== [(file,), {}])
def test_rpmsign_setup(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = MagicMock()
rpmsign = DummyRPMSigningUtil("PATH", maintainer)
patched = patches(
("RPMSigningUtil.rpmmacro", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_macro, ):
assert not rpmsign.setup()
assert (
list(m_macro.return_value.call_args)
== [(maintainer.home,),
{'maintainer': maintainer.name,
'gpg_bin': maintainer.gpg_bin,
'gpg_config': maintainer.gnupg_home}])
def test_packager_run(patches, extract, raises):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"PackageSigningRunner.sign_tarball",
"PackageSigningRunner.sign_directory",
("PackageSigningRunner.extract", dict(new_callable=PropertyMock)),
("PackageSigningRunner.log", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_tarb, m_dir, m_extract, m_log):
m_extract.return_value = extract
if raises:
_error = raises("AN ERROR OCCURRED")
m_extract.side_effect = _error
if raises == Exception:
with pytest.raises(raises):
packager.run()
else:
assert packager.run() == (1 if raises else None)
if raises:
assert not m_tarb.called
assert not m_dir.called
assert not m_log.return_value.success.called
if raises == Exception:
return
assert (list(m_log.return_value.error.call_args) == [(str(_error), ),
{}])
return
assert (list(m_log.return_value.success.call_args) == [
('Successfully signed packages', ), {}
])
if extract:
assert (list(m_tarb.call_args) == [(), {}])
assert not m_dir.called
return
assert not m_tarb.called
assert (list(m_dir.call_args) == [(), {}])
def test_packager_sign_all(patches, listdir, utils):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches("os",
"PackageSigningRunner.sign",
("PackageSigningRunner.signing_utils",
dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_os, m_sign, m_utils):
m_os.listdir.return_value = listdir
m_utils.return_value = utils
assert not packager.sign_all("PATH")
assert (list(m_os.listdir.call_args) == [('PATH', ), {}])
expected = [x for x in listdir if x in utils]
assert (list(list(c) for c in m_os.path.join.call_args_list) == [[
('PATH', k), {}
] for k in expected])
assert (list(list(c) for c in m_sign.call_args_list) == [[
(k, m_os.path.join.return_value), {}
] for k in expected])
def test_debsign_pkg_files(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
debsign = sign.DebSigningUtil("PATH", maintainer, "LOG")
patched = patches(
"chain",
("DirectorySigningUtil.pkg_files", dict(new_callable=PropertyMock)),
("DebSigningUtil.changes_files", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_chain, m_pkg, m_changes):
m_pkg.return_value = ("FILE1", "FILE2", "FILE3")
m_chain.from_iterable.side_effect = lambda _iter: list(_iter)
assert (debsign.pkg_files == (m_changes.return_value.return_value, ) *
3)
assert m_chain.from_iterable.called
assert (list(list(c) for c in m_changes.return_value.call_args_list) == [[
('FILE1', ), {}
], [('FILE2', ), {}], [('FILE3', ), {}]])
def test_packager_sign(patches):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"PackageSigningRunner.get_signing_util",
("PackageSigningRunner.log", dict(new_callable=PropertyMock)),
("PackageSigningRunner.maintainer", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
path = MagicMock()
with patched as (m_util, m_log, m_maintainer):
assert not packager.sign(path)
assert (
list(m_log.return_value.notice.call_args)
== [(f"Signing {path.name}s ({m_maintainer.return_value}) {path}",), {}])
assert (
list(m_util.call_args)
== [(path, ), {}])
assert (
list(m_util.return_value.sign.call_args)
== [(), {}])
def test_packager_sign_directory(patches, tar):
packager = sign.PackageSigningRunner("x", "y", "z")
patched = patches(
"PackageSigningRunner.archive",
"PackageSigningRunner.sign",
("PackageSigningRunner.package_type", dict(new_callable=PropertyMock)),
("PackageSigningRunner.path", dict(new_callable=PropertyMock)),
("PackageSigningRunner.tar", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
with patched as (m_archive, m_sign, m_type, m_path, m_tar):
m_tar.return_value = tar
assert not packager.sign_directory()
assert (list(m_sign.call_args) == [(m_type.return_value,
m_path.return_value), {}])
if not tar:
assert not m_archive.called
return
assert (list(m_archive.call_args) == [(m_path.return_value, ), {}])
def test_util_command(patches, command_name, command, which):
packager = sign.PackageSigningRunner("x", "y", "z")
maintainer = identity.GPGIdentity(packager)
util = sign.DirectorySigningUtil("PATH",
maintainer,
"LOG",
command=command)
patched = patches(
"shutil",
("DirectorySigningUtil.package_type", dict(new_callable=PropertyMock)),
prefix="tools.distribution.sign")
if command_name is not None:
util.command_name = command_name
with patched as (m_shutil, m_type):
m_shutil.which.return_value = which
if not which and not command:
with pytest.raises(sign.SigningError) as e:
util.command
assert (list(m_shutil.which.call_args) == [(command_name, ), {}])
assert (
e.value.args[0] ==
f"Signing software missing ({m_type.return_value}): {command_name}"
)
return
result = util.command
assert "command" in util.__dict__
assert not m_type.called
if command:
assert not m_shutil.which.called
assert result == command
return
assert (list(m_shutil.which.call_args) == [(command_name, ), {}])
assert result == m_shutil.which.return_value
