def test_status_error(self): config_values = { 'type': 'virt', 'server': 'localhost', 'username': '******', 'password': '******', 'owner': 'owner', } config = VirtConfigSection('test', None) config.update(**config_values) self.virt = Virt(self.logger, config, None, interval=60) # No dest given here self.virt.status = True self.virt._send_data = Mock() self.virt._run = Mock( side_effect=VirtError('unable to connect to source')) self.run_once() self.virt._send_data.assert_called_once_with(data_to_send=ANY) self.assertTrue( isinstance( self.virt._send_data.mock_calls[0].kwargs['data_to_send'], StatusReport)) self.assertEqual( self.virt._send_data.mock_calls[0].kwargs['data_to_send']. data['source']['message'], 'unable to connect to source.')
def init_virt_config_section(self): """ Method executed before each unit test """ self.virt_config = VirtConfigSection('test_libvirt', None) # We need to set values using this way, because we need # to trigger __setitem__ of virt_config for key, value in LIBVIRT_SECTION_VALUES.items(): self.virt_config[key] = value
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 test_hypervisorCheckInAsync(self, rhsmconnection): owner = 'owner' env = 'env' config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'owner': owner, 'env': env }, 'test', None) # Ensure we try out the new API rhsmconnection.return_value.has_capability.return_value = True self.sm.logger = MagicMock() report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) expected = { 'hypervisors': [h.toDict() for h in self.mapping['hypervisors']] } self.sm.connection.hypervisorCheckIn.assert_called_with('owner', 'env', expected, options=None) self.sm.logger.warning.assert_called_with( "The hypervisor id '123' is assigned to 2 different systems. " "Only one will be recorded at the server.") self.sm.connection.return_value.has_capability = MagicMock( return_value=False)
def setUpClass(cls, rhsmcert, rhsmconfig): super(TestSubscriptionManager, cls).setUpClass() config = VirtConfigSection.from_dict({'type': 'libvirt'}, 'test', None) cls.tempdir = tempfile.mkdtemp() with open(os.path.join(cls.tempdir, 'cert.pem'), 'w') as f: f.write("\n") rhsmcert.return_value.subject = {'CN': 123} rhsmconfig.return_value.get.side_effect = lambda group, key: { 'consumerCertDir': cls.tempdir }.get(key, DEFAULT) cls.sm = SubscriptionManager(cls.logger, config) cls.sm.connection = MagicMock() cls.sm.connection.return_value.has_capability = MagicMock( return_value=False) cls.sm.connection.return_value.getConsumer = MagicMock( return_value={'environment': { 'name': 'env' }}) cls.sm.connection.return_value.getOwner = MagicMock( return_value={'key': 'owner'}) cls.uep_connection = patch('rhsm.connection.UEPConnection', cls.sm.connection) cls.uep_connection.start() cls.sm.cert_uuid = 123
def test_job_status(self, rhsmconnection): rhsmconnection.return_value.has_capability.return_value = True config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'owner': 'owner' }, 'test', None) report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) rhsmconnection.return_value.getJob.return_value = { 'state': 'RUNNING', } self.sm.check_report_state(report) self.assertEqual(report.state, AbstractVirtReport.STATE_PROCESSING) def host(_host): return {'uuid': _host} # self.sm.connection.return_value.getJob.return_value = { rhsmconnection.return_value.getJob.return_value = { 'state': 'FINISHED', 'resultData': { 'failedUpdate': ["failed"], 'updated': [host('123')], 'created': [host('456')], 'unchanged': [host('789')] } } self.sm.logger = MagicMock() self.sm.check_report_state(report) # calls: authenticating + checking job status + 1 line about the number of unchanged self.assertEqual(self.sm.logger.debug.call_count, 3) self.assertEqual(report.state, AbstractVirtReport.STATE_FINISHED)
def test_job_status_with_status_command(self, rhsmconnection): rhsmconnection.return_value.has_capability.return_value = True config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'owner': 'owner' }, 'test', None) report = StatusReport(config) rhsmconnection.return_value.getJob.return_value = { 'state': 'RUNNING', } self.sm.check_report_state(report, status_call=True) self.assertEqual(report.state, AbstractVirtReport.STATE_PROCESSING) self.assertEqual(report.last_job_status, 'RUNNING') rhsmconnection.return_value.getJob.return_value = { 'state': 'FINISHED', 'resultData': { 'failedUpdate': ["failed"], 'updated': [{'uuid', '123'}], 'created': [{'uuid' '456'}], 'unchanged': [{'uuid', '789'}] } } self.sm.logger = MagicMock() self.sm.check_report_state(report, status_call=True) # calls: authenticating + checking job status + 1 line about the number of unchanged self.assertEqual(self.sm.logger.debug.call_count, 3) self.assertEqual(report.state, AbstractVirtReport.STATE_FINISHED) self.assertEqual(report.last_job_status, 'FINISHED')
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_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_sendVirtGuests(self): config = VirtConfigSection.from_dict({'type': 'libvirt'}, 'test', None) report = DomainListReport(config, self.guestList, self.hypervisor_id) self.sm.sendVirtGuests(report) self.sm.connection.updateConsumer.assert_called_with( 123, guest_uuids=[g.toDict() for g in self.guestList], hypervisor_id=self.hypervisor_id)
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 = 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_hypervisorHeartbeat(self, rhsmconnection): owner = 'owner' config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'owner': owner }, 'test', None) # Ensure we try out the new API rhsmconnection.return_value.has_capability.return_value = True self.sm.logger = MagicMock() self.sm.hypervisorHeartbeat(config, options=None) self.sm.connection.hypervisorHeartbeat.assert_called_with(owner, None)
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_hypervisorCheckIn(self): owner = "owner" config = VirtConfigSection.from_dict({'type': 'libvirt', 'owner': owner}, 'test', None) # Ensure the data takes the proper for for the old API self.sm.connection.return_value.has_capability = MagicMock(return_value=False) self.sm.logger = MagicMock() report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) self.sm.connection.hypervisorCheckIn.assert_called_with( owner, '', dict((host.hypervisorId, [g.toDict() for g in host.guestIds]) for host in self.mapping['hypervisors']), options=None) self.sm.logger.warning.assert_called_with("The hypervisor id '123' is assigned to 2 different systems. " "Only one will be recorded at the server.")
def filter_hosts(self, filter_something, filter_type=''): 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=esx server=does.not.exist username=username password=password owner=owner env=env {filter_something} {filter_type} """.format(filter_something=filter_something, filter_type=filter_type)) conf = parse_file(os.path.join(config_dir, "test.conf")) test_conf_values = conf.pop('test') effective_config = EffectiveConfig() effective_config['test'] = VirtConfigSection.from_dict( test_conf_values, 'test', effective_config ) effective_config.validate() config_manager = DestinationToSourceMapper(effective_config) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0][1] included_hypervisor = Hypervisor('12345', guestIds=[ Guest('guest-2', xvirt.CONFIG_TYPE, Guest.STATE_RUNNING), ]) excluded_hypervisor = Hypervisor('00000', guestIds=[ Guest('guest-1', xvirt.CONFIG_TYPE, Guest.STATE_RUNNING), ]) assoc = { 'hypervisors': [ excluded_hypervisor, included_hypervisor, ] } report = HostGuestAssociationReport(config, assoc) assert report.association == { 'hypervisors': [ included_hypervisor ] }
def filter_hosts(self, filter_something, filter_type=''): 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=esx server=does.not.exist username=username password=password owner=owner env=env {filter_something} {filter_type} """.format(filter_something=filter_something, filter_type=filter_type)) conf = parse_file(os.path.join(config_dir, "test.conf")) test_conf_values = conf.pop('test') effective_config = EffectiveConfig() effective_config['test'] = VirtConfigSection.from_dict( test_conf_values, 'test', effective_config) effective_config.validate() config_manager = DestinationToSourceMapper(effective_config) self.assertEqual(len(config_manager.configs), 1) config = config_manager.configs[0][1] included_hypervisor = Hypervisor('12345', guestIds=[ Guest('guest-2', xvirt.CONFIG_TYPE, Guest.STATE_RUNNING), ]) excluded_hypervisor = Hypervisor('00000', guestIds=[ Guest('guest-1', xvirt.CONFIG_TYPE, Guest.STATE_RUNNING), ]) assoc = { 'hypervisors': [ excluded_hypervisor, included_hypervisor, ] } report = HostGuestAssociationReport(config, assoc) assert report.association == {'hypervisors': [included_hypervisor]}
def setUpClass(cls, rhsmcert, rhsmconfig): super(TestSubscriptionManager, cls).setUpClass() config = VirtConfigSection.from_dict({'type': 'libvirt'}, 'test', None) cls.tempdir = tempfile.mkdtemp() with open(os.path.join(cls.tempdir, 'cert.pem'), 'w') as f: f.write("\n") rhsmcert.return_value.subject = {'CN': 123} rhsmconfig.return_value.get.side_effect = lambda group, key: {'consumerCertDir': cls.tempdir}.get(key, DEFAULT) cls.sm = SubscriptionManager(cls.logger, config) cls.sm.connection = MagicMock() cls.sm.connection.return_value.has_capability = MagicMock(return_value=False) cls.sm.connection.return_value.getConsumer = MagicMock(return_value={}) cls.sm.connection.return_value.getOwner = MagicMock(return_value={'key': 'owner'}) cls.uep_connection = patch('rhsm.connection.UEPConnection', cls.sm.connection) cls.uep_connection.start() cls.sm.cert_uuid = 123
def test_hypervisorCheckInAsync(self, rhsmconnection): owner = 'owner' config = VirtConfigSection.from_dict({'type': 'libvirt', 'owner': owner}, 'test', None) # Ensure we try out the new API rhsmconnection.return_value.has_capability.return_value = True self.sm.logger = MagicMock() report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) expected = {'hypervisors': [h.toDict() for h in self.mapping['hypervisors']]} self.sm.connection.hypervisorCheckIn.assert_called_with( 'owner', '', expected, options=None ) self.sm.logger.warning.assert_called_with("The hypervisor id '123' is assigned to 2 different systems. " "Only one will be recorded at the server.") self.sm.connection.return_value.has_capability = MagicMock(return_value=False)
def test_hypervisorCheckIn(self): owner = "owner" env = "env" config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'owner': owner, 'env': env }, 'test', None) # Ensure the data takes the proper for for the old API self.sm.connection.return_value.has_capability = MagicMock( return_value=False) report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) self.sm.connection.hypervisorCheckIn.assert_called_with( owner, env, dict((host.hypervisorId, [g.toDict() for g in host.guestIds]) for host in self.mapping['hypervisors']), options=None)
class TestManager(TestBase): """ Test of all available subscription managers. """ guest1 = Guest('9c927368-e888-43b4-9cdb-91b10431b258', xvirt.CONFIG_TYPE, Guest.STATE_RUNNING) guest2 = Guest('d5ffceb5-f79d-41be-a4c1-204f836e144a', xvirt.CONFIG_TYPE, Guest.STATE_SHUTOFF) guestInfo = [guest1] hypervisor_id = "HYPERVISOR_ID" config = VirtConfigSection.from_dict({ 'type': 'libvirt', 'owner': 'OWNER' }, 'test', None) host_guest_report = HostGuestAssociationReport( config, { 'hypervisors': [ Hypervisor('9c927368-e888-43b4-9cdb-91b10431b258', []), Hypervisor('ad58b739-5288-4cbc-a984-bd771612d670', [guest1, guest2]) ] }) domain_report = DomainListReport(config, [guest1], hypervisor_id)
def test_hypervisorCheckIn(self): owner = "owner" config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'owner': owner }, 'test', None) # Ensure the data takes the proper for for the old API self.sm.connection.return_value.has_capability = MagicMock( return_value=False) self.sm.logger = MagicMock() report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) self.sm.connection.hypervisorCheckIn.assert_called_with( owner, '', dict((host.hypervisorId, [g.toDict() for g in host.guestIds]) for host in self.mapping['hypervisors']), options=None) self.sm.logger.warning.assert_called_with( "The hypervisor id '123' is assigned to 2 different systems. " "Only one will be recorded at the server.")
def test_hypervisorCheckInAsync(self, rhsmconnection): owner = 'owner' env = 'env' config = VirtConfigSection.from_dict( { 'type': 'libvirt', 'owner': owner, 'env': env }, 'test', None) # Ensure we try out the new API rhsmconnection.return_value.has_capability.return_value = True report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) expected = { 'hypervisors': [h.toDict() for h in self.mapping['hypervisors']] } self.sm.connection.hypervisorCheckIn.assert_called_with('owner', 'env', expected, options=None) self.sm.connection.return_value.has_capability = MagicMock( return_value=False)
def test_job_status(self, rhsmconnection): rhsmconnection.return_value.has_capability.return_value = True config = VirtConfigSection.from_dict({'type': 'libvirt', 'owner': 'owner'}, 'test', None) report = HostGuestAssociationReport(config, self.mapping) self.sm.hypervisorCheckIn(report) rhsmconnection.return_value.getJob.return_value = { 'state': 'RUNNING', } self.sm.check_report_state(report) self.assertEqual(report.state, AbstractVirtReport.STATE_PROCESSING) def host(_host): return { 'uuid': _host } # self.sm.connection.return_value.getJob.return_value = { rhsmconnection.return_value.getJob.return_value = { 'state': 'FINISHED', 'resultData': { 'failedUpdate': ["failed"], 'updated': [ host('123') ], 'created': [ host('456') ], 'unchanged': [ host('789') ] } } self.sm.logger = MagicMock() self.sm.check_report_state(report) # calls: authenticating + checking job status + 1 line about the number of unchanged self.assertEqual(self.sm.logger.debug.call_count, 3) self.assertEqual(report.state, AbstractVirtReport.STATE_FINISHED)
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)
class TestVirtConfigSection(TestBase): """ Test base for testing class VirtConfigSection """ def __init__(self, *args, **kwargs): super(TestVirtConfigSection, self).__init__(*args, **kwargs) self.virt_config = None def init_virt_config_section(self): """ Method executed before each unit test """ self.virt_config = VirtConfigSection('test_libvirt', None) # We need to set values using this way, because we need # to trigger __setitem__ of virt_config for key, value in LIBVIRT_SECTION_VALUES.items(): self.virt_config[key] = value def test_validate_virt_type(self): """ Test validation of supported types of virtualization backends """ self.init_virt_config_section() test_virt_types = list(VW_TYPES[:]) test_virt_types.extend(['vmware,' 'kvm']) for virt_type in test_virt_types: self.virt_config['type'] = virt_type result = self.virt_config._validate_virt_type('type') if virt_type not in VW_TYPES: self.assertIsNotNone(result) else: self.assertIsNone(result) value = self.virt_config.get('type') self.assertEqual(value, virt_type) def test_validate_missing_virt_type(self): """ Test validation of missing type of virtualization backend """ self.init_virt_config_section() del self.virt_config['type'] self.virt_config.validate() virt_type = self.virt_config.get('type') self.assertEqual(virt_type, 'libvirt') def test_validate_wrong_virt_type(self): """ Test validation of wrong type of virtualization backend """ self.init_virt_config_section() self.virt_config['type'] = 'qemu' result = self.virt_config._validate_virt_type('type') self.assertIsNotNone(result) self.virt_config.validate() virt_type = self.virt_config.get('type') self.assertEqual(virt_type, 'libvirt') def test_validate_unencrypted_password(self): """ Test of validation of password that is not encrypted """ self.init_virt_config_section() result = self.virt_config._validate_unencrypted_password('password') self.assertIsNone(result) def test_validate_unicode_unencrypted_password(self): """ Test of validation of password that is not encrypted and it contains some UTF-8 string. """ self.init_virt_config_section() self.virt_config['password'] = '******' result = self.virt_config._validate_unencrypted_password('password') self.assertIsNone(result) def mock_pwd_file(self): # Backup previous values self.old_key_file = Password.KEYFILE self.old_can_write = Password._can_write # Mock pwd file f, filename = tempfile.mkstemp() self.addCleanup(os.unlink, filename) Password.KEYFILE = filename Password._can_write = MagicMock(return_value=True) def unmock_pwd_file(self): # Restore pwd file from backup Password.KEYFILE = self.old_key_file Password._can_write = self.old_can_write def test_validate_encrypted_password(self): """ Test of validation of encrypted password """ self.init_virt_config_section() self.mock_pwd_file() # Safe current password password = self.virt_config['password'] # Delete unencrypted password first del self.virt_config['password'] # Set up encrypted password self.virt_config['encrypted_password'] = hexlify( Password.encrypt(password)) # Do own testing here result = self.virt_config._validate_encrypted_password( 'encrypted_password') self.assertIsNone(result) decrypted_password = self.virt_config.get('password') self.assertEqual(password, decrypted_password) self.unmock_pwd_file() def test_validate_missing_encrypted_password(self): """ Test of validation of missing encrypted password """ self.init_virt_config_section() result = self.virt_config._validate_encrypted_password( 'encrypted_password') self.assertIsNotNone(result) def test_validate_wrong_encrypted_password(self): """ Test of validation of corrupted encrypted password """ self.init_virt_config_section() self.mock_pwd_file() # Safe current password password = self.virt_config['password'] # Delete unencrypted password first del self.virt_config['password'] # Set up corrupted encrypted password encrypted_pwd = Password.encrypt(password) corrupted_encrypted_pwd = b'S' + encrypted_pwd[1:] self.virt_config['encrypted_password'] = hexlify( corrupted_encrypted_pwd) # Do own testing here result = self.virt_config._validate_encrypted_password( 'encrypted_password') self.assertIsNone(result) decrypted_password = self.virt_config.get('password') self.assertNotEqual(password, decrypted_password) self.unmock_pwd_file() def test_validate_correct_username(self): """ Test of validation of username (it has to include only latin1 characters) """ self.init_virt_config_section() result = self.virt_config._validate_username('username') self.assertIsNone(result) def test_validate_missing_username(self): """ Test of validation of missing username """ self.init_virt_config_section() del self.virt_config['username'] result = self.virt_config._validate_username('username') self.assertIsNotNone(result) def test_validate_wrong_username(self): """ Test validation of wrong username (containing e.g. UTF-8 string) """ self.init_virt_config_section() # First, change username to something exotic ;-) self.virt_config['username'] = '******' result = self.virt_config._validate_username('username') self.assertIsNotNone(result) def test_validate_server(self): """ Test validation of server """ self.init_virt_config_section() result = self.virt_config._validate_server('server') self.assertIsNone(result) def test_validate_missing_server(self): """ Test validation of missing server for some virt backends """ self.init_virt_config_section() # These backends require server option in configuration virt_backends_requiring_server = ('esx', 'rhevm', 'hyperv', 'xen') # Delete server option del self.virt_config['server'] # Test all of them for virt_type in virt_backends_requiring_server: self.virt_config['type'] = virt_type result = self.virt_config._validate_server('server') self.assertIsNotNone(result) def test_validate_missing_server_not_critical(self): """ Test validation of missing server for some virt backends which do not need server option to exist. """ self.init_virt_config_section() # These backends do not require server option in configuration virt_backends_not_requiring_server = ('libvirt', 'vdsm', 'fake') # Delete server option del self.virt_config['server'] # Test all of vm backend types for virt_type in virt_backends_not_requiring_server: self.virt_config['type'] = virt_type result = self.virt_config._validate_server('server') self.assertIsNone(result) def test_validate_environment(self): """ Test validation of env option """ self.init_virt_config_section() result = self.virt_config._validate_env('env') self.assertIsNone(result) def test_validate_owner(self): """ Test validation of owner option """ self.init_virt_config_section() result = self.virt_config._validate_owner('owner') self.assertIsNone(result) def test_validate_filter(self): """ Test validation of host filter """ self.init_virt_config_section() result = self.virt_config._validate_filter('filter_hosts') self.assertIsNone(result) def test_validate_filter_hypervisor_id_hostname(self): """ Test validation of host filter with hypervisor_id = hostname (default is uuid) """ self.init_virt_config_section() self.virt_config['hypervisor_id'] = 'hostname' self.virt_config['filter_hosts'] = '*.example.com, www.company.com' self.virt_config['exclude_hosts'] = [ 'foo.bar.com', 'pub.org', 'foo.net' ] result = self.virt_config._validate_filter('filter_hosts') self.assertIsNone(result) def test_validate_wrong_filter_hypervisor_id_hostname(self): """ Test validation of host filter with hypervisor_id = hostname and filter containing some UUID. Some warning should be returned in this case """ self.init_virt_config_section() self.virt_config['hypervisor_id'] = 'hostname' self.virt_config['filter_hosts'] = [ '*.example.com', 'www.company.com', '118f4087-7535-4187-8bc2-8e07fc676156' ] self.virt_config['exclude_hosts'] = [ '446e2e7d-825a-5ca0-8cee-13ae9f56c903', '4a9d7c0f-7058-4afd-8d06-42661872b48c', ] result = self.virt_config._validate_filter('filter_hosts') self.assertIsNotNone(result) def test_validate_wrong_filter_hypervisor_id_hwuuid(self): """ Test validation of host filter with hypervisor_id = hwuuid and filter containing some UUID. Some warning should be returned in this case """ self.init_virt_config_section() self.virt_config['type'] = 'esx' self.virt_config['hypervisor_id'] = 'hwuuid' self.virt_config['filter_hosts'] = [ 'host-9', 'host-14', '118f4087-7535-4187-8bc2-8e07fc676156' ] self.virt_config['exclude_hosts'] = [ '446e2e7d-825a-5ca0-8cee-13ae9f56c903', '4a9d7c0f-7058-4afd-8d06-42661872b48c', ] result = self.virt_config._validate_filter('filter_hosts') self.assertIsNotNone(result)
class TestVirtConfigSection(TestBase): """ Test base for testing class VirtConfigSection """ def __init__(self, *args, **kwargs): super(TestVirtConfigSection, self).__init__(*args, **kwargs) self.virt_config = None def init_virt_config_section(self): """ Method executed before each unit test """ self.virt_config = VirtConfigSection('test_libvirt', None) # We need to set values using this way, because we need # to trigger __setitem__ of virt_config for key, value in LIBVIRT_SECTION_VALUES.items(): self.virt_config[key] = value def test_validate_virt_type(self): """ Test validation of supported types of virtualization backends """ self.init_virt_config_section() test_virt_types = list(VW_TYPES[:]) test_virt_types.extend(['vmware,' 'kvm']) for virt_type in test_virt_types: self.virt_config['type'] = virt_type result = self.virt_config._validate_virt_type('type') if virt_type not in VW_TYPES: self.assertIsNotNone(result) else: self.assertIsNone(result) value = self.virt_config.get('type') self.assertEqual(value, virt_type) def test_validate_missing_virt_type(self): """ Test validation of missing type of virtualization backend """ self.init_virt_config_section() del self.virt_config['type'] self.virt_config.validate() virt_type = self.virt_config.get('type') self.assertEqual(virt_type, 'libvirt') def test_validate_wrong_virt_type(self): """ Test validation of wrong type of virtualization backend """ self.init_virt_config_section() self.virt_config['type'] = 'qemu' result = self.virt_config._validate_virt_type('type') self.assertIsNotNone(result) self.virt_config.validate() virt_type = self.virt_config.get('type') self.assertEqual(virt_type, 'libvirt') def test_validate_unencrypted_password(self): """ Test of validation of password that is not encrypted """ self.init_virt_config_section() result = self.virt_config._validate_unencrypted_password('password') self.assertIsNone(result) def test_validate_unicode_unencrypted_password(self): """ Test of validation of password that is not encrypted and it contains some UTF-8 string. """ self.init_virt_config_section() self.virt_config['password'] = '******' result = self.virt_config._validate_unencrypted_password('password') self.assertIsNone(result) def mock_pwd_file(self): # Backup previous values self.old_key_file = Password.KEYFILE self.old_can_write = Password._can_write # Mock pwd file f, filename = tempfile.mkstemp() self.addCleanup(os.unlink, filename) Password.KEYFILE = filename Password._can_write = MagicMock(return_value=True) def unmock_pwd_file(self): # Restore pwd file from backup Password.KEYFILE = self.old_key_file Password._can_write = self.old_can_write def test_validate_encrypted_password(self): """ Test of validation of encrypted password """ self.init_virt_config_section() self.mock_pwd_file() # Safe current password password = self.virt_config['password'] # Delete unencrypted password first del self.virt_config['password'] # Set up encrypted password self.virt_config['encrypted_password'] = hexlify(Password.encrypt(password)) # Do own testing here result = self.virt_config._validate_encrypted_password('encrypted_password') self.assertIsNone(result) decrypted_password = self.virt_config.get('password') self.assertEqual(password, decrypted_password) self.unmock_pwd_file() def test_validate_missing_encrypted_password(self): """ Test of validation of missing encrypted password """ self.init_virt_config_section() result = self.virt_config._validate_encrypted_password('encrypted_password') self.assertIsNotNone(result) def test_validate_wrong_encrypted_password(self): """ Test of validation of corrupted encrypted password """ self.init_virt_config_section() self.mock_pwd_file() # Safe current password password = self.virt_config['password'] # Delete unencrypted password first del self.virt_config['password'] # Set up corrupted encrypted password encrypted_pwd = Password.encrypt(password) corrupted_encrypted_pwd = b'S' + encrypted_pwd[1:] self.virt_config['encrypted_password'] = hexlify(corrupted_encrypted_pwd) # Do own testing here result = self.virt_config._validate_encrypted_password('encrypted_password') self.assertIsNone(result) decrypted_password = self.virt_config.get('password') self.assertNotEqual(password, decrypted_password) self.unmock_pwd_file() def test_validate_correct_username(self): """ Test of validation of username (it has to include only latin1 characters) """ self.init_virt_config_section() result = self.virt_config._validate_username('username') self.assertIsNone(result) def test_validate_missing_username(self): """ Test of validation of missing username """ self.init_virt_config_section() del self.virt_config['username'] result = self.virt_config._validate_username('username') self.assertIsNotNone(result) def test_validate_wrong_username(self): """ Test validation of wrong username (containing e.g. UTF-8 string) """ self.init_virt_config_section() # First, change username to something exotic ;-) self.virt_config['username'] = '******' result = self.virt_config._validate_username('username') self.assertIsNotNone(result) def test_validate_server(self): """ Test validation of server """ self.init_virt_config_section() result = self.virt_config._validate_server('server') self.assertIsNone(result) def test_validate_missing_server(self): """ Test validation of missing server for some virt backends """ self.init_virt_config_section() # These backends require server option in configuration virt_backends_requiring_server = ('esx', 'rhevm', 'hyperv', 'xen') # Delete server option del self.virt_config['server'] # Test all of them for virt_type in virt_backends_requiring_server: self.virt_config['type'] = virt_type result = self.virt_config._validate_server('server') self.assertIsNotNone(result) def test_validate_missing_server_not_critical(self): """ Test validation of missing server for some virt backends which do not need server option to exist. """ self.init_virt_config_section() # These backends do not require server option in configuration virt_backends_not_requiring_server = ('libvirt', 'vdsm', 'fake') # Delete server option del self.virt_config['server'] # Test all of vm backend types for virt_type in virt_backends_not_requiring_server: self.virt_config['type'] = virt_type result = self.virt_config._validate_server('server') self.assertIsNone(result) def test_validate_environment(self): """ Test validation of env option """ self.init_virt_config_section() result = self.virt_config._validate_env('env') self.assertIsNone(result) def test_validate_owner(self): """ Test validation of owner option """ self.init_virt_config_section() result = self.virt_config._validate_owner('owner') self.assertIsNone(result) def test_validate_filter(self): """ Test validation of host filter """ self.init_virt_config_section() result = self.virt_config._validate_filter('filter_hosts') self.assertIsNone(result) def test_validate_missing_filter_type(self): """ Test validation of missing filter type """ self.init_virt_config_section() del self.virt_config['filter_type'] result = self.virt_config._validate_filter('filter_hosts') self.assertIsNotNone(result) def test_validate_wrong_filter_type(self): """ Test validation of wrong filter type """ self.init_virt_config_section() self.virt_config['filter_type'] = 'not_supported_filter_type' result = self.virt_config._validate_filter_type('filter_type') self.assertIsNotNone(result) def test_validate_regex_filter_type(self): """ Test validation of regex filter type """ self.init_virt_config_section() self.virt_config['filter_type'] = 'regex' result = self.virt_config._validate_filter_type('filter_type') self.assertIsNone(result) def test_validate_filter_hypervisor_id_hostname(self): """ Test validation of host filter with hypervisor_id = hostname (default is uuid) """ self.init_virt_config_section() self.virt_config['hypervisor_id'] = 'hostname' self.virt_config['filter_hosts'] = '*.example.com, www.company.com' self.virt_config['exclude_hosts'] = ['foo.bar.com', 'pub.org', 'foo.net'] result = self.virt_config._validate_filter('filter_hosts') self.assertIsNone(result) def test_validate_wrong_filter_hypervisor_id_hostname(self): """ Test validation of host filter with hypervisor_id = hostname and filter containing some UUID. Some warning should be returned in this case """ self.init_virt_config_section() self.virt_config['hypervisor_id'] = 'hostname' self.virt_config['filter_hosts'] = [ '*.example.com', 'www.company.com', '118f4087-7535-4187-8bc2-8e07fc676156' ] self.virt_config['exclude_hosts'] = [ '446e2e7d-825a-5ca0-8cee-13ae9f56c903', '4a9d7c0f-7058-4afd-8d06-42661872b48c', ] result = self.virt_config._validate_filter('filter_hosts') self.assertIsNotNone(result) def test_validate_wrong_filter_hypervisor_id_hwuuid(self): """ Test validation of host filter with hypervisor_id = hwuuid and filter containing some UUID. Some warning should be returned in this case """ self.init_virt_config_section() self.virt_config['type'] = 'esx' self.virt_config['hypervisor_id'] = 'hwuuid' self.virt_config['filter_hosts'] = [ 'host-9', 'host-14', '118f4087-7535-4187-8bc2-8e07fc676156' ] self.virt_config['exclude_hosts'] = [ '446e2e7d-825a-5ca0-8cee-13ae9f56c903', '4a9d7c0f-7058-4afd-8d06-42661872b48c', ] result = self.virt_config._validate_filter('filter_hosts') self.assertIsNotNone(result) def test_validate_wrong_values_in_encrypted_password(self): """ Test of validation of corrupted encrypted password """ self.init_virt_config_section() self.mock_pwd_file() # Safe current password password = self.virt_config['password'] # Delete unencrypted password first del self.virt_config['password'] # Set up corrupted encrypted password self.virt_config['encrypted_password'] = '******' # Do own testing here result = self.virt_config._validate_encrypted_password('encrypted_password') self.assertIsNotNone(result) self.unmock_pwd_file()
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)