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'}, '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 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_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)