def test_get_resource_info(self):
vnf_obj = self._get_expected_active_vnf()
self.assertRaises(vnfm.InfraDriverUnreachable,
self.infra_driver.get_resource_info,
plugin=None, context=self.context, vnf_info=vnf_obj,
auth_attr=utils.get_vim_auth_obj(),
region_name=None)
def test_delete_chain(self):
auth_attr = utils.get_vim_auth_obj()
flow_classifier = {'name': 'test_delete_chain_fc',
'description': 'fc for testing delete chain',
'source_port_range': '1000-2000',
'ip_proto': 6,
'destination_port_range': '80-180'}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=auth_attr)
self.assertIsNotNone(fc_id)
vnf_1 = {'name': 'test_delete_chain_vnf_1',
'connection_points': [uuid.uuid4(), uuid.uuid4()]}
vnf_2 = {'name': 'test_delete_chain_vnf_2',
'connection_points': [uuid.uuid4(), uuid.uuid4()]}
vnf_3 = {'name': 'test_delete_chain_vnf_3',
'connection_points': [uuid.uuid4(), uuid.uuid4()]}
vnfs = [vnf_1, vnf_2, vnf_3]
chain_id = self.sfc_driver.create_chain(name='fake_ffg',
fc_id=fc_id,
vnfs=vnfs,
auth_attr=auth_attr)
self.assertIsNotNone(chain_id)
try:
self.sfc_driver.delete_chain(chain_id,
auth_attr=auth_attr)
except Exception:
self.assertTrue(True)
def test_get_resource_info(self):
vnf_obj = self._get_expected_active_vnf()
self.assertRaises(vnfm.InfraDriverUnreachable,
self.infra_driver.get_resource_info,
plugin=None, context=self.context, vnf_info=vnf_obj,
auth_attr=utils.get_vim_auth_obj(),
region_name=None)
def test_create_chain(self):
auth_attr = utils.get_vim_auth_obj()
flow_classifier = {'name': 'test_create_chain_fc',
'description': 'fc for testing create chain',
'source_port_range': '1997-2008',
'ip_proto': 6,
'destination_port_range': '80-100'}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=auth_attr)
self.assertIsNotNone(fc_id)
vnf_1 = {'name': 'test_create_chain_vnf_1',
'connection_points': [uuidutils.generate_uuid(),
uuidutils.generate_uuid()]}
vnf_2 = {'name': 'test_create_chain_vnf_2',
'connection_points': [uuidutils.generate_uuid(),
uuidutils.generate_uuid()]}
vnf_3 = {'name': 'test_create_chain_vnf_3',
'connection_points': [uuidutils.generate_uuid(),
uuidutils.generate_uuid()]}
vnfs = [vnf_1, vnf_2, vnf_3]
result = self.sfc_driver.create_chain(name='fake_ffg',
path_id=None,
fc_ids=fc_id,
vnfs=vnfs,
auth_attr=auth_attr)
self.assertIsNotNone(result)
def test_delete(self):
vnf_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.infra_driver.delete(plugin=None,
context=self.context,
vnf_id=vnf_id,
auth_attr=utils.get_vim_auth_obj())
self.heat_client.delete.assert_called_once_with(vnf_id)
def test_update_flow_classifier(self):
auth_attr = utils.get_vim_auth_obj()
flow_classifier = {'name': 'next_fake_fc',
'source_port_range': '2005-2010',
'ip_proto': 6,
'destination_port_range': '80-180'}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
flow_classifier_update = {'name': 'next_fake_fc_two',
'instance_id': None,
'status': 'PENDING_CREATE',
'match': {'source_port_range': '5-10',
'ip_proto': 17,
'destination_port_range': '2-4'}}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(fc_id)
vnf_1 = {'name': 'test_create_chain_vnf_1',
'connection_points': [uuidutils.generate_uuid(),
uuidutils.generate_uuid()]}
vnf_2 = {'name': 'test_create_chain_vnf_2',
'connection_points': [uuidutils.generate_uuid(),
uuidutils.generate_uuid()]}
vnf_3 = {'name': 'test_create_chain_vnf_3',
'connection_points': [uuidutils.generate_uuid(),
uuidutils.generate_uuid()]}
vnfs = [vnf_1, vnf_2, vnf_3]
chain_id = self.sfc_driver.create_chain(name='fake_ffg',
path_id=None,
fc_ids=fc_id,
vnfs=vnfs,
auth_attr=auth_attr)
self.assertIsNotNone(chain_id)
result = self.sfc_driver.\
update_flow_classifier(chain_id=chain_id,
fc=flow_classifier_update,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(result)
def test_delete_flow_classifier(self):
flow_classifier = {'name': 'another_fake_fc',
'description': 'another flow-classifier',
'source_port_range': '1999-2005',
'ip_proto': 6,
'destination_port_range': '80-100'}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(fc_id)
try:
self.sfc_driver.\
delete_flow_classifier(fc_id=fc_id,
auth_attr=utils.get_vim_auth_obj())
except Exception:
self.assertTrue(True)
def test_create_flow_classifier(self):
flow_classifier = {'name': 'fake_fc',
'source_port_range': '2005-2010',
'ip_proto': 6,
'destination_port_range': '80-180'}
result = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(result)
def test_delete_flow_classifier(self):
flow_classifier = {'name': 'another_fake_fc',
'description': 'another flow-classifier',
'source_port_range': '1999-2005',
'ip_proto': 6,
'destination_port_range': '80-100'}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(fc_id)
try:
self.sfc_driver.\
delete_flow_classifier(fc_id=fc_id,
auth_attr=utils.get_vim_auth_obj())
except Exception:
self.assertTrue(True)
def test_create_ip_addr_param_attr(self):
device_obj = utils.get_dummy_device_obj_ipaddr_attr()
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_ipaddr_data()
result = self.heat_driver.create(plugin=None, context=self.context,
device=device_obj,
auth_attr=utils.get_vim_auth_obj())
self.heat_client.create.assert_called_once_with(expected_fields)
self.assertEqual(expected_result, result)
def setUp(self):
super(TestOpenstack_Driver, self).setUp()
self._mock_keystone()
self.keystone.create_key_dir.return_value = 'test_keys'
self.config_fixture.config(group='vim_keys', openstack='/tmp/')
self.openstack_driver = openstack_driver.OpenStack_Driver()
self.vim_obj = self.get_vim_obj()
self.auth_obj = utils.get_vim_auth_obj()
self.addCleanup(mock.patch.stopall)
def test_create_ip_addr_param_attr(self):
vnf_obj = utils.get_dummy_device_obj_ipaddr_attr()
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_ipaddr_data()
result = self.heat_driver.create(plugin=None, context=self.context,
vnf=vnf_obj,
auth_attr=utils.get_vim_auth_obj())
self.heat_client.create.assert_called_once_with(expected_fields)
self.assertEqual(expected_result, result)
def test_create_flow_classifier(self):
flow_classifier = {'name': 'fake_fc',
'source_port_range': '2005-2010',
'ip_proto': 6,
'destination_port_range': '80-180'}
result = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(result)
def test_create_wait(self):
vnf_obj = utils.get_dummy_device_obj()
expected_result = self._get_expected_vnf_wait_obj()
vnf_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.heat_driver.create_wait(plugin=None,
context=self.context,
vnf_dict=vnf_obj,
vnf_id=vnf_id,
auth_attr=utils.get_vim_auth_obj())
self.assertEqual(expected_result, vnf_obj)
def test_update(self):
device_obj = utils.get_dummy_device_obj_config_attr()
device_config_obj = utils.get_dummy_device_update_config_attr()
expected_device_update = self._get_expected_device_update_obj()
device_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.heat_driver.update(plugin=None, context=self.context,
device_id=device_id, device_dict=device_obj,
device=device_config_obj,
auth_attr=utils.get_vim_auth_obj())
self.assertEqual(device_obj, expected_device_update)
def test_update(self):
vnf_obj = utils.get_dummy_device_obj_config_attr()
vnf_config_obj = utils.get_dummy_device_update_config_attr()
expected_vnf_update = self._get_expected_vnf_update_obj()
vnf_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.heat_driver.update(plugin=None, context=self.context,
vnf_id=vnf_id, vnf_dict=vnf_obj,
vnf=vnf_config_obj,
auth_attr=utils.get_vim_auth_obj())
self.assertEqual(expected_vnf_update, vnf_obj)
def test_create_wait(self):
device_obj = utils.get_dummy_device_obj()
expected_result = self._get_expected_device_wait_obj()
device_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.heat_driver.create_wait(plugin=None,
context=self.context,
device_dict=device_obj,
device_id=device_id,
auth_attr=utils.get_vim_auth_obj())
self.assertEqual(device_obj, expected_result)
def test_create_wait(self):
vnf_obj = self._get_dummy_tosca_vnf('test_tosca_openwrt.yaml')
expected_result = self._get_expected_vnf_wait_obj()
vnf_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.infra_driver.create_wait(plugin=None,
context=self.context,
vnf_dict=vnf_obj,
vnf_id=vnf_id,
auth_attr=utils.get_vim_auth_obj())
self.assertEqual(expected_result, vnf_obj)
def test_create_ip_addr_param_attr(self):
vnf_obj = utils.get_dummy_device_obj_ipaddr_attr()
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_ipaddr_data()
result = self.infra_driver.create(plugin=None, context=self.context,
vnf=vnf_obj,
auth_attr=utils.get_vim_auth_obj())
actual_fields = self.heat_client.create.call_args[0][0]
self._assert_create_result_old_template(expected_fields, actual_fields,
expected_result, result)
def test_update_flow_classifier(self):
flow_classifier = {'name': 'next_fake_fc',
'description': 'fake flow-classifier',
'source_port_range': '2005-2010',
'ip_proto': 6,
'destination_port_range': '80-180'}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(fc_id)
flow_classifier['description'] = 'next fake flow-classifier'
result = self.sfc_driver.\
update_flow_classifier(fc_id=fc_id,
fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(result)
def test_create_ip_addr_param_attr(self):
vnf_obj = utils.get_dummy_device_obj_ipaddr_attr()
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_ipaddr_data()
result = self.infra_driver.create(plugin=None, context=self.context,
vnf=vnf_obj,
auth_attr=utils.get_vim_auth_obj())
actual_fields = self.heat_client.create.call_args[0][0]
self._assert_create_result_old_template(expected_fields, actual_fields,
expected_result, result)
def test_update_flow_classifier(self):
flow_classifier = {
'name': 'next_fake_fc',
'description': 'fake flow-classifier',
'source_port_range': '2005-2010',
'ip_proto': 6,
'destination_port_range': '80-180'
}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(fc_id)
flow_classifier['description'] = 'next fake flow-classifier'
result = self.sfc_driver.\
update_flow_classifier(fc_id=fc_id,
fc=flow_classifier,
auth_attr=utils.get_vim_auth_obj())
self.assertIsNotNone(result)
def test_update_empty_param(self, mock_log):
vnf_obj = utils.get_dummy_vnf_param_attr()
vnf_param_obj = utils.get_dummy_vnf_update_empty_param()
vnf_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.assertRaises(vnfm.VNFUpdateInvalidInput,
self.infra_driver.update,
plugin=None, context=self.context,
vnf_id=vnf_id, vnf_dict=vnf_obj,
vnf=vnf_param_obj,
auth_attr=utils.get_vim_auth_obj())
log_msg = "at vnf_id {} because the target "\
"yaml is empty.".format(vnf_id)
mock_log.warning.assert_called_with(log_msg)
def _test_assert_equal_for_tosca_templates(self,
tosca_tpl_name,
hot_tpl_name,
input_params='',
files=None,
is_monitor=True,
multi_vdus=False):
vnf = self._get_dummy_tosca_vnf(tosca_tpl_name, input_params)
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_tosca(hot_tpl_name)
expected_vnf = self._get_expected_tosca_vnf(tosca_tpl_name,
hot_tpl_name,
input_params,
is_monitor,
multi_vdus)
result = self.infra_driver.create(plugin=None, context=self.context,
vnf=vnf,
auth_attr=utils.get_vim_auth_obj())
actual_fields = self.heat_client.create.call_args[0][0]
actual_fields["template"] = yaml.safe_load(actual_fields["template"])
expected_fields["template"] = \
yaml.safe_load(expected_fields["template"])
if files:
for k, v in actual_fields["files"].items():
actual_fields["files"][k] = yaml.safe_load(v)
expected_fields["files"] = {}
for k, v in files.items():
expected_fields["files"][k] = yaml.safe_load(_get_template(v))
self.assertEqual(expected_fields, actual_fields)
vnf["attributes"]["heat_template"] = yaml.safe_load(
vnf["attributes"]["heat_template"])
self.heat_client.create.assert_called_once_with(expected_fields)
self.assertEqual(expected_result, result)
if files:
expected_fields["files"] = {}
for k, v in files.items():
expected_vnf["attributes"][k] = yaml.safe_load(
_get_template(v))
vnf["attributes"][k] = yaml.safe_load(
vnf["attributes"][k])
expected_vnf["attributes"]['scaling_group_names'] = {
'SP1': 'SP1_group'}
vnf["attributes"]['scaling_group_names'] = jsonutils.loads(
vnf["attributes"]['scaling_group_names']
)
self.assertEqual(expected_vnf, vnf)
def test_update(self):
vnf_obj = utils.get_dummy_vnf_config_attr()
vnf_config_obj = utils.get_dummy_vnf_update_config()
expected_vnf_update = self._get_expected_vnf_update_obj()
vnf_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.infra_driver.update(plugin=None, context=self.context,
vnf_id=vnf_id, vnf_dict=vnf_obj,
vnf=vnf_config_obj,
auth_attr=utils.get_vim_auth_obj())
expected_vnf_update['attributes']['config'] = yaml.load(
expected_vnf_update['attributes']['config'])
vnf_obj['attributes']['config'] = yaml.load(vnf_obj['attributes'][
'config'])
self.assertEqual(expected_vnf_update, vnf_obj)
def _test_assert_equal_for_tosca_templates(self,
tosca_tpl_name,
hot_tpl_name,
input_params='',
files=None,
is_monitor=True,
multi_vdus=False):
vnf = self._get_dummy_tosca_vnf(tosca_tpl_name, input_params)
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_tosca(hot_tpl_name)
expected_vnf = self._get_expected_tosca_vnf(tosca_tpl_name,
hot_tpl_name,
input_params,
is_monitor,
multi_vdus)
result = self.infra_driver.create(plugin=None, context=self.context,
vnf=vnf,
auth_attr=utils.get_vim_auth_obj())
actual_fields = self.heat_client.create.call_args[0][0]
actual_fields["template"] = yaml.safe_load(actual_fields["template"])
expected_fields["template"] = \
yaml.safe_load(expected_fields["template"])
if files:
for k, v in actual_fields["files"].items():
actual_fields["files"][k] = yaml.safe_load(v)
expected_fields["files"] = {}
for k, v in files.items():
expected_fields["files"][k] = yaml.safe_load(_get_template(v))
self.assertEqual(expected_fields, actual_fields)
vnf["attributes"]["heat_template"] = yaml.safe_load(
vnf["attributes"]["heat_template"])
self.heat_client.create.assert_called_once_with(expected_fields)
self.assertEqual(expected_result, result)
if files:
expected_fields["files"] = {}
for k, v in files.items():
expected_vnf["attributes"][k] = yaml.safe_load(
_get_template(v))
vnf["attributes"][k] = yaml.safe_load(
vnf["attributes"][k])
expected_vnf["attributes"]['scaling_group_names'] = {
'SP1': 'SP1_group'}
vnf["attributes"]['scaling_group_names'] = jsonutils.loads(
vnf["attributes"]['scaling_group_names']
)
self.assertEqual(expected_vnf, vnf)
def test_update_new_param(self):
vnf_obj = utils.get_dummy_vnf_param_attr()
vnf_param_obj = utils.get_dummy_vnf_update_new_param()
expected_vnf_update = self._get_expected_vnf_update_new_param_obj()
vnf_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.infra_driver.update(plugin=None, context=self.context,
vnf_id=vnf_id, vnf_dict=vnf_obj,
vnf=vnf_param_obj,
auth_attr=utils.get_vim_auth_obj())
expected_vnf_update['attributes']['param_values'] = yaml.safe_load(
expected_vnf_update['attributes']['param_values'])
vnf_obj['attributes']['param_values'] = yaml.safe_load(
vnf_obj['attributes']['param_values'])
self.assertEqual(expected_vnf_update, vnf_obj)
def test_delete_chain(self):
auth_attr = utils.get_vim_auth_obj()
flow_classifier = {
'name': 'test_delete_chain_fc',
'description': 'fc for testing delete chain',
'source_port_range': '1000-2000',
'ip_proto': 6,
'destination_port_range': '80-180'
}
fc_id = self.sfc_driver.\
create_flow_classifier(name='fake_ffg', fc=flow_classifier,
auth_attr=auth_attr)
self.assertIsNotNone(fc_id)
vnf_1 = {
'name':
'test_delete_chain_vnf_1',
'connection_points':
[uuidutils.generate_uuid(),
uuidutils.generate_uuid()]
}
vnf_2 = {
'name':
'test_delete_chain_vnf_2',
'connection_points':
[uuidutils.generate_uuid(),
uuidutils.generate_uuid()]
}
vnf_3 = {
'name':
'test_delete_chain_vnf_3',
'connection_points':
[uuidutils.generate_uuid(),
uuidutils.generate_uuid()]
}
vnfs = [vnf_1, vnf_2, vnf_3]
chain_id = self.sfc_driver.create_chain(name='fake_ffg',
fc_ids=fc_id,
vnfs=vnfs,
auth_attr=auth_attr)
self.assertIsNotNone(chain_id)
try:
self.sfc_driver.delete_chain(chain_id, auth_attr=auth_attr)
except Exception:
self.assertTrue(True)
def _test_assert_equal_for_tosca_templates(self, tosca_tpl_name,
hot_tpl_name):
device = self._get_dummy_tosca_device(tosca_tpl_name)
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_tosca(hot_tpl_name)
expected_device = self._get_expected_tosca_device(tosca_tpl_name,
hot_tpl_name)
result = self.heat_driver.create(plugin=None, context=self.context,
device=device,
auth_attr=utils.get_vim_auth_obj())
actual_fields = self.heat_client.create.call_args[0][0]
actual_fields["template"] = yaml.safe_load(actual_fields["template"])
expected_fields["template"] = \
yaml.safe_load(expected_fields["template"])
self.assertEqual(actual_fields, expected_fields)
device["attributes"]["heat_template"] = yaml.safe_load(
device["attributes"]["heat_template"])
self.heat_client.create.assert_called_once_with(expected_fields)
self.assertEqual(expected_result, result)
self.assertEqual(device, expected_device)
def _test_assert_equal_for_tosca_templates(self, tosca_tpl_name,
hot_tpl_name):
device = self._get_dummy_tosca_device(tosca_tpl_name)
expected_result = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
expected_fields = self._get_expected_fields_tosca(hot_tpl_name)
expected_device = self._get_expected_tosca_device(tosca_tpl_name,
hot_tpl_name)
result = self.heat_driver.create(plugin=None, context=self.context,
device=device,
auth_attr=utils.get_vim_auth_obj())
actual_fields = self.heat_client.create.call_args[0][0]
actual_fields["template"] = yaml.safe_load(actual_fields["template"])
expected_fields["template"] = \
yaml.safe_load(expected_fields["template"])
self.assertEqual(actual_fields, expected_fields)
device["attributes"]["heat_template"] = yaml.safe_load(
device["attributes"]["heat_template"])
self.heat_client.create.assert_called_once_with(expected_fields)
self.assertEqual(expected_result, result)
self.assertEqual(device, expected_device)
def dummy_get_vim(*args, **kwargs):
vim_obj = dict()
vim_obj['auth_cred'] = utils.get_vim_auth_obj()
vim_obj['type'] = 'openstack'
return vim_obj
def dummy_get_vim(*args, **kwargs):
vim_obj = dict()
vim_obj['auth_cred'] = utils.get_vim_auth_obj()
vim_obj['type'] = 'openstack'
return vim_obj
def test_delete(self):
device_id = '4a4c2d44-8a52-4895-9a75-9d1c76c3e738'
self.heat_driver.delete(plugin=None, context=self.context,
device_id=device_id,
auth_attr=utils.get_vim_auth_obj())
self.heat_client.delete.assert_called_once_with(device_id)
