def test_get_loaded_kmods(monkeypatch):
run_subprocess_mocked = mock.Mock(
spec=run_subprocess,
side_effect=run_subprocess_side_effect(
(
("lsmod", ),
(
"Module Size Used by\n"
"a 81920 4\n"
"b 49152 0\n"
"c 40960 1\n",
0,
),
),
(("modinfo", "-F", "filename", "a"),
(MODINFO_STUB.split()[0] + "\n", 0)),
(("modinfo", "-F", "filename", "b"),
(MODINFO_STUB.split()[1] + "\n", 0)),
(("modinfo", "-F", "filename", "c"),
(MODINFO_STUB.split()[2] + "\n", 0)),
),
)
monkeypatch.setattr(
checks,
"run_subprocess",
value=run_subprocess_mocked,
)
assert get_loaded_kmods() == {
"kernel/lib/c.ko.xz", "kernel/lib/a.ko.xz", "kernel/lib/b.ko.xz"
}
def test_get_rhel_supported_kmods(
monkeypatch,
pretend_os,
repoquery_f_stub,
repoquery_l_stub,
exception,
):
run_subprocess_mock = mock.Mock(side_effect=run_subprocess_side_effect(
(
("repoquery", "-f"),
(repoquery_f_stub, 0),
),
(
("repoquery", "-l"),
(repoquery_l_stub, 0),
),
))
monkeypatch.setattr(
checks,
"run_subprocess",
value=run_subprocess_mock,
)
if exception:
with pytest.raises(exception):
checks.get_rhel_supported_kmods()
else:
res = checks.get_rhel_supported_kmods()
assert res == set((
"kernel/lib/a.ko",
"kernel/lib/a.ko.xz",
"kernel/lib/b.ko.xz",
"kernel/lib/c.ko.xz",
"kernel/lib/c.ko",
))
def test_ensure_compatibility_of_kmods(
monkeypatch,
pretend_os,
caplog,
host_kmods,
exception,
should_be_in_logs,
shouldnt_be_in_logs,
):
monkeypatch.setattr(checks, "get_loaded_kmods",
mock.Mock(return_value=host_kmods))
run_subprocess_mock = mock.Mock(side_effect=run_subprocess_side_effect(
(("uname", ), ("5.8.0-7642-generic\n", 0)),
(("repoquery", "-f"), (REPOQUERY_F_STUB_GOOD, 0)),
(("repoquery", "-l"), (REPOQUERY_L_STUB_GOOD, 0)),
))
monkeypatch.setattr(
checks,
"run_subprocess",
value=run_subprocess_mock,
)
if exception:
with pytest.raises(exception):
checks.ensure_compatibility_of_kmods()
else:
checks.ensure_compatibility_of_kmods()
if should_be_in_logs:
assert should_be_in_logs in caplog.records[-1].message
if shouldnt_be_in_logs:
assert shouldnt_be_in_logs not in caplog.records[-1].message
def test_remove_pkgs_failed_to_remove(
pkgs_to_remove,
ret_code,
backup_pkg,
critical,
expected,
monkeypatch,
caplog,
):
run_subprocess_mock = mock.Mock(
side_effect=unit_tests.run_subprocess_side_effect((
("rpm", "-e", "--nodeps", pkgs_to_remove[0]),
("test", ret_code)), ))
monkeypatch.setattr(
backup,
"run_subprocess",
value=run_subprocess_mock,
)
if critical:
with pytest.raises(SystemExit):
backup.remove_pkgs(
pkgs_to_remove=pkgs_to_remove,
backup=backup_pkg,
critical=critical,
)
else:
backup.remove_pkgs(pkgs_to_remove=pkgs_to_remove,
backup=backup_pkg,
critical=critical)
assert expected.format(pkgs_to_remove[0]) in caplog.records[-1].message
def test_enable_repos_toolopts_enablerepo(
toolopts_enablerepo,
subprocess,
should_raise,
expected,
expected_message,
tool_opts,
monkeypatch,
caplog,
):
cmd_mock = ["subscription-manager", "repos"]
for repo in toolopts_enablerepo:
cmd_mock.append("--enable=%s" % repo)
run_subprocess_mock = mock.Mock(
side_effect=unit_tests.run_subprocess_side_effect((cmd_mock,
subprocess), ))
monkeypatch.setattr(
utils,
"run_subprocess",
value=run_subprocess_mock,
)
tool_opts.enablerepo = toolopts_enablerepo
# monkeypatch.setattr(tool_opts, "enablerepo", toolopts_enablerepo)
if should_raise:
with pytest.raises(SystemExit):
subscription.enable_repos(rhel_repoids=None)
else:
subscription.enable_repos(rhel_repoids=None)
assert system_info.submgr_enabled_repos == expected
assert expected_message in caplog.records[-1].message
assert run_subprocess_mock.call_count == 1
def test_remove_iwlax2xx_firmware(
pretend_os,
is_iwl7260_installed,
is_iwlax2xx_installed,
subprocess_output,
subprocess_call_count,
expected_message,
monkeypatch,
caplog,
):
run_subprocess_mock = mock.Mock(side_effect=run_subprocess_side_effect((
("rpm", "-e", "--nodeps", "iwlax2xx-firmware"), subprocess_output), ))
is_rpm_installed_mock = mock.Mock(
side_effect=[is_iwl7260_installed, is_iwlax2xx_installed])
monkeypatch.setattr(
special_cases,
"run_subprocess",
value=run_subprocess_mock,
)
monkeypatch.setattr(special_cases.system_info,
"is_rpm_installed",
value=is_rpm_installed_mock)
special_cases.remove_iwlax2xx_firmware()
assert run_subprocess_mock.call_count == subprocess_call_count
assert is_rpm_installed_mock.call_count == 2
assert expected_message in caplog.records[-1].message
def test_is_loaded_kernel_latest_eus_system(
pretend_os,
repoquery_version,
uname_version,
return_code,
package_name,
raise_system_exit,
tmpdir,
monkeypatch,
caplog,
):
fake_reposdir_path = str(tmpdir)
monkeypatch.setattr(checks,
"get_hardcoded_repofiles_dir",
value=lambda: fake_reposdir_path)
run_subprocess_mocked = mock.Mock(
spec=run_subprocess,
side_effect=run_subprocess_side_effect(
(
(
"repoquery",
"--quiet",
"--qf",
'"%{BUILDTIME}\\t%{VERSION}-%{RELEASE}\\t%{REPOID}"',
"--setopt=reposdir=%s" % fake_reposdir_path,
package_name,
),
(
repoquery_version,
return_code,
),
),
(("uname", "-r"), (uname_version, return_code)),
),
)
monkeypatch.setattr(
checks,
"run_subprocess",
value=run_subprocess_mocked,
)
if raise_system_exit:
with pytest.raises(SystemExit):
is_loaded_kernel_latest()
repoquery_kernel_version = repoquery_version.split("\t")[1]
uname_kernel_version = uname_version.rsplit(".", 1)[0]
assert (
"The version of the loaded kernel is different from the latest version in repositories defined in the %s folder"
% fake_reposdir_path)
assert ("Latest kernel version available in baseos: %s\n" %
repoquery_kernel_version in caplog.records[-1].message)
assert "Loaded kernel version: %s\n" % uname_kernel_version in caplog.records[
-1].message
else:
is_loaded_kernel_latest()
assert "The currently loaded kernel is at the latest version." in caplog.records[
-1].message
def test_ensure_compatibility_of_kmods_excluded(
monkeypatch,
pretend_os,
caplog,
unsupported_pkg,
msg_in_logs,
msg_not_in_logs,
exception,
):
monkeypatch.setattr(
checks,
"get_loaded_kmods",
mock.Mock(return_value=HOST_MODULES_STUB_GOOD | {unsupported_pkg}),
)
get_unsupported_kmods_mocked = mock.Mock(
wraps=checks.get_unsupported_kmods)
run_subprocess_mock = mock.Mock(side_effect=run_subprocess_side_effect(
(("uname", ), ("5.8.0-7642-generic\n", 0)),
(("repoquery", "-f"), (REPOQUERY_F_STUB_GOOD, 0)),
(("repoquery", "-l"), (REPOQUERY_L_STUB_GOOD, 0)),
))
monkeypatch.setattr(
checks,
"run_subprocess",
value=run_subprocess_mock,
)
monkeypatch.setattr(
checks,
"get_unsupported_kmods",
value=get_unsupported_kmods_mocked,
)
if exception:
with pytest.raises(exception):
checks.ensure_compatibility_of_kmods()
else:
checks.ensure_compatibility_of_kmods()
get_unsupported_kmods_mocked.assert_called_with(
# host kmods
set((
unsupported_pkg,
"kernel/lib/c.ko.xz",
"kernel/lib/a.ko.xz",
"kernel/lib/b.ko.xz",
)),
# rhel supported kmods
set((
"kernel/lib/c.ko",
"kernel/lib/b.ko.xz",
"kernel/lib/c.ko.xz",
"kernel/lib/a.ko.xz",
"kernel/lib/a.ko",
)),
)
if msg_in_logs:
assert any(msg_in_logs in record.message for record in caplog.records)
if msg_not_in_logs:
assert all(msg_not_in_logs not in record.message
for record in caplog.records)
def test_unregister_system_submgr_not_found(self, monkeypatch, caplog):
rpm_command = ["rpm", "--quiet", "-q", "subscription-manager"]
run_subprocess_mock = mock.Mock(
side_effect=unit_tests.run_subprocess_side_effect((rpm_command,
("", 1)), ))
monkeypatch.setattr(utils, "run_subprocess", value=run_subprocess_mock)
subscription.unregister_system()
assert "The subscription-manager package is not installed." in caplog.records[
-1].message
def test_is_loaded_kernel_latest(repoquery_version, uname_version, return_code,
major_ver, package_name, raise_system_exit,
monkeypatch, caplog):
Version = namedtuple("Version", ("major", "minor"))
# Using the minor version as 99, so the tests should never fail because of a constraint in the code, since we don't
# mind the minor version number (for now), and require only that the major version to be in the range of 6 to 8,
# we can set the minor version to 99 to avoid hardcoded checks in the code.
monkeypatch.setattr(
checks.system_info,
"version",
value=Version(major=major_ver, minor=99),
)
system_info.id = "centos"
run_subprocess_mocked = mock.Mock(
spec=run_subprocess,
side_effect=run_subprocess_side_effect(
(
(
"repoquery",
"--quiet",
"--qf",
'"%{BUILDTIME}\\t%{VERSION}-%{RELEASE}\\t%{REPOID}"',
package_name,
),
(
repoquery_version,
return_code,
),
),
(("uname", "-r"), (uname_version, return_code)),
),
)
monkeypatch.setattr(
checks,
"run_subprocess",
value=run_subprocess_mocked,
)
if raise_system_exit:
with pytest.raises(SystemExit):
is_loaded_kernel_latest()
repoquery_kernel_version = repoquery_version.split("\t")[1]
uname_kernel_version = uname_version.rsplit(".", 1)[0]
assert ("Latest kernel version available in baseos: %s\n" %
repoquery_kernel_version in caplog.records[-1].message)
assert "Loaded kernel version: %s\n" % uname_kernel_version in caplog.records[
-1].message
else:
is_loaded_kernel_latest()
assert "The currently loaded kernel is at the latest version." in caplog.records[
-1].message
def test_lock_releasever_in_rhel_repositories(pretend_os, subprocess, expected,
monkeypatch, caplog):
cmd = [
"subscription-manager", "release",
"--set=%s" % system_info.releasever
]
run_subprocess_mock = mock.Mock(
side_effect=unit_tests.run_subprocess_side_effect((cmd, subprocess), ))
monkeypatch.setattr(
utils,
"run_subprocess",
value=run_subprocess_mock,
)
subscription.lock_releasever_in_rhel_repositories()
assert expected in caplog.records[-1].message
assert run_subprocess_mock.call_count == 1
def test_changed_pkgs_control_remove_installed_pkgs(monkeypatch, caplog):
removed_pkgs = ["pkg_1"]
run_subprocess_mock = mock.Mock(
side_effect=unit_tests.run_subprocess_side_effect((("rpm", "-e",
"--nodeps",
removed_pkgs[0]),
("test", 0)), ))
monkeypatch.setattr(
backup,
"run_subprocess",
value=run_subprocess_mock,
)
control = backup.ChangedRPMPackagesController()
control.installed_pkgs = removed_pkgs
control._remove_installed_pkgs()
assert "Removing package: %s" % removed_pkgs[0] in caplog.records[
-1].message
def test_is_loaded_kernel_latest_unsupported_skip(repoquery_version,
return_code, major_ver,
package_name,
unsupported_skip, expected,
monkeypatch, caplog):
run_subprocess_mocked = mock.Mock(
spec=run_subprocess,
side_effect=run_subprocess_side_effect((
(
"repoquery",
"--quiet",
"--qf",
'"%{BUILDTIME}\\t%{VERSION}-%{RELEASE}\\t%{REPOID}"',
package_name,
),
(
repoquery_version,
return_code,
),
), ),
)
monkeypatch.setattr(
checks.system_info,
"version",
value=systeminfo.Version(major=major_ver, minor=0),
)
monkeypatch.setattr(
checks,
"run_subprocess",
value=run_subprocess_mocked,
)
monkeypatch.setattr(os, "environ", {
"CONVERT2RHEL_UNSUPPORTED_SKIP_KERNEL_CURRENCY_CHECK":
unsupported_skip
})
if unsupported_skip == "0":
with pytest.raises(SystemExit):
is_loaded_kernel_latest()
expected = expected.format(package_name)
else:
is_loaded_kernel_latest()
assert expected in caplog.records[-1].message
def test_unregister_system(self, output, ret_code, expected, monkeypatch,
caplog):
submgr_command = ("subscription-manager", "unregister")
rpm_command = ("rpm", "--quiet", "-q", "subscription-manager")
# Mock rpm command
run_subprocess_mock = mock.Mock(side_effect=run_subprocess_side_effect(
(
submgr_command,
(
output,
ret_code,
),
),
(rpm_command, ("", 0)),
), )
monkeypatch.setattr(utils, "run_subprocess", value=run_subprocess_mock)
subscription.unregister_system()
assert expected in caplog.records[-1].message
def test_changedrpms_packages_controller_install_local_rpms_system_exit(
monkeypatch, caplog):
pkgs = ["pkg-1"]
run_subprocess_mock = mock.Mock(
side_effect=unit_tests.run_subprocess_side_effect((("rpm", "-i",
pkgs[0]),
("test", 1)), ))
monkeypatch.setattr(
backup,
"run_subprocess",
value=run_subprocess_mock,
)
control = backup.ChangedRPMPackagesController()
with pytest.raises(SystemExit):
control._install_local_rpms(pkgs_to_install=pkgs,
replace=False,
critical=True)
assert run_subprocess_mock.call_count == 1
assert "Error: Couldn't install %s packages." % pkgs[0] in caplog.records[
-1].message
