def integration_test_no_hit():
good_env = InputData("good_environment_no_hit_1")
good_env.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_NOT_HIT)
good_env.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
good_env.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
good_env.add(Specs.redhat_release, RHEL7)
yield good_env, None
good_env = InputData("good_environment_no_hit_2")
good_env.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
good_env.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_NOT_HIT)
good_env.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
good_env.add(Specs.redhat_release, RHEL7)
yield good_env, None
good_env = InputData("good_environment_no_hit_3")
good_env.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
good_env.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
good_env.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_NOT_HIT)
good_env.add(Specs.redhat_release, RHEL7)
yield good_env, None
good_env = InputData("good_environment_no_hit_4")
good_env.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
good_env.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
good_env.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
good_env.add(Specs.redhat_release, RHEL6)
yield good_env, None
def test_lscpu():
input_data = InputData().add(Specs.lscpu, LSCPU_1)
result = run_test(system_profile, input_data)
assert result["cores_per_socket"] == 1
input_data = InputData().add(Specs.lscpu, LSCPU_2)
result = run_test(system_profile, input_data)
assert result.get("cores_per_socket") is None
def integration_tests_3():
input_data = InputData("test_return_skip_exception_1")
input_data.add(Specs.redhat_release, RHEL7)
yield input_data, None
input_data = InputData("test_return_skip_exception_2")
input_data.add(Specs.redhat_release, RHEL7)
yield input_data, None
def integration_tests_1():
input_data = InputData("test_return_make_none_1")
input_data.add(Specs.redhat_release, RHEL7)
yield input_data, None
input_data = InputData("test_return_make_none_2")
input_data.add(Specs.redhat_release, RHEL7)
yield input_data, MAKE_NONE_RESULT
def test_integration_tests():
comp = insights_heartbeat.is_insights_heartbeat
input_data = InputData(name="Match: no kernel")
input_data.add(Specs.hostname, insights_heartbeat.HOST)
expected = make_fail(insights_heartbeat.ERROR_KEY)
run_test(comp, input_data, expected)
input_data = InputData(name="No Match: bad hostname")
input_data.add(Specs.hostname, NON_MATCHING_HOSTNAME)
run_test(comp, input_data, None)
def test_integration_2(run_rule):
input_data = InputData("test_return_none_2_1")
input_data.add(Specs.redhat_release, RHEL7)
result = run_rule(returns_none.report_none, input_data)
assert result is None
input_data = InputData("test_return_none_2_2")
input_data.add(Specs.redhat_release, RHEL7)
result = run_rule(returns_none.report_none,
input_data,
return_make_none=True)
assert result == MAKE_NONE_RESULT
def test_integration_3(run_rule):
input_data = InputData("test_return_skip_exception_2_1")
input_data.add(Specs.redhat_release, RHEL7)
result = run_rule(returns_none.report_skip_exception, input_data)
assert result is None
input_data = InputData("test_return_skip_exception_2_2")
input_data.add(Specs.redhat_release, RHEL7)
result = run_rule(returns_none.report_skip_exception,
input_data,
return_make_none=True)
assert result is None
def integration_test():
input_data = InputData("no_bash_bug")
input_data.add(Specs.installed_rpms, CURRENT_VERSION)
expected = make_pass("BASH_BUG", bash=CURRENT_VERSION, found=NOT_FOUND)
yield input_data, expected
input_data = InputData("is_bash_bug")
input_data.add(Specs.installed_rpms, BUG_VERSION)
expected = make_fail("BASH_BUG", bash=BUG_VERSION, found=FOUND)
yield input_data, expected
def test_gcp_license_codes():
input_data = InputData().add(Specs.gcp_license_codes, GCP_LICENSE_CODES_1)
result = run_test(system_profile, input_data)
assert result["is_marketplace"] is True
input_data = InputData().add(Specs.gcp_license_codes, GCP_LICENSE_CODES_2)
result = run_test(system_profile, input_data)
assert result["is_marketplace"] is True
input_data = InputData().add(Specs.gcp_license_codes,
GCP_LICENSE_CODES_BAD)
result = run_test(system_profile, input_data)
assert result.get("is_marketplace") is None
def integration_test():
input_data = InputData("test_fedora")
input_data.add(Specs.redhat_release, FEDORA)
expected = make_response("IS_FEDORA", product="Fedora")
yield input_data, expected
input_data = InputData("test_rhel")
input_data.add(Specs.redhat_release, RHEL)
expected = make_response("IS_NOT_FEDORA", product="Red Hat Enterprise Linux Server")
yield input_data, expected
def integration_tests():
# Test that should pass
data = InputData("localhost_in_hosts")
data.add('hosts', HOSTS_WITH_LOCALHOST)
yield data, []
# Test that should fail
data = InputData("localhost_not_in_hosts")
data.add('hosts', HOSTS_WITHOUT_LOCALHOST)
expected = make_response(localhost_in_hosts.ERROR_KEY,
message=localhost_in_hosts.MESSAGE,
hosts_defined=set({
'fte.example.com', 'nonlocal.example.com',
'nonlocal2.fte.example.com'
}))
yield data, [expected]
def test_rpmostree_status_full():
input_data = InputData().add(Specs.rpm_ostree_status, DATA_1)
result = run_test(system_profile, input_data)
deployments = result["rpm_ostree_deployments"]
assert len(deployments) == 2
dep = deployments[0]
assert dep == {
"id":
"fedora-silverblue-63335a77f9853618ba1a5f139c5805e82176a2a040ef5e34d7402e12263af5bb.0",
"checksum":
"63335a77f9853618ba1a5f139c5805e82176a2a040ef5e34d7402e12263af5bb",
"origin": "fedora/33/x86_64/silverblue",
"osname": "fedora-silverblue",
"version": "33.21",
"booted": True,
"pinned": False,
}
dep = deployments[1]
assert dep == {
"id":
"fedora-silverblue-775d54e89bc74731ec27db04f12510c0269c8cbab3ad5e39e0a4d693231ef072.0",
"checksum":
"775d54e89bc74731ec27db04f12510c0269c8cbab3ad5e39e0a4d693231ef072",
"origin": "fedora/33/x86_64/silverblue",
"osname": "fedora-silverblue",
"version": "33.17",
"booted": False,
"pinned": False,
}
def integration_test_hit():
bad_env = InputData("bad_environment_hit_1")
bad_env.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
bad_env.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
bad_env.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
bad_env.add(Specs.redhat_release, RHEL7)
expected = make_fail(ocp_tuned_regression.ERROR_KEY, tuned_version='tuned-2.11.0-5.el7')
yield bad_env, expected
bad_env = InputData("bad_environment_hit_2")
bad_env.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
bad_env.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT2)
bad_env.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
bad_env.add(Specs.redhat_release, RHEL7)
expected = make_fail(ocp_tuned_regression.ERROR_KEY, tuned_version='tuned-2.11.0-5.el7fdp')
yield bad_env, expected
def integration_test():
input_data = InputData("test_fedora")
input_data.add(Specs.redhat_release, FEDORA)
input_data.add(Specs.hostname, TEST_HOSTNAME)
expected = make_pass("IS_FEDORA", hostname=TEST_HOSTNAME, product="Fedora")
yield input_data, expected
input_data = InputData("test_rhel")
input_data.add(Specs.redhat_release, RHEL)
input_data.add(Specs.hostname, TEST_HOSTNAME)
expected = make_fail("IS_NOT_FEDORA",
hostname=TEST_HOSTNAME,
product="Red Hat Enterprise Linux Server")
yield input_data, expected
def test_cpuinfo():
input_data = InputData().add(Specs.cpuinfo, CPU_INFO_1)
result = run_test(system_profile, input_data)
assert result["cpu_flags"] == [
"fpu", "vme", "de", "pse", "tsc", "msr", "pae", "mce"
]
assert result["cpu_model"] == "Intel(R) Xeon(R) CPU E5-2690 0 @ 2.90GHz"
assert result["number_of_cpus"] == 2
assert result["number_of_sockets"] == 2
def test_noselinux():
for first, second, policy_type, selinux_type in MATCHING + NON_MATCHING + INVALID:
second = second.format(policy_type)
input_data = InputData()
input_data.add('sestatus', SESTATUS_DISABLED)
input_data.add('installed-rpms', first + '\n' + second)
input_data.add('selinux-config', SELINUX_CONFIG.format(selinux_type))
response = integrate(input_data, rule.report)
assert response == []
tests.append((input_data, response))
input_data = InputData()
input_data.add('sestatus', SESTATUS_PERMISSIVE)
input_data.add('installed-rpms', first + '\n' + second)
input_data.add('selinux-config', SELINUX_CONFIG.format(selinux_type))
response = integrate(input_data, rule)
assert response == []
tests.append((input_data, response))
def test_valid_selinux():
for first, second, policy_type, selinux_type in MATCHING:
second = second.format(policy_type)
input_data = InputData()
input_data.add('sestatus', SESTATUS_OK)
input_data.add('installed-rpms', first + '\n' + second)
input_data.add('selinux-config', SELINUX_CONFIG.format(selinux_type))
response = integrate(input_data, rule.report)
assert response == []
tests.append((input_data, response))
def test_rules_fixture(run_rule):
input_data = InputData('test_pass')
input_data.add(UNAME['spec'], UNAME['data'])
input_data.add(RPMS['spec'], RPMS['data'], path=RPMS['path'])
expected = make_pass('PASS',
bash_ver='bash-4.1.23-6.fc29',
uname_ver='2.6.32')
results = run_rule(rules_fixture_plugin.report, input_data)
assert results == expected
input_data = InputData('test_fail')
input_data.add(RPMS['spec'], RPMS['data'], path=RPMS['path'])
expected = make_fail('FAIL',
bash_ver='bash-4.1.23-6.fc29',
path=RPMS['path'])
results = run_rule(rules_fixture_plugin.report, input_data)
assert results == expected
input_data = InputData('test_ret_none')
results = run_rule(rules_fixture_plugin.report, input_data)
assert results is None
def integration_test_no_hit():
data = InputData("test1")
data.add(Specs.installed_rpms, INSTALLED_TUNED_HIT)
expected = make_fail(tuned_not_applying_profiles.ERROR_KEY,
installed_package='tuned-2.11.0-5.el7',
kcs=tuned_not_applying_profiles.KCS)
yield data, expected
data = InputData("test2")
data.add(Specs.installed_rpms, INSTALLED_TUNED_FDP_HIT)
expected = make_fail(tuned_not_applying_profiles.ERROR_KEY,
installed_package='tuned-2.11.0-5.el7fdp',
kcs=tuned_not_applying_profiles.KCS)
yield data, expected
data = InputData("test3")
data.add(Specs.installed_rpms, INSTALLED_TUNED_NOT_HIT)
yield data, None
data = InputData("test4")
data.add(Specs.installed_rpms, INSTALLED_TUNED_FDP_NOT_HIT)
yield data, None
def integration_tests():
data = InputData("Hit test 1")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
data.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
data.add(Specs.messages, CONTENT_MESSAGES_HIT)
expected = make_info(ocp_elasticsearch_crashbackoff.ERROR_KEY,
kcs=ocp_elasticsearch_crashbackoff.KCS,
checked_sysctl="vm.max_map_count=65530")
yield data, expected
data = InputData("No Hit test 1")
data.add(Specs.redhat_release, RHEL6)
data.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
data.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
data.add(Specs.messages, CONTENT_MESSAGES_HIT)
yield data, None
data = InputData("No Hit test 2")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_NOT_HIT)
data.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
data.add(Specs.messages, CONTENT_MESSAGES_HIT)
yield data, None
data = InputData("No Hit test 3")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
data.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_NOT_HIT)
data.add(Specs.messages, CONTENT_MESSAGES_HIT)
yield data, None
data = InputData("No Hit test 4")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.systemctl_list_units, CONTENT_SYSTEMCTL_LIST_UNITS_HIT)
data.add(Specs.sysctl, CONTENT_SYSCTL_COMMAND_HIT)
data.add(Specs.messages, CONTENT_MESSAGES_NOT_HIT)
yield data, None
def integration_tests():
"""
InputData acts as the data source for the parsers
so that they may execute and then be used as input
to the rule. So this is essentially and end-to-end
test of the component chain.
"""
input_data = InputData("GOOD_CONFIG")
input_data.add(LocalSpecs.sshd_config, GOOD_CONFIG)
input_data.add(Specs.installed_rpms, OPENSSH_RPM)
yield input_data, None
input_data = InputData("BAD_CONFIG")
input_data.add(LocalSpecs.sshd_config, BAD_CONFIG)
input_data.add(Specs.installed_rpms, OPENSSH_RPM)
errors = {
'AuthenticationMethods': 'badkey',
'LogLevel': 'normal',
'PermitRootLogin': '******',
'Protocol': '1'
}
expected = make_fail(sshd_secure.ERROR_KEY,
errors=errors,
openssh=EXPECTED_OPENSSH)
yield input_data, expected
input_data = InputData("DEFAULT_CONFIG")
input_data.add(LocalSpecs.sshd_config, DEFAULT_CONFIG)
input_data.add(Specs.installed_rpms, OPENSSH_RPM)
errors = {
'AuthenticationMethods': 'default',
'LogLevel': 'default',
'PermitRootLogin': '******'
}
expected = make_fail(sshd_secure.ERROR_KEY,
errors=errors,
openssh=EXPECTED_OPENSSH)
yield input_data, expected
def test_nonmatching_selinux():
for first, second, policy_type, selinux_type in NON_MATCHING:
second = second.format(policy_type)
input_data = InputData()
input_data.add('sestatus', SESTATUS_OK)
input_data.add('installed-rpms', first + '\n' + second)
input_data.add('selinux-config', SELINUX_CONFIG.format(selinux_type))
response = integrate(input_data, rule.report)
assert 'policy_rpm' in response[0]
assert 'policy_type_rpm' in response[0]
assert 'policy_type' in response[0]
assert response[0]['policy_rpm'] == first[:first.rfind('.')]
assert response[0]['policy_type_rpm'] == second[:second.rfind('.')]
assert response[0]['policy_type'] == policy_type
tests.append((input_data, response))
def test_rpmostree_status_simple():
input_data = InputData().add(Specs.rpm_ostree_status, DATA_0)
result = run_test(system_profile, input_data)
deployments = result["rpm_ostree_deployments"]
assert len(deployments) == 1
dep = deployments[0]
assert dep == {
"id":
"rhel-f0c0294860db563e5906db8c9f257d2bfebe40c93e0320b0e380b879f545e267.0",
"checksum":
"f0c0294860db563e5906db8c9f257d2bfebe40c93e0320b0e380b879f545e267",
"origin": "edge:rhel/8/x86_64/edge",
"osname": "rhel",
"booted": True,
"pinned": False
}
def _run_rule(name, rule, input_data):
"""
Fixture for rule integration testing
Use this fixture to create an integration test for your rule plugin.
Sample code::
def test_myrule(run_rule):
input_data = {'spec': Specs.installed_rpms, 'data': RPMS_DATA}
expected = make_fail(ERROR_KEY, bad_data=data_expected)
results = run_rule('my test name', my_rule, input_data)
assert results == expected
Arguments:
name (str): Name to identify this test in output.
rule (object): Your rule function object.
data (list or dict): List of dict of each data spec your rule requires
to trigger. If a single input data spec then a dict can be passed instead.
Each dict must include both ``spec`` and ``data`` keys, and may optionally
include ``path`` if necessary for the spec.
Return:
results of call to make_pass, make_fail, etc., or None
Raises:
KeyError: Raises if either spec or data keywords are not present.
"""
idata = InputData(name)
input_data = input_data if isinstance(input_data,
list) else [input_data]
for d in input_data:
if 'path' in d:
idata.add(d['spec'], d['data'], path=d['path'])
else:
idata.add(d['spec'], d['data'])
return run_test(rule, idata)
def integration_test_no_hit():
data = InputData("test1")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.ps_aux, CONTENT_PS_AUX_HIT)
data.add(Specs.systemctl_list_units, LIST_UNITS_FIREWALLD_RUNNING)
data.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
expected = make_fail(ocp_firewalld_enabled.ERROR_KEY, firewalld_service=True, version="4.1.9")
yield data, expected
data = InputData("test2")
data.add(Specs.redhat_release, RHEL6)
data.add(Specs.ps_aux, CONTENT_PS_AUX_HIT)
data.add(Specs.systemctl_list_units, LIST_UNITS_FIREWALLD_RUNNING)
data.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
yield data, None
data = InputData("test3")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.ps_aux, CONTENT_PS_AUX_NOT_HIT)
data.add(Specs.systemctl_list_units, LIST_UNITS_FIREWALLD_RUNNING)
data.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
yield data, None
data = InputData("test4")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.ps_aux, CONTENT_PS_AUX_HIT)
data.add(Specs.systemctl_list_units, LIST_UNITS_FIREWALLD_NOT_RUNNING)
data.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_HIT)
yield data, None
data = InputData("test5")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.ps_aux, CONTENT_PS_AUX_HIT)
data.add(Specs.systemctl_list_units, LIST_UNITS_FIREWALLD_RUNNING)
data.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_NOT_HIT)
yield data, None
data = InputData("test6")
data.add(Specs.redhat_release, RHEL7)
data.add(Specs.ps_aux, CONTENT_PS_AUX_NOT_HIT)
data.add(Specs.systemctl_list_units, LIST_UNITS_FIREWALLD_NOT_RUNNING)
data.add(Specs.installed_rpms, CONTENT_INSTALLED_RPMS_NOT_HIT)
yield data, None
def test_display_name():
input_data = InputData().add(Specs.display_name, DISPLAY_NAME_1)
result = run_test(system_profile, input_data)
assert result["display_name"] == "foo-bar"
def generate_inputs(things):
for kernel in things:
uname_line = UNAME_TEMPLATE % kernel
i = InputData()
i.add(Specs.uname, uname_line)
yield (kernel, i)
def test_greenboot_status_red():
input_data = InputData().add(Specs.greenboot_status, RED)
result = run_test(system_profile, input_data)
assert result["host_type"] == "edge"
def test_ansible_host():
input_data = InputData().add(Specs.ansible_host, ANSIBLE_HOST_1)
result = run_test(system_profile, input_data)
assert result["ansible_host"] == "foo-bar"
def test_always_fires():
i = InputData()
expected = make_pass("ALWAYS_FIRES", kernel="this is junk")
run_test(always_fires.report, i, expected)
