def test_hypervisorCheckIn(self, server): options = MagicMock() server.return_value.registration.new_system_user_pass.return_value = { 'system_id': '123' } config, d = self.create_fake_config('test', **self.default_config_args) manager = Manager.from_config(self.logger, config) self.host_guest_report._config = config manager.hypervisorCheckIn(self.host_guest_report, options) manager.server_xmlrpc.registration.virt_notify.assert_called_with(ANY, [ [0, "exists", "system", {"identity": "host", "uuid": "0000000000000000"}], [0, "crawl_began", "system", {}], [0, "exists", "domain", { "memory_size": 0, "name": "VM 9c927368-e888-43b4-9cdb-91b10431b258 from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670", "state": "running", "uuid": "9c927368e88843b49cdb91b10431b258", "vcpus": 1, "virt_type": "fully_virtualized" }], [0, "exists", "domain", { "memory_size": 0, "name": "VM d5ffceb5-f79d-41be-a4c1-204f836e144a from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670", "state": "shutoff", "uuid": "d5ffceb5f79d41bea4c1204f836e144a", "vcpus": 1, "virt_type": "fully_virtualized" }], [0, "crawl_ended", "system", {}] ])
def _create_destinations(self): """Populate self.destinations with a list of list with them @param reset: Whether to kill existing destinations or not, defaults to false @type: bool """ dests = [] for info in self.dest_to_source_mapper.dests: # Dests should already include all destinations we want created # at this time. This method will make no assumptions of creating # defaults of any kind. source_keys = self.dest_to_source_mapper.dest_to_sources_map[info] info.name = "destination_%s" % hash(info) logger = log.getLogger(name=info.name) manager = Manager.fromInfo(logger, self.options, info) dest_class = info_to_destination_class[type(info)] dest = dest_class(config=info, logger=logger, source_keys=source_keys, options=self.options, source=self.datastore, dest=manager, terminate_event=self.terminate_event, interval=self.options[VW_GLOBAL]['interval'], oneshot=self.options[VW_GLOBAL]['oneshot']) dests.append(dest) return dests
def test_satellite_config_file(self): # Username and password are required for a valid sat5 destination with open(os.path.join(self.config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt sat_server=sat.example.com sat_username=sat_username sat_password=sat_password """) conf = parse_file(os.path.join(self.config_dir, "test.conf")) effective_config = EffectiveConfig() conf_values = conf.pop("test") effective_config["test"] = ConfigSection.from_dict( conf_values, "test", effective_config ) config_manager = DestinationToSourceMapper(effective_config) self.assertEqual(len(config_manager.configs), 1) # There should only be one destination detected self.assertEqual(len(config_manager.dests), 1) # Which should be a Satellite5DestinationInfo dest_info = config_manager.dests.pop() self.assertTrue(isinstance(dest_info, Satellite5DestinationInfo), 'The destination info ' 'we got was not of the ' 'expected type') manager = Manager.fromInfo(self.logger, effective_config, dest_info) self.assertTrue(isinstance(manager, Satellite)) self.assertEqual(dest_info.sat_server, 'sat.example.com')
def test_sm_config_override(self, initConfig, HTTPSConnection, RhsmProxyHTTPSConnection): """Test if overriding options from rhsm.conf works.""" conn = MagicMock() conn.getresponse.return_value.status = 200 conn.getresponse.return_value.read.return_value = '{"result": "ok"}' HTTPSConnection.return_value = conn RhsmProxyHTTPSConnection.return_value = conn def config_get(section, key): return { 'server/proxy_hostname': 'proxy.server.test', 'rhsm/consumerCertDir': '', 'server/hostname': 'server.test', 'server/port': '8081', 'server/prefix': 'old_prefix', }.get('%s/%s' % (section, key), None) initConfig.return_value.get.side_effect = config_get config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt owner=owner env=env rhsm_hostname=host rhsm_port=8080 rhsm_prefix=/prefix rhsm_proxy_hostname= rhsm_proxy_port=8443 rhsm_insecure=1 rhsm_username=user rhsm_password=passwd """) conf = parse_file(os.path.join(config_dir, "test.conf")) effective_config = EffectiveConfig() conf_values = conf.pop("test") effective_config["test"] = VirtConfigSection.from_dict( conf_values, "test", effective_config ) config_manager = DestinationToSourceMapper(effective_config) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] manager = Manager.fromOptions(self.logger, Mock(), config) self.assertTrue(isinstance(manager, SubscriptionManager)) self.assertEqual(config.rhsm_hostname, 'host') self.assertEqual(config.rhsm_port, '8080') manager._connect(config) self.assertFalse(RhsmProxyHTTPSConnection.called, "It shouldn't use proxy") self.assertTrue(HTTPSConnection.called) conn.request.assert_called_with( 'GET', '/prefix/status/', body=ANY, headers=ANY)
def test_hypervisorCheckIn(self, server): options = MagicMock() server.return_value.registration.new_system_user_pass.return_value = { 'system_id': '123' } config = Config('test', 'libvirt', sat_server='localhost') manager = Manager.fromOptions(self.logger, options, config) options.env = "ENV" options.owner = "OWNER" manager.hypervisorCheckIn(self.host_guest_report, options) manager.server_xmlrpc.registration.virt_notify.assert_called_with(ANY, [ [0, "exists", "system", {"identity": "host", "uuid": "0000000000000000"}], [0, "crawl_began", "system", {}], [0, "exists", "domain", { "memory_size": 0, "name": "VM 9c927368-e888-43b4-9cdb-91b10431b258 from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670", "state": "running", "uuid": "9c927368e88843b49cdb91b10431b258", "vcpus": 1, "virt_type": "fully_virtualized" }], [0, "exists", "domain", { "memory_size": 0, "name": "VM d5ffceb5-f79d-41be-a4c1-204f836e144a from libvirt hypervisor ad58b739-5288-4cbc-a984-bd771612d670", "state": "shutoff", "uuid": "d5ffceb5f79d41bea4c1204f836e144a", "vcpus": 1, "virt_type": "fully_virtualized" }], [0, "crawl_ended", "system", {}] ])
def test_per_config_options_encrypted(self, can_write): options = Mock() options.force_register = True can_write.return_value = True with tempfile.NamedTemporaryFile() as tmp: password.Password.KEYFILE = tmp.name config_dict = { "sat_server": "http://localhost:%s" % TEST_PORT, "sat_username": "******", "sat_encrypted_password": hexlify(password.Password.encrypt('password')), "type": "libvirt", } config = VirtConfigSection.from_dict(config_dict, 'test', None) config.validate() dests = DestinationToSourceMapper.parse_dests_from_dict( config._values) self.assertEqual(len(dests), 1) dest_info = dests.pop() s = Manager.fromInfo(self.logger, options, dest_info) self.assertTrue(isinstance(s, Satellite)) report = HostGuestAssociationReport(config, self.mapping) result = s.hypervisorCheckIn(report, options) self.assertTrue("failedUpdate" in result) self.assertTrue("created" in result) self.assertTrue("updated" in result)
def _create_destinations(self): """Populate self.destinations with a list of list with them @param reset: Whether to kill existing destinations or not, defaults to false @type: bool """ dests = [] for info in self.dest_to_source_mapper.dests: # Dests should already include all destinations we want created # at this time. This method will make no assumptions of creating # defaults of any kind. source_keys = self.dest_to_source_mapper.dest_to_sources_map[info] info.name = "destination_%s" % hash(info) logger = log.getLogger(name=info.name) manager = Manager.fromInfo(logger, self.options, info) dest_class = info_to_destination_class[type(info)] dest = dest_class(config=info, logger=logger, source_keys=source_keys, options=self.options, source=self.datastore, dest=manager, terminate_event=self.terminate_event, interval=self.options[VW_GLOBAL]['interval'], oneshot=self.options[VW_GLOBAL]['oneshot'], status=self.options[VW_GLOBAL]['status']) dests.append(dest) return dests
def test_sm_config_override(self, initConfig, HTTPSConnection, RhsmProxyHTTPSConnection): """Test if overriding options from rhsm.conf works.""" conn = MagicMock() conn.getresponse.return_value.status = 200 conn.getresponse.return_value.read.return_value = '{"result": "ok"}' HTTPSConnection.return_value = conn RhsmProxyHTTPSConnection.return_value = conn def config_get(section, key): return { 'server/proxy_hostname': 'proxy.server.test', 'rhsm/consumerCertDir': '', 'server/hostname': 'server.test', 'server/port': '8081', 'server/prefix': 'old_prefix', }.get('%s/%s' % (section, key), None) initConfig.return_value.get.side_effect = config_get config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt owner=owner env=env rhsm_hostname=host rhsm_port=8080 rhsm_prefix=/prefix rhsm_proxy_hostname= rhsm_proxy_port=8443 rhsm_insecure=1 rhsm_username=user rhsm_password=passwd """) conf = parse_file(os.path.join(config_dir, "test.conf")) effective_config = EffectiveConfig() conf_values = conf.pop("test") effective_config["test"] = VirtConfigSection.from_dict( conf_values, "test", effective_config) config_manager = DestinationToSourceMapper(effective_config) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] manager = Manager.fromOptions(self.logger, Mock(), config) self.assertTrue(isinstance(manager, SubscriptionManager)) self.assertEqual(config.rhsm_hostname, 'host') self.assertEqual(config.rhsm_port, '8080') manager._connect(config) self.assertFalse(RhsmProxyHTTPSConnection.called, "It shouldn't use proxy") self.assertTrue(HTTPSConnection.called) conn.request.assert_called_with('GET', '/prefix/status/', body=ANY, headers=ANY)
def test_sm_config_cmd(self): os.environ = {} sys.argv = ["virt-who", "--sam", "--libvirt"] logger, options = parseOptions() config = Config("env/cmdline", options.virtType, defaults={}, **options) config.checkOptions(logger) manager = Manager.fromOptions(logger, options, config) self.assertTrue(isinstance(manager, SubscriptionManager))
def test_sendVirtGuests(self, create_from_file, connection): self.prepare(create_from_file, connection) config = VirtConfigSection.from_dict({'type': 'libvirt', 'sm_type': 'sam'}, 'test', None) manager = Manager.from_config(self.logger, config) manager.sendVirtGuests(self.domain_report, self.options) manager.connection.updateConsumer.assert_called_with( ANY, guest_uuids=[guest.toDict() for guest in self.guestInfo], hypervisor_id=self.hypervisor_id)
def test_sm_config_cmd(self): os.environ = {} sys.argv = ["virt-who", "--sam", "--libvirt"] logger, effective_config = parse_options() config_manager = DestinationToSourceMapper(effective_config) self.assertEqual(len(config_manager.configs), 1) config = dict(config_manager.configs)[VW_ENV_CLI_SECTION_NAME] manager = Manager.from_config(self.logger, config) self.assertTrue(isinstance(manager, SubscriptionManager))
def test_sm_config_env(self): os.environ = { "VIRTWHO_SAM": '1', "VIRTWHO_LIBVIRT": '1' } sys.argv = ["virt-who"] logger, config = parse_options() manager = Manager.from_config(logger, config) self.assertTrue(isinstance(manager, SubscriptionManager))
def test_sendVirtGuests(self): config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'sat_server': 'localhost' }, 'test', None) manager = Manager.from_config(self.logger, config) self.assertRaises(ManagerError, manager.sendVirtGuests, self.domain_report)
def test_sendVirtGuests(self, create_from_file, connection): self.prepare(create_from_file, connection) config = Config('test', 'libvirt') config.smType = 'sam' manager = Manager.fromOptions(self.logger, self.options, config) manager.sendVirtGuests(self.domain_report, self.options) manager.connection.updateConsumer.assert_called_with( ANY, guest_uuids=[guest.toDict() for guest in self.guestInfo], hypervisor_id=self.hypervisor_id)
def test_sendVirtGuests(self, create_from_file, connection): self.prepare(create_from_file, connection) config, d = self.create_fake_config('test', **self.default_config_args) manager = Manager.from_config(self.logger, config) self.domain_report._config = config manager.sendVirtGuests(self.domain_report, self.options) manager.connection.updateConsumer.assert_called_with( ANY, guest_uuids=[guest.toDict() for guest in self.guestInfo], hypervisor_id=self.hypervisor_id)
def test_sm_config_env(self): os.environ = { "VIRTWHO_SAM": '1', "VIRTWHO_LIBVIRT": '1' } sys.argv = ["virt-who"] logger, options = parseOptions() config = Config("env/cmdline", options.virtType, defaults={}, **options) config.checkOptions(logger) manager = Manager.fromOptions(logger, options, config) self.assertTrue(isinstance(manager, SubscriptionManager))
def test_satellite_config_cmd(self): os.environ = {} sys.argv = ["virt-who", "--satellite", "--satellite-server=sat.example.com", "--satellite-username=username", "--satellite-password=password", "--libvirt"] logger, options = parseOptions() config = Config("env/cmdline", options.virtType, defaults={}, **options) config.checkOptions(logger) manager = Manager.fromOptions(logger, options, config) self.assertTrue(isinstance(manager, Satellite))
def test_sendVirtGuests(self, create_from_file, connection): self.prepare(create_from_file, connection) config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'sm_type': 'sam' }, 'test', None) manager = Manager.from_config(self.logger, config) manager.sendVirtGuests(self.domain_report, self.options) manager.connection.updateConsumer.assert_called_with( ANY, guest_uuids=[guest.toDict() for guest in self.guestInfo], hypervisor_id=self.hypervisor_id)
def test_satellite_config_env(self): os.environ = { "VIRTWHO_SATELLITE": '1', "VIRTWHO_SATELLITE_SERVER": 'sat.example.com', "VIRTWHO_SATELLITE_USERNAME": '******', "VIRTWHO_SATELLITE_PASSWORD": '******', "VIRTWHO_LIBVIRT": '1' } sys.argv = ["virt-who"] logger, options = parseOptions() config = Config("env/cmdline", options.virtType, defaults={}, **options) config.checkOptions(logger) manager = Manager.fromOptions(logger, options, config) self.assertTrue(isinstance(manager, Satellite))
def test_satellite_config_cmd(self): os.environ = {} sys.argv = [ "virt-who", "--satellite", "--satellite-server=sat.example.com", "--satellite-username=username", "--satellite-password=password", "--libvirt" ] logger, options = parseOptions() config = Config("env/cmdline", options.virtType, defaults={}, **options) config.checkOptions(logger) manager = Manager.fromOptions(logger, options, config) self.assertTrue(isinstance(manager, Satellite))
def test_satellite_config_file(self): config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt sat_server=sat.example.com """) config_manager = ConfigManager(self.logger, config_dir) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] manager = Manager.fromOptions(self.logger, MagicMock(), config) self.assertTrue(isinstance(manager, Satellite)) self.assertEqual(config.sat_server, 'sat.example.com')
def test_hypervisorCheckIn(self, create_from_file, connection): self.prepare(create_from_file, connection) config, d = self.create_fake_config('test', **self.default_config_args) d['owner'] = 'OWNER' manager = Manager.from_config(self.logger, config) # TODO additional mocking. Specifically, mock out the host_guest_report and config... self.host_guest_report._config = config manager.hypervisorCheckIn(self.host_guest_report) manager.connection.hypervisorCheckIn.assert_called_with( d['owner'], '', dict( (host.hypervisorId, [guest.toDict() for guest in host.guestIds]) for host in self.host_guest_report.association['hypervisors']), options=ANY)
def test_satellite_config_cmd(self): os.environ = {} sys.argv = ["virt-who", "--satellite", "--satellite-server=sat.example.com", "--satellite-username=username", "--satellite-password=password", "--libvirt"] logger, effective_config = parse_options() config_manager = DestinationToSourceMapper(effective_config) # Again there should only be one config parsed out (and one dest) self.assertEqual(len(config_manager.configs), 1) self.assertEqual(len(config_manager.dests), 1) dest_info = config_manager.dests.pop() self.assertTrue(isinstance(dest_info, Satellite5DestinationInfo)) manager = Manager.fromInfo(self.logger, effective_config, dest_info) self.assertTrue(isinstance(manager, Satellite))
def test_per_config_options_encrypted(self, can_write): options = Options(None, None, None) options.force_register = True can_write.return_value = True with tempfile.NamedTemporaryFile() as tmp: password.Password.KEYFILE = tmp.name config = Config('test', 'libvirt', sat_server="http://localhost:%s" % TEST_PORT, sat_username='******', sat_encrypted_password=hexlify(password.Password.encrypt('password'))) s = Manager.fromOptions(self.logger, options, config) self.assertTrue(isinstance(s, Satellite)) report = HostGuestAssociationReport(config, self.mapping) result = s.hypervisorCheckIn(report, options) self.assertTrue("failedUpdate" in result) self.assertTrue("created" in result) self.assertTrue("updated" in result)
def test_sm_config_file(self): config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt owner=owner env=env rhsm_hostname=host rhsm_port=8080 rhsm_prefix=prefix rhsm_proxy_hostname=proxy_host rhsm_proxy_port=9090 rhsm_proxy_user=proxy_user rhsm_proxy_password=proxy_password rhsm_insecure=1 rhsm_username=user rhsm_password=passwd rhsm_no_proxy=filter """) config_manager = DestinationToSourceMapper( init_config({}, {}, config_dir=config_dir)) self.assertEqual(len(config_manager.configs), 1) config = dict(config_manager.configs)["test"] manager = Manager.from_config(self.logger, config) self.assertTrue(isinstance(manager, SubscriptionManager)) self.assertEqual(config['rhsm_hostname'], 'host') self.assertEqual(config['rhsm_port'], '8080') manager._connect(config) self.sm.connection.assert_called_with( username='******', password='******', host='host', ssl_port=8080, handler='prefix', proxy_hostname='proxy_host', proxy_port='9090', proxy_user='******', proxy_password='******', no_proxy='filter', insecure='1', correlation_id=manager.correlation_id)
def test_satellite_config_env(self): os.environ = { "VIRTWHO_SATELLITE": '1', "VIRTWHO_SATELLITE_SERVER": 'sat.example.com', "VIRTWHO_SATELLITE_USERNAME": '******', "VIRTWHO_SATELLITE_PASSWORD": '******', "VIRTWHO_LIBVIRT": '1' } sys.argv = ["virt-who"] logger, effective_config = parse_options() config_manager = DestinationToSourceMapper(effective_config) # Again there should only be one config parsed out (and one dest) self.assertEqual(len(config_manager.configs), 1) self.assertEqual(len(config_manager.dests), 1) dest_info = config_manager.dests.pop() self.assertTrue(isinstance(dest_info, Satellite5DestinationInfo)) manager = Manager.fromInfo(self.logger, effective_config, dest_info) self.assertTrue(isinstance(manager, Satellite))
def test_sm_config_file(self): config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt owner=owner env=env rhsm_hostname=host rhsm_port=8080 rhsm_prefix=prefix rhsm_proxy_hostname=proxy_host rhsm_proxy_port=9090 rhsm_proxy_user=proxy_user rhsm_proxy_password=proxy_password rhsm_insecure=1 rhsm_username=user rhsm_password=passwd rhsm_no_proxy=filter """) config_manager = DestinationToSourceMapper(init_config({}, {}, config_dir=config_dir)) self.assertEqual(len(config_manager.configs), 1) config = dict(config_manager.configs)["test"] manager = Manager.from_config(self.logger, config) self.assertTrue(isinstance(manager, SubscriptionManager)) self.assertEqual(config['rhsm_hostname'], 'host') self.assertEqual(config['rhsm_port'], '8080') manager._connect(config) self.sm.connection.assert_called_with( username='******', password='******', host='host', ssl_port=8080, handler='prefix', proxy_hostname='proxy_host', proxy_port='9090', proxy_user='******', proxy_password='******', no_proxy='filter', insecure='1', correlation_id=manager.correlation_id)
def test_per_config_options_encrypted(self, can_write): options = Options(None, None, None) options.force_register = True can_write.return_value = True with tempfile.NamedTemporaryFile() as tmp: password.Password.KEYFILE = tmp.name config = Config('test', 'libvirt', sat_server="http://localhost:%s" % TEST_PORT, sat_username='******', sat_encrypted_password=hexlify( password.Password.encrypt('password'))) s = Manager.fromOptions(self.logger, options, config) self.assertTrue(isinstance(s, Satellite)) report = HostGuestAssociationReport(config, self.mapping) result = s.hypervisorCheckIn(report, options) self.assertTrue("failedUpdate" in result) self.assertTrue("created" in result) self.assertTrue("updated" in result)
def check_sm_connection(self, config): errors = [] try: sm_manager = Manager.fromOptions(self.logger, config, config) sm_manager._connect(config) if self.smType == "sat": if hasattr(sm_manager, 'server_xmlrpc'): server = 'server_xmlrpc' else: server = 'server' session = getattr(sm_manager, server).auth.login(config.sat_username, config.sat_password) getattr(sm_manager, server).auth.logout(session) except Exception as e: if issubclass(e.__class__, ManagerError) or issubclass(e.__class__, ManagerFatalError) or isinstance(e, ConnectionError): errors.append(repr(e)) else: raise e return errors
def test_hypervisorCheckIn(self, create_from_file, connection): self.prepare(create_from_file, connection) config = Config('test', 'libvirt') config.smType = 'sam' manager = Manager.fromOptions(self.logger, self.options, config) self.options.env = "ENV" self.options.owner = "OWNER" manager.hypervisorCheckIn(self.host_guest_report, self.options) manager.connection.hypervisorCheckIn.assert_called_with( self.options.owner, self.options.env, dict( ( host.hypervisorId, [ guest.toDict() for guest in host.guestIds ] ) for host in self.host_guest_report.association['hypervisors']), options=self.options)
def test_hypervisorCheckIn(self, create_from_file, connection): self.prepare(create_from_file, connection) config, d = self.create_fake_config('test', **self.default_config_args) d['owner'] = 'OWNER' manager = Manager.from_config(self.logger, config) # TODO additional mocking. Specifically, mock out the host_guest_report and config... self.host_guest_report._config = config manager.hypervisorCheckIn(self.host_guest_report) manager.connection.hypervisorCheckIn.assert_called_with( d['owner'], '', dict( ( host.hypervisorId, [ guest.toDict() for guest in host.guestIds ] ) for host in self.host_guest_report.association['hypervisors']), options=ANY)
def test_sm_config_file(self, rhsmconnection): config_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, config_dir) with open(os.path.join(config_dir, "test.conf"), "w") as f: f.write(""" [test] type=libvirt rhsm_hostname=host rhsm_port=8080 rhsm_prefix=prefix rhsm_proxy_hostname=proxy_host rhsm_proxy_port=9090 rhsm_proxy_user=proxy_user rhsm_proxy_password=proxy_password rhsm_insecure=1 rhsm_username=user rhsm_password=passwd """) config_manager = ConfigManager(self.logger, config_dir) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0] manager = Manager.fromOptions(self.logger, Mock(), config) self.assertTrue(isinstance(manager, SubscriptionManager)) self.assertEqual(config.rhsm_hostname, 'host') self.assertEqual(config.rhsm_port, '8080') manager._connect(config) rhsmconnection.assert_called_with( username='******', password='******', host='host', ssl_port=8080, handler='prefix', proxy_hostname='proxy_host', proxy_port='9090', proxy_user='******', proxy_password='******', insecure='1')
def test_per_config_options_encrypted(self, can_write): options = Mock() options.force_register = True can_write.return_value = True with tempfile.NamedTemporaryFile() as tmp: password.Password.KEYFILE = tmp.name config_dict = { "sat_server": "http://localhost:%s" % TEST_PORT, "sat_username": "******", "sat_encrypted_password": hexlify(password.Password.encrypt('password')), "type": "libvirt", } config = VirtConfigSection.from_dict(config_dict, 'test', None) config.validate() dests = DestinationToSourceMapper.parse_dests_from_dict(config._values) self.assertEqual(len(dests), 1) dest_info = dests.pop() s = Manager.fromInfo(self.logger, options, dest_info) self.assertTrue(isinstance(s, Satellite)) report = HostGuestAssociationReport(config, self.mapping) result = s.hypervisorCheckIn(report, options) self.assertTrue("failedUpdate" in result) self.assertTrue("created" in result) self.assertTrue("updated" in result)
def __init__(self, logger, config): self.logger = logger self.config = config self.sm_manager = Manager.fromOptions(logger, config, config) self.connection = None
def test_sm_config_env(self): os.environ = {"VIRTWHO_SAM": '1', "VIRTWHO_LIBVIRT": '1'} sys.argv = ["virt-who"] logger, config = parse_options() manager = Manager.from_config(logger, config) self.assertTrue(isinstance(manager, SubscriptionManager))
def _sendGuestAssociation(self, report): manager = Manager.fromOptions(self.logger, self.options, report.config) manager.hypervisorCheckIn(report, self.options)
def _sendGuestList(self, report): manager = Manager.fromOptions(self.logger, self.options, report.config) manager.sendVirtGuests(report, self.options)
def test_sendVirtGuests(self): options = MagicMock() config = Config('test', 'libvirt', sat_server='localhost') manager = Manager.fromOptions(self.logger, options, config) self.assertRaises(ManagerError, manager.sendVirtGuests, self.domain_report)
def check_report_state(self, report): ''' Check state of one report that is being processed on server. ''' manager = Manager.fromOptions(self.logger, self.options, report.config) manager.check_report_state(report)
def test_sendVirtGuests(self): config = VirtConfigSection.from_dict({'type': 'libvirt', 'sat_server': 'localhost'}, 'test', None) manager = Manager.from_config(self.logger, config) self.assertRaises(ManagerError, manager.sendVirtGuests, self.domain_report)