def test_network_interfaces_just_lo_ethtool_no_get_ipv4_addresses( self, MockGetInterfacesInfo, MockGetDevices): hw = hwprobe.HardwareCollector() MockGetDevices.return_value = ['lo'] mock_info = Mock(mac_address="00:00:00:00:00:00", device="lo", ipv4_address="127.0.0.1", ipv4_netmask="24", ipv4_broadcast="Unknown") mock_info.get_ipv6_addresses.return_value = [] # mock etherinfo not having a get_ipv4_addresses method # if this fails, you need a mock that supports deleting # attributes from mocks, ala mock 1.0+ try: del mock_info.get_ipv4_addresses except AttributeError: self.fail( "You probably need a newer version of 'mock' installed, 1.0 or newer" ) MockGetInterfacesInfo.return_value = [mock_info] net_int = hw.get_network_interfaces() self.assertEqual(net_int['net.interface.lo.ipv4_address'], '127.0.0.1') self.assertFalse('net.interface.lo.mac_address' in net_int)
def test_meminfo(self): hw = hwprobe.HardwareCollector() mem = hw.get_mem_info() # not great tests, but alas self.assertEqual(len(mem), 2) for key in mem: assert key in ['memory.memtotal', 'memory.swaptotal']
def test_distro_with_os_release(self, mock_exists): """ Test reading release information from /etc/os-release """ def mock_os_path_exists(path): """ This method mock missing /etc/redhat-release :param path: of this file :return: False for /etc/redhat-release and True for any other file """ if path == "/etc/redhat-release": return False else: return True mock_exists.side_effect = mock_os_path_exists hw = hwprobe.HardwareCollector() expected = { "distribution.version": "42", "distribution.name": "Awesome OS", "distribution.id": "Go4It", "distribution.version.modifier": "", } self.assertEqual(hw.get_release_info(), expected)
def test_lscpu_ignores_locale(self): hw_check_topo = hwprobe.HardwareCollector() facts = hw_check_topo.get_ls_cpu_info() # if all values can be encoded as ascii, then lscpu is not using JP locale for key, value in facts.items(): key.encode('ascii') value.encode('ascii')
def test_mocked_json_parser(self, mock_access, mock_check_json, mock_check_output): mock_access.return_value = True mock_check_json.return_value = True mock_check_output.return_value = LSCPU_JSON_OUTPUT hw_check = hwprobe.HardwareCollector() facts = hw_check.get_ls_cpu_info() self.assertEqual(LSCPU_JSON_EXPECTED, facts)
def __init__(self): self.collectors = [ collector.StaticFactsCollector(), host_collector.HostCollector(), hwprobe.HardwareCollector(), custom.CustomFactsCollector(), ]
def setUp(self): # Note this is patching an *instance* of HardwareCollector, not the class. self.hw_check_topo = hwprobe.HardwareCollector() self.hw_check_topo_patcher = patch.object(self.hw_check_topo, 'check_for_cpu_topo', Mock(return_value=True)) self.hw_check_topo_patcher.start() super(HardwareProbeTest, self).setUp()
def test_networkinfo(self): hw = hwprobe.HardwareCollector() net = hw.get_network_info() expected = set([ 'network.fqdn', 'network.hostname', 'network.ipv4_address', 'network.ipv6_address' ]) self.assertEqual(expected, set(net.keys()))
def __init__(self): self.collectors = [ collector.StaticFactsCollector(), host_collector.HostCollector(), hwprobe.HardwareCollector(), custom.CustomFactsCollector(), insights.InsightsCollector(), kpatch.KPatchCollector() ]
def test_distro_with_platform(self, MockExists): MockExists.return_value = False hw = hwprobe.HardwareCollector() expected = { 'distribution.version': '42', 'distribution.name': 'Awesome OS', 'distribution.id': 'Go4It', 'distribution.version.modifier': 'Unknown' } self.assertEqual(hw.get_release_info(), expected)
def test_distro_newline_in_release(self, MockOpen, MockExists): hw = hwprobe.HardwareCollector() MockExists.side_effect = [False, True] MockOpen.return_value.readline.return_value = "Awesome OS release 42 (Go4It)\n\n" expected = { "distribution.version": "42", "distribution.name": "Awesome OS", "distribution.id": "Go4It", "distribution.version.modifier": "", } self.assertEqual(hw.get_release_info(), expected)
def test_distro_newline_in_release(self, MockOpen, MockExists): hw = hwprobe.HardwareCollector() MockExists.side_effect = [False, True] MockOpen.return_value.readline.return_value = "Awesome OS release 42 (Go4It)\n\n" expected = { 'distribution.version': '42', 'distribution.name': 'Awesome OS', 'distribution.id': 'Go4It', 'distribution.version.modifier': '' } self.assertEqual(hw.get_release_info(), expected)
def test_distro_os_release_colon(self, MockOpen, MockExists): MockExists.return_value = True hw = hwprobe.HardwareCollector() with patch("rhsmlib.facts.hwprobe.platform"): MockOpen.return_value.readlines.return_value = OS_RELEASE_COLON.split("\n") expected = { "distribution.version": "42", "distribution.name": "Awesome OS", "distribution.id": "Go4It", "distribution.version.modifier": "be:ta", } self.assertEqual(hw.get_release_info(), expected)
def test_manual_distro_with_modifier(self, MockOpen, MockExists): MockExists.side_effect = [False, True] hw = hwprobe.HardwareCollector() with patch("rhsmlib.facts.hwprobe.platform"): MockOpen.return_value.readline.return_value = "Awesome OS release 42 Mega (Go4It)" expected = { "distribution.version": "42", "distribution.name": "Awesome OS", "distribution.id": "Go4It", "distribution.version.modifier": "mega", } self.assertEqual(hw.get_release_info(), expected)
def test_distro_os_release_colon(self, MockOpen, MockExists): MockExists.return_value = True hw = hwprobe.HardwareCollector() with patch('rhsmlib.facts.hwprobe.platform'): MockOpen.return_value.readlines.return_value = OS_RELEASE_COLON.split('\n') expected = { 'distribution.version': '42', 'distribution.name': 'Awesome OS', 'distribution.id': 'Go4It', 'distribution.version.modifier': 'be:ta' } self.assertEquals(hw.get_release_info(), expected)
def test_manual_distro_bogus_content_os_release(self, MockOpen, MockExists): hw = hwprobe.HardwareCollector() with patch('rhsmlib.facts.hwprobe.platform'): MockExists.return_value = True MockOpen.return_value.readlines.return_value = ["This is not really a release file of any sort"] expected = { 'distribution.version': 'Unknown', 'distribution.name': 'Unknown', 'distribution.id': 'Unknown', 'distribution.version.modifier': '' } self.assertEquals(hw.get_release_info(), expected)
def test_distro_bogus_content_no_platform_module(self, MockOpen, MockExists): hw = hwprobe.HardwareCollector() MockExists.side_effect = [False, True] with patch('rhsmlib.facts.hwprobe.platform'): MockOpen.return_value.readline.return_value = "this is not really a release file of any sort" expected = { 'distribution.version': 'Unknown', 'distribution.name': 'Unknown', 'distribution.id': 'Unknown', 'distribution.version.modifier': '' } self.assertEquals(hw.get_release_info(), expected)
def test_network_interfaces_just_lo(self, MockGetInterfacesInfo, MockGetDevices): hw = hwprobe.HardwareCollector() MockGetDevices.return_value = ["lo"] mock_info = Mock(mac_address="00:00:00:00:00:00", device="lo") mock_info.get_ipv6_addresses.return_value = [] mock_ipv4 = Mock(address="127.0.0.1", netmask="24", broadcase="Unknown") mock_info.get_ipv4_addresses = Mock(return_value=[mock_ipv4]) MockGetInterfacesInfo.return_value = [mock_info] net_int = hw.get_network_interfaces() self.assertEqual(net_int["net.interface.lo.ipv4_address"], "127.0.0.1") self.assertFalse("net.interface.lo.mac_address" in net_int)
def test_manual_distro_with_modifier(self, MockOpen, MockExists): MockExists.side_effect = [False, True] hw = hwprobe.HardwareCollector() with patch('rhsmlib.facts.hwprobe.platform'): MockOpen.return_value.readline.return_value = "Awesome OS release 42 Mega (Go4It)" expected = { 'distribution.version': '42', 'distribution.name': 'Awesome OS', 'distribution.id': 'Go4It', 'distribution.version.modifier': 'mega' } self.assertEqual(hw.get_release_info(), expected)
def test_network_interfaces_sit(self, MockGetInterfacesInfo, MockGetDevices): hw = hwprobe.HardwareCollector() MockGetDevices.return_value = ["sit0"] mock_ipv6 = Mock(address="::1", netmask="/128", scope="global") mock_info = Mock(mac_address="00:00:00:00:00:00", device="sit0") mock_info.get_ipv6_addresses.return_value = [mock_ipv6] mock_info.get_ipv4_addresses.return_value = [] MockGetInterfacesInfo.return_value = [mock_info] net_int = hw.get_network_interfaces() # ignore mac address for sit* interfaces (bz #838123) self.assertFalse("net.interface.sit0.mac_address" in net_int)
def test_network_interfaces_just_lo_ipv6(self, MockGetInterfacesInfo, MockGetDevices): hw = hwprobe.HardwareCollector() MockGetDevices.return_value = ["lo"] mock_ipv6 = Mock(address="::1", netmask="/128", scope="global") mock_info = Mock(mac_address="00:00:00:00:00:00", device="lo") mock_info.get_ipv6_addresses.return_value = [mock_ipv6] mock_info.get_ipv4_addresses.return_value = [] MockGetInterfacesInfo.return_value = [mock_info] net_int = hw.get_network_interfaces() self.assertEqual(net_int["net.interface.lo.ipv6_address.global"], "::1") self.assertFalse("net.interface.lo.mac_address" in net_int)
def get_all(self): host_facts = {} hardware_collector = hwprobe.HardwareCollector(prefix=self.prefix, testing=self.testing) hardware_info = hardware_collector.get_all() firmware_collector = firmware_info.FirmwareCollector( prefix=self.prefix, testing=self.testing, ) firmware_info_dict = firmware_collector.get_all() virt_collector = virt.VirtCollector( prefix=self.prefix, testing=self.testing, collected_hw_info=firmware_info_dict) virt_collector_info = virt_collector.get_all() host_facts.update(hardware_info) host_facts.update(virt_collector_info) host_facts.update(firmware_info_dict) locale_info = {} effective_locale = 'Unknown' # When there is no locale set (system variable LANG is unset), # then this is value returned by locale.getdefaultlocale() # Tuple contains: (language[_territory], encoding identifier) default_locale = (None, None) try: default_locale = locale.getdefaultlocale() except ValueError as err: log.warning( "Unable to get default locale (bad environment variable?): %s" % err) if default_locale[0] is not None: effective_locale = ".".join([_f for _f in default_locale if _f]) locale_info['system.default_locale'] = effective_locale host_facts.update(locale_info) # Now, munging, kluges, special cases, etc # NOTE: we are passing the facts we've already collected into # cleanup_collector. cleanup_collector = cleanup.CleanupCollector( prefix=self.prefix, testing=self.testing, collected_hw_info=host_facts) cleanup_info = cleanup_collector.get_all() host_facts.update(cleanup_info) return host_facts
def get_all(self): host_facts = {} hardware_collector = hwprobe.HardwareCollector(prefix=self.prefix, testing=self.testing) hardware_info = hardware_collector.get_all() firmware_collector = firmware_info.FirmwareCollector( prefix=self.prefix, testing=self.testing, ) firmware_info_dict = firmware_collector.get_all() virt_collector = virt.VirtCollector( prefix=self.prefix, testing=self.testing, collected_hw_info=firmware_info_dict) virt_collector_info = virt_collector.get_all() host_facts.update(hardware_info) host_facts.update(virt_collector_info) host_facts.update(firmware_info_dict) default_rhsm_dir = rhsm.config.DEFAULT_CONFIG_DIR.rstrip('/') custom_facts_dir = os.path.join(default_rhsm_dir, self.facts_sub_dir) path_and_globs = [(custom_facts_dir, self.facts_glob)] custom_facts = custom.CustomFactsCollector( prefix=self.prefix, testing=self.testing, path_and_globs=path_and_globs) custom_facts_dict = custom_facts.get_all() host_facts.update(custom_facts_dict) locale_info = {} locale_info['system.default_locale'] = ".".join( locale.getdefaultlocale()) host_facts.update(locale_info) # Now, munging, kluges, special cases, etc # NOTE: we are passing the facts we've already collected into # cleanup_collector. cleanup_collector = cleanup.CleanupCollector( prefix=self.prefix, testing=self.testing, collected_hw_info=host_facts) cleanup_info = cleanup_collector.get_all() host_facts.update(cleanup_info) return host_facts
def test_network_interfaces_multiple_ipv6(self, MockGetInterfacesInfo, MockGetDevices): hw = hwprobe.HardwareCollector() MockGetDevices.return_value = ['eth0'] mock_info = Mock(mac_address="00:00:00:00:00:00", device="eth0") mock_info.get_ipv4_addresses.return_value = [] mock_ipv6s = [Mock(address="::1", netmask="/128", scope="link"), Mock(address="fe80::f00d:f00d:f00d:f00d", netmask="/64", scope="link")] mock_info.get_ipv6_addresses = Mock(return_value=mock_ipv6s) MockGetInterfacesInfo.return_value = [mock_info] net_int = hw.get_network_interfaces() self.assertEqual(net_int['net.interface.eth0.ipv6_address.link'], '::1') self.assertEqual(net_int['net.interface.eth0.ipv6_address.link_list'], '::1, fe80::f00d:f00d:f00d:f00d')
def test_network_interfaces_multiple_ipv4(self, MockGetInterfacesInfo, MockGetDevices): hw = hwprobe.HardwareCollector() MockGetDevices.return_value = ['eth0'] mock_info = Mock(mac_address="00:00:00:00:00:00", device="eth0") mock_info.get_ipv6_addresses.return_value = [] mock_ipv4s = [Mock(address="10.0.0.1", netmask="24", broadcast="Unknown"), Mock(address="10.0.0.2", netmask="24", broadcast="Unknown")] mock_info.get_ipv4_addresses = Mock(return_value=mock_ipv4s) MockGetInterfacesInfo.return_value = [mock_info] net_int = hw.get_network_interfaces() self.assertEquals(net_int['net.interface.eth0.ipv4_address'], '10.0.0.2') self.assertEquals(net_int['net.interface.eth0.ipv4_address_list'], '10.0.0.1, 10.0.0.2')
def get_all(self): host_facts = {} hardware_collector = hwprobe.HardwareCollector( prefix=self.prefix, testing=self.testing ) hardware_info = hardware_collector.get_all() firmware_collector = firmware_info.FirmwareCollector( prefix=self.prefix, testing=self.testing, ) firmware_info_dict = firmware_collector.get_all() virt_collector = virt.VirtCollector( prefix=self.prefix, testing=self.testing, collected_hw_info=firmware_info_dict ) virt_collector_info = virt_collector.get_all() host_facts.update(hardware_info) host_facts.update(virt_collector_info) host_facts.update(firmware_info_dict) locale_info = {} effective_locale = 'Unknown' if locale.getdefaultlocale()[0] is not None: effective_locale = ".".join(filter(None, locale.getdefaultlocale())) locale_info['system.default_locale'] = effective_locale host_facts.update(locale_info) # Now, munging, kluges, special cases, etc # NOTE: we are passing the facts we've already collected into # cleanup_collector. cleanup_collector = cleanup.CleanupCollector( prefix=self.prefix, testing=self.testing, collected_hw_info=host_facts ) cleanup_info = cleanup_collector.get_all() host_facts.update(cleanup_info) return host_facts
def test_last_boot(self, mock_exists): """ Test reading release information from /proc/uptime """ def mock_os_path_exists(path): """ This method mock missing /proc/uptime :param path: of this file :return: False for /proc/uptime and True for any other file """ if path == "/proc/uptime": return False else: return True mock_exists.side_effect = mock_os_path_exists hw = hwprobe.HardwareCollector() last_boot_dict = hw.get_last_boot() last_boot = last_boot_dict["last_boot"] self.assertTrue(last_boot.endswith(" UTC"))
# Default is an empty FactsCollector self.facts_collector = self.facts_collector_class() @util.dbus_service_method(dbus_interface=constants.FACTS_DBUS_INTERFACE, out_signature='a{ss}') @util.dbus_handle_exceptions def GetFacts(self, sender=None): collection = self.facts_collector.collect() cleaned = dict([(str(key), str(value)) for key, value in list(collection.data.items())]) return dbus.Dictionary(cleaned, signature="ss") def class_factory(name, facts_collector=None): """Function used for creating subclasses of class BaseFact""" def __init__(self, conn=None, object_path=None, bus_name=None): super(self.__class__, self).__init__(conn=conn, object_path=object_path, bus_name=bus_name) self.facts_collector = facts_collector return type(name, (BaseFacts, ), {"__init__": __init__}) AllFacts = class_factory('AllFacts', all.AllFactsCollector()) HostFacts = class_factory('HostFacts', host_collector.HostCollector()) HardwareFacts = class_factory('HardwareFacts', hwprobe.HardwareCollector()) CustomFacts = class_factory('CustomFacts', custom.CustomFactsCollector()) StaticFacts = class_factory('StaticFacts', collector.StaticFactsCollector())
def test_get_slave_hwaddr_alb(self, MockOpen): MockOpen.return_value = six.StringIO(PROC_BONDING_ALB) hw = hwprobe.HardwareCollector() slave_hw = hw._get_slave_hwaddr("bond0", "eth0") # note we .upper the result self.assertEqual("52:54:00:07:03:BA", slave_hw)
def test_network_interfaces_none(self, MockGetInterfacesInfo, MockGetDevices): hw = hwprobe.HardwareCollector() net_int = hw.get_network_interfaces() self.assertEqual(net_int, {})