def test_legacy_source_image(self):
for legacy, new in zip(self.legacy_mapping_source_image,
self.new_mapping_source_image):
if new['destination_type'] == 'volume':
self.assertThat(legacy, matchers.IsSubDictOf(new.legacy()))
else:
self.assertRaises(exception.InvalidBDMForLegacy, new.legacy)
def test_from_api(self):
for api, new in zip(self.api_mapping, self.new_mapping):
new['connection_info'] = None
if new['snapshot_id']:
new['volume_id'] = None
self.assertThat(block_device.BlockDeviceDict.from_api(api),
matchers.IsSubDictOf(new))
def test_from_legacy_mapping(self):
def _get_image_bdms(bdms):
return [bdm for bdm in bdms if bdm['source_type'] == 'image']
def _get_bootable_bdms(bdms):
return [bdm for bdm in bdms if bdm['boot_index'] >= 0]
new_no_img = block_device.from_legacy_mapping(self.legacy_mapping)
self.assertEquals(len(_get_image_bdms(new_no_img)), 0)
for new, expected in zip(new_no_img, self.new_mapping):
self.assertThat(new, matchers.IsSubDictOf(expected))
new_with_img = block_device.from_legacy_mapping(
self.legacy_mapping, 'fake_image_ref')
image_bdms = _get_image_bdms(new_with_img)
boot_bdms = _get_bootable_bdms(new_with_img)
self.assertEquals(len(image_bdms), 1)
self.assertEquals(len(boot_bdms), 1)
self.assertEquals(image_bdms[0]['boot_index'], 0)
self.assertEquals(boot_bdms[0]['source_type'], 'image')
new_with_img_and_root = block_device.from_legacy_mapping(
self.legacy_mapping, 'fake_image_ref', 'sda1')
image_bdms = _get_image_bdms(new_with_img_and_root)
boot_bdms = _get_bootable_bdms(new_with_img_and_root)
self.assertEquals(len(image_bdms), 0)
self.assertEquals(len(boot_bdms), 1)
self.assertEquals(boot_bdms[0]['boot_index'], 0)
self.assertEquals(boot_bdms[0]['source_type'], 'volume')
class TestDictMatches(testtools.TestCase, helpers.TestMatchersInterface):
matches_matcher = matchers.IsSubDictOf(
{'foo': 'bar', 'baz': 'DONTCARE',
'cat': {'tabby': True, 'fluffy': False}}
)
matches_matches = [
{'foo': 'bar', 'baz': 'noox', 'cat': {'tabby': True, 'fluffy': False}},
{'foo': 'bar', 'baz': 'quux'}
]
matches_mismatches = [
{'foo': 'bop', 'baz': 'qux',
'cat': {'tabby': True, 'fluffy': False}},
{'foo': 'bar', 'baz': 'quux',
'cat': {'tabby': True, 'fluffy': True}},
{'foo': 'bar', 'cat': {'tabby': True, 'fluffy': False}, 'dog': None},
]
str_examples = [
("IsSubDictOf({'foo': 'bar', 'baz': 'DONTCARE',"
" 'cat': {'fluffy': False, 'tabby': True}})",
matches_matcher),
]
describe_examples = [
("Dictionaries do not match at fluffy. d1: False d2: True",
{'foo': 'bar', 'baz': 'quux',
'cat': {'tabby': True, 'fluffy': True}}, matches_matcher),
("Dictionaries do not match at foo. d1: bar d2: bop",
{'foo': 'bop', 'baz': 'quux',
'cat': {'tabby': True, 'fluffy': False}}, matches_matcher),
]
def _test_network_api(self, method, rpc_method, **kwargs):
ctxt = context.RequestContext('fake_user', 'fake_project')
rpcapi = network_rpcapi.NetworkAPI()
expected_retval = 'foo' if method == 'call' else None
expected_version = kwargs.pop('version', rpcapi.BASE_RPC_API_VERSION)
expected_topic = CONF.network_topic
expected_msg = rpcapi.make_msg(method, **kwargs)
if 'source_compute' in expected_msg['args']:
# Fix up for migrate_instance_* calls.
args = expected_msg['args']
args['source'] = args.pop('source_compute')
args['dest'] = args.pop('dest_compute')
targeted_methods = [
'lease_fixed_ip', 'release_fixed_ip', 'rpc_setup_network_on_host',
'_rpc_allocate_fixed_ip', 'deallocate_fixed_ip', 'update_dns',
'_associate_floating_ip', '_disassociate_floating_ip',
'lease_fixed_ip', 'release_fixed_ip', 'migrate_instance_start',
'migrate_instance_finish',
'allocate_for_instance', 'deallocate_for_instance',
]
if method in targeted_methods and 'host' in kwargs:
if method not in ['allocate_for_instance',
'deallocate_for_instance',
'deallocate_fixed_ip']:
del expected_msg['args']['host']
host = kwargs['host']
if CONF.multi_host:
expected_topic = rpc.queue_get_for(ctxt, CONF.network_topic,
host)
expected_msg['version'] = expected_version
self.fake_args = None
self.fake_kwargs = None
def _fake_rpc_method(*args, **kwargs):
self.fake_args = args
self.fake_kwargs = kwargs
if expected_retval:
return expected_retval
self.stubs.Set(rpc, rpc_method, _fake_rpc_method)
retval = getattr(rpcapi, method)(ctxt, **kwargs)
self.assertEqual(retval, expected_retval)
expected_args = [ctxt, expected_topic, expected_msg]
for arg, expected_arg in zip(self.fake_args, expected_args):
try:
self.assertEqual(arg, expected_arg)
except AssertionError:
# actual_args may contain optional args, like the one that
# have default values; therefore if arg and excepted_arg
# do not match verify at least that the required ones do
if isinstance(arg, dict) and isinstance(expected_arg, dict):
actual_args = arg.get('args')
required_args = expected_arg.get('args')
if actual_args and required_args:
self.assertThat(required_args,
matchers.IsSubDictOf(actual_args))
def test_describe_instances_bdm(self):
"""Make sure describe_instances works with root_device_name and
block device mappings
"""
(inst1, inst2, volumes) = self._setUpBlockDeviceMapping()
result = self._assertInstance(inst1['id'])
self.assertThat(self._expected_instance_bdm1,
matchers.IsSubDictOf(result))
self._assertEqualBlockDeviceMapping(
self._expected_block_device_mapping0, result['blockDeviceMapping'])
result = self._assertInstance(inst2['id'])
self.assertThat(self._expected_instance_bdm2,
matchers.IsSubDictOf(result))
self._tearDownBlockDeviceMapping(inst1, inst2, volumes)
def _assertEqualBlockDeviceMapping(self, expected, result):
self.assertEqual(len(expected), len(result))
for x in expected:
found = False
for y in result:
if x['deviceName'] == y['deviceName']:
self.assertThat(x, matchers.IsSubDictOf(y))
found = True
break
self.assertTrue(found)
def test_format_instance_bdm(self):
(inst1, inst2, volumes) = self._setUpBlockDeviceMapping()
result = {}
self.cloud._format_instance_bdm(self.context, inst1['uuid'],
'/dev/sdb1', result)
self.assertThat(
{'rootDeviceType': self._expected_instance_bdm1['rootDeviceType']},
matchers.IsSubDictOf(result))
self._assertEqualBlockDeviceMapping(
self._expected_block_device_mapping0, result['blockDeviceMapping'])
result = {}
self.cloud._format_instance_bdm(self.context, inst2['uuid'],
'/dev/sdc1', result)
self.assertThat(
{'rootDeviceType': self._expected_instance_bdm2['rootDeviceType']},
matchers.IsSubDictOf(result))
self._tearDownBlockDeviceMapping(inst1, inst2, volumes)
def test_legacy_mapping_source_image(self):
got_legacy = block_device.legacy_mapping(self.new_mapping)
for legacy, expected in zip(got_legacy, self.legacy_mapping):
self.assertThat(expected, matchers.IsSubDictOf(legacy))
def test_legacy(self):
for legacy, new in zip(self.legacy_mapping, self.new_mapping):
self.assertThat(legacy, matchers.IsSubDictOf(new.legacy()))
def test_from_legacy(self):
for legacy, new in zip(self.legacy_mapping, self.new_mapping):
self.assertThat(block_device.BlockDeviceDict.from_legacy(legacy),
matchers.IsSubDictOf(new))
