conductor/conductor/tests/unit/data/plugins/inventory_provider/test_aai.py

   1 #
   2 # -------------------------------------------------------------------------
   3 #   Copyright (c) 2015-2017 AT&T Intellectual Property
   4 #   Copyright (C) 2020 Wipro Limited.
   5 #
   6 #   Licensed under the Apache License, Version 2.0 (the "License");
   7 #   you may not use this file except in compliance with the License.
   8 #   You may obtain a copy of the License at
   9 #
  10 #       http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 #   Unless required by applicable law or agreed to in writing, software
  13 #   distributed under the License is distributed on an "AS IS" BASIS,
  14 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 #   See the License for the specific language governing permissions and
  16 #   limitations under the License.
  17 #
  18 # -------------------------------------------------------------------------
  19 #
  20 import copy
  21 import json
  22 import mock
  23 import unittest
  24
  25 from oslo_config import cfg
  26
  27 import conductor.data.plugins.inventory_provider.aai as aai
  28 from conductor.data.plugins.inventory_provider.aai import AAI
  29 from conductor.data.plugins.triage_translator.triage_translator import TraigeTranslator
  30
  31
  32 class TestAAI(unittest.TestCase):
  33
  34     def setUp(self):
  35         cfg.CONF.set_override('password', '4HyU6sI+Tw0YMXgSHr5sJ5C0UTkeBaxXoxQqWuSVFugls7sQnaAXp4zMfJ8FKFrH', 'aai')
  36         CONF = cfg.CONF
  37         CONF.register_opts(aai.AAI_OPTS, group='aai')
  38         self.conf = CONF
  39         self.aai_ep = AAI()
  40
  41     def tearDown(self):
  42         mock.patch.stopall()
  43
  44     def test_get_version_from_string(self):
  45
  46         self.assertEqual("2.5", self.aai_ep._get_version_from_string("AAI2.5"))
  47         self.assertEqual("3.0", self.aai_ep._get_version_from_string("AAI3.0"))
  48
  49     def test_aai_versioned_path(self):
  50
  51         self.assertEqual('/{}/cloud-infrastructure/cloud-regions/?depth=0'.format(self.conf.aai.server_url_version),
  52                          self.aai_ep._aai_versioned_path("/cloud-infrastructure/cloud-regions/?depth=0"))
  53         self.assertEqual('/{}/query?format=id'.format(self.conf.aai.server_url_version),
  54                          self.aai_ep._aai_versioned_path("/query?format=id"))
  55
  56     def test_resolve_clli_location(self):
  57
  58         req_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_clli_location.json'
  59         req_json = json.loads(open(req_json_file).read())
  60
  61         response = mock.MagicMock()
  62         response.status_code = 200
  63         response.ok = True
  64         response.json.return_value = req_json
  65
  66         self.mock_get_request = mock.patch.object(AAI, '_request', return_value=response)
  67         self.mock_get_request.start()
  68         self.assertEqual({'country': u'USA', 'latitude': u'40.39596', 'longitude': u'-74.135342'} ,
  69                         self.aai_ep.resolve_clli_location("clli_code"))
  70
  71     def test_get_inventory_group_pair(self):
  72
  73         req_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_inventory_group_pair.json'
  74         req_json = json.loads(open(req_json_file).read())
  75
  76         response = mock.MagicMock()
  77         response.status_code = 200
  78         response.ok = True
  79         response.json.return_value = req_json
  80
  81         self.mock_get_request = mock.patch.object(AAI, '_request', return_value=response)
  82         self.mock_get_request.start()
  83         self.assertEqual([[u'instance-1', u'instance-2']] ,
  84                         self.aai_ep.get_inventory_group_pairs("service_description"))
  85
  86     def test_resolve_host_location(self):
  87
  88         req_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_host_name.json'
  89         req_json = json.loads(open(req_json_file).read())
  90
  91         req_response = mock.MagicMock()
  92         req_response.status_code = 200
  93         req_response.ok = True
  94         req_response.json.return_value = req_json
  95
  96         complex_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_get_complex.json'
  97         complex_json = json.loads(open(complex_json_file).read())
  98
  99         self.mock_get_request = mock.patch.object(AAI, '_request', return_value=req_response)
 100         self.mock_get_request.start()
 101
 102         self.mock_get_complex = mock.patch.object(AAI, '_get_complex', return_value=complex_json)
 103         self.mock_get_complex.start()
 104
 105         self.assertEqual({'country': u'USA', 'latitude': u'28.543251', 'longitude': u'-81.377112'} ,
 106                          self.aai_ep.resolve_host_location("host_name"))
 107
 108     def test_resolve_demands_inventory_type_cloud(self):
 109
 110         self.aai_ep.conf.HPA_enabled = True
 111         TraigeTranslator.getPlanIdNAme = mock.MagicMock(return_value=None)
 112         TraigeTranslator.addDemandsTriageTranslator = mock.MagicMock(return_value=None)
 113
 114         plan_info = {
 115             'plan_name': 'name',
 116             'plan_id': 'id'
 117         }
 118         triage_translator_data = None
 119
 120         demands_list_file = './conductor/tests/unit/data/plugins/inventory_provider/demand_list.json'
 121         demands_list = json.loads(open(demands_list_file).read())
 122
 123         generic_vnf_list_file = './conductor/tests/unit/data/plugins/inventory_provider/generic_vnf_list.json'
 124         generic_vnf_list = json.loads(open(generic_vnf_list_file).read())
 125
 126         regions_response_file = './conductor/tests/unit/data/plugins/inventory_provider/regions.json'
 127         regions_response = json.loads(open(regions_response_file).read())
 128
 129         demand_service_response_file = './conductor/tests/unit/data/plugins/inventory_provider/resolve_demand_service_response.json'
 130         demand_service_response = json.loads(open(demand_service_response_file).read())
 131
 132         complex_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_get_complex.json'
 133         complex_json = json.loads(open(complex_json_file).read())
 134
 135         req_response = mock.MagicMock()
 136         req_response.status_code = 200
 137         req_response.ok = True
 138         req_response.json.return_value = demand_service_response
 139
 140         self.mock_first_level_service_call = mock.patch.object(AAI, 'first_level_service_call', return_value=generic_vnf_list)
 141         self.mock_first_level_service_call.start()
 142
 143         self.mock_get_regions = mock.patch.object(AAI, '_get_regions', return_value=regions_response)
 144         self.mock_get_regions.start()
 145
 146         regions_list = list()
 147         regions_list.append(regions_response.get('region-name'))
 148         self.mock_resolve_cloud_regions_by_cloud_region_id = mock.patch.object(AAI,
 149                                                                                'resolve_cloud_regions_by_cloud_region_id',
 150                                                                                return_value=regions_list)
 151         self.mock_resolve_cloud_regions_by_cloud_region_id.start()
 152
 153
 154         self.mock_resolve_v_server_for_candidate = mock.patch.object(AAI, 'resolve_v_server_for_candidate',
 155                                                                       return_value=demand_service_response)
 156         self.mock_resolve_v_server_for_candidate.start()
 157
 158         complex_link = {"link": "/aai/v10/complex-id", "d_value": 'test-id'}
 159         self.mock_resolve_complex_info_link_for_v_server = mock.patch.object(AAI,
 160                                                                              'resolve_complex_info_link_for_v_server',
 161                                                                              return_value=complex_link)
 162         self.mock_resolve_complex_info_link_for_v_server.start()
 163
 164         self.mock_get_complex = mock.patch.object(AAI, '_get_complex', return_value=complex_json)
 165         self.mock_get_complex.start()
 166
 167         flavor_info = regions_response["region-name"]["flavors"]
 168         self.maxDiff = None
 169         self.assertCountEqual({u'demand_name': [
 170             {'candidate_id': u'service-instance-id', 'city': None,
 171              'cloud_owner': u'cloud-owner',
 172              'uniqueness': 'true',
 173              'vim-id': u'cloud-owner_cloud-region-id',
 174              'vlan_key': None, 'cloud_region_version': '', 'complex_name': None, 'cost': 1.0,
 175              'country': u'USA', 'existing_placement': 'false',
 176              'host_id': u'vnf-name', 'inventory_provider': 'aai',
 177              'inventory_type': 'service', 'latitude': u'28.543251',
 178              'location_id': u'cloud-region-id', 'location_type': 'att_aic',
 179              'longitude': u'-81.377112', 'physical_location_id': u'test-id',
 180              'port_key': None,
 181              'region': u'SE', 'service_resource_id': '',
 182              'sriov_automation': 'false', 'state': None},
 183             {'candidate_id': u'region-name', 'city': u'Middletown',
 184              'cloud_owner': u'cloud-owner',
 185              'uniqueness': 'true',
 186              'vim-id': u'cloud-owner_region-name',
 187              'cloud_region_version': u'1.0', 'complex_name': u'complex-name',
 188              'cost': 2.0, 'country': u'USA', 'existing_placement': 'false',
 189              'inventory_provider': 'aai', 'inventory_type': 'cloud',
 190              'latitude': u'50.34', 'location_id': u'region-name',
 191              'location_type': 'att_aic', 'longitude': u'30.12',
 192              'physical_location_id': u'complex-id',
 193              'region': u'USA', 'service_resource_id': u'service-resource-id-123',
 194              'sriov_automation': 'false', 'state': u'NJ',
 195              'flavors': flavor_info}]},
 196             self.aai_ep.resolve_demands(demands_list, plan_info=plan_info,
 197                                         triage_translator_data=triage_translator_data))
 198
 199     def test_resolve_demands_inventory_type_service(self):
 200         self.aai_ep.conf.HPA_enabled = True
 201         TraigeTranslator.getPlanIdNAme = mock.MagicMock(return_value=None)
 202         TraigeTranslator.addDemandsTriageTranslator = mock.MagicMock(return_value=None)
 203
 204         plan_info = {
 205             'plan_name': 'name',
 206             'plan_id': 'id'
 207         }
 208         triage_translator_data = None
 209
 210         demands_list_file = './conductor/tests/unit/data/plugins/inventory_provider/service_demand_list.json'
 211         demands_list = json.loads(open(demands_list_file).read())
 212
 213         generic_vnf_list_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_service_generic_vnf_list.json'
 214         generic_vnf_list = json.loads(open(generic_vnf_list_file).read())
 215
 216         v_server_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_vserver.json'
 217         v_server = json.loads(open(v_server_file).read())
 218
 219         demand_service_response_file = './conductor/tests/unit/data/plugins/inventory_provider/resolve_demand_service_response.json'
 220         demand_service_response = json.loads(open(demand_service_response_file).read())
 221
 222         complex_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_complex.json'
 223         complex_response = json.loads(open(complex_file).read())
 224
 225         region_response_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_region.json'
 226         region_response = json.loads(open(region_response_file).read())
 227
 228         results_file = './conductor/tests/unit/data/plugins/inventory_provider/service_candidates.json'
 229         results_json = json.loads(open(results_file).read())
 230
 231         req_response = mock.MagicMock()
 232         req_response.status_code = 200
 233         req_response.ok = True
 234         req_response.json.return_value = demand_service_response
 235
 236         def mock_first_level_service_call_response(path, name, service_type):
 237             if "equipment-role" in path:
 238                 return list()
 239             else:
 240                 return generic_vnf_list
 241
 242         self.mock_first_level_service_call = mock.patch.object(AAI, 'first_level_service_call',
 243                                                                side_effect=mock_first_level_service_call_response)
 244         self.mock_first_level_service_call.start()
 245
 246         regions = list()
 247         regions.append(region_response)
 248         self.mock_resolve_cloud_regions_by_cloud_region_id = mock.patch.object(AAI,
 249                                                                                'resolve_cloud_regions_by_cloud_region_id',
 250                                                                                return_value=regions)
 251         self.mock_resolve_cloud_regions_by_cloud_region_id.start()
 252
 253         self.mock_resolve_v_server_for_candidate = mock.patch.object(AAI, 'resolve_v_server_for_candidate',
 254                                                                       return_value=v_server)
 255         self.mock_resolve_v_server_for_candidate.start()
 256
 257         complex_link = {"link": "/aai/v14/cloud-infrastructure/complexes/complex/clli1", "d_value": 'clli1'}
 258         self.mock_resolve_complex_info_link_for_v_server = mock.patch.object(AAI,
 259                                                                              'resolve_complex_info_link_for_v_server',
 260                                                                              return_value=complex_link)
 261         self.mock_resolve_complex_info_link_for_v_server.start()
 262
 263         self.mock_get_complex = mock.patch.object(AAI, '_get_complex', return_value=complex_response)
 264         self.mock_get_complex.start()
 265
 266         self.maxDiff = None
 267         self.assertEqual(results_json, self.aai_ep.resolve_demands(demands_list, plan_info=plan_info,
 268                                          triage_translator_data=triage_translator_data))
 269
 270     def test_resolve_demands_inventory_type_vfmodule(self):
 271         self.aai_ep.conf.HPA_enabled = True
 272         TraigeTranslator.getPlanIdNAme = mock.MagicMock(return_value=None)
 273         TraigeTranslator.addDemandsTriageTranslator = mock.MagicMock(return_value=None)
 274
 275         plan_info = {
 276             'plan_name': 'name',
 277             'plan_id': 'id'
 278         }
 279         triage_translator_data = None
 280
 281         demands_list_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_demand_list.json'
 282         demands_list = json.loads(open(demands_list_file).read())
 283
 284         generic_vnf_list_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_service_generic_vnf_list.json'
 285         generic_vnf_list = json.loads(open(generic_vnf_list_file).read())
 286
 287         vfmodules_list_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_list.json'
 288         vfmodules_list = json.loads(open(vfmodules_list_file).read())
 289
 290         v_server_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_vserver.json'
 291         v_server = json.loads(open(v_server_file).read())
 292
 293         demand_service_response_file = './conductor/tests/unit/data/plugins/inventory_provider/resolve_demand_service_response.json'
 294         demand_service_response = json.loads(open(demand_service_response_file).read())
 295
 296         complex_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_complex.json'
 297         complex_response = json.loads(open(complex_file).read())
 298
 299         region_response_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_region.json'
 300         region_response = json.loads(open(region_response_file).read())
 301
 302         results_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_candidates.json'
 303         results_json = json.loads(open(results_file).read())
 304
 305         req_response = mock.MagicMock()
 306         req_response.status_code = 200
 307         req_response.ok = True
 308         req_response.json.return_value = demand_service_response
 309
 310         def mock_first_level_service_call_response(path, name, service_type):
 311             if "equipment-role" in path:
 312                 return list()
 313             else:
 314                 return generic_vnf_list
 315
 316         self.mock_first_level_service_call = mock.patch.object(AAI, 'first_level_service_call',
 317                                                                side_effect=mock_first_level_service_call_response)
 318         self.mock_first_level_service_call.start()
 319
 320         self.mock_resolve_vf_modules_for_generic_vnf = mock.patch.object(AAI, 'resolve_vf_modules_for_generic_vnf',
 321                                                                          return_value=vfmodules_list)
 322         self.mock_resolve_vf_modules_for_generic_vnf.start()
 323
 324         regions = list()
 325         regions.append(region_response)
 326         self.mock_resolve_cloud_regions_by_cloud_region_id = mock.patch.object(AAI,
 327                                                                                'resolve_cloud_regions_by_cloud_region_id',
 328                                                                                return_value=regions)
 329         self.mock_resolve_cloud_regions_by_cloud_region_id.start()
 330
 331         self.mock_resolve_v_server_for_candidate = mock.patch.object(AAI, 'resolve_v_server_for_candidate',
 332                                                                        return_value=v_server)
 333         self.mock_resolve_v_server_for_candidate.start()
 334
 335         complex_link = {"link": "/aai/v14/cloud-infrastructure/complexes/complex/clli1", "d_value": 'clli1'}
 336         self.mock_resolve_complex_info_link_for_v_server = mock.patch.object(AAI, 'resolve_complex_info_link_for_v_server',
 337                                                                              return_value=complex_link)
 338         self.mock_resolve_complex_info_link_for_v_server.start()
 339
 340         self.mock_get_complex = mock.patch.object(AAI, '_get_complex', return_value=complex_response)
 341         self.mock_get_complex.start()
 342
 343         self.maxDiff = None
 344         self.assertEqual(results_json, self.aai_ep.resolve_demands(demands_list, plan_info=plan_info,
 345                                          triage_translator_data=triage_translator_data))
 346
 347     def test_get_complex(self):
 348
 349         complex_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_get_complex.json'
 350         complex_json = json.loads(open(complex_json_file).read())
 351
 352         response = mock.MagicMock()
 353         response.status_code = 200
 354         response.ok = True
 355         response.json.return_value = complex_json
 356
 357         self.mock_get_request = mock.patch.object(AAI, '_request', return_value=response)
 358         self.mock_get_request.start()
 359
 360         self.assertEqual({u'city': u'Middletown', u'latitude': u'28.543251', u'longitude': u'-81.377112', u'country': u'USA', u'region': u'SE'},
 361                          self.aai_ep._get_complex("/v10/complex/complex_id", "complex_id"))
 362
 363     def test_check_network_roles(self):
 364
 365         network_role_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_network_role.json'
 366         network_role_json = json.loads(open(network_role_json_file).read())
 367
 368         response = mock.MagicMock()
 369         response.status_code = 200
 370         response.ok = True
 371         response.json.return_value = network_role_json
 372
 373         self.mock_get_request = mock.patch.object(AAI, '_request', return_value=response)
 374         self.mock_get_request.start()
 375         self.assertEqual(set(['test-cloud-value']) ,
 376                         self.aai_ep.check_network_roles("network_role_id"))
 377
 378     def test_check_candidate_role(self):
 379
 380         candidate_role_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_candidate_role.json'
 381         candidate_role_json = json.loads(open(candidate_role_json_file).read())
 382
 383         response = mock.MagicMock()
 384         response.status_code = 200
 385         response.ok = True
 386         response.json.return_value = candidate_role_json
 387
 388         self.mock_get_request = mock.patch.object(AAI, '_request', return_value=response)
 389         self.mock_get_request.start()
 390
 391         self.assertEqual("test-role",
 392                          self.aai_ep.check_candidate_role("candidate_host_id"))
 393
 394     def test_match_inventory_attributes(self):
 395         template_attributes = dict()
 396         template_attributes['attr-1'] = ['attr-1-value1', 'attr-1-value2']
 397
 398         inventory_attributes = dict()
 399         inventory_attributes['attr-1'] = 'attr-1-value1'
 400
 401         self.assertEqual(True,
 402                          self.aai_ep.match_inventory_attributes(template_attributes, inventory_attributes, "candidate-id"))
 403
 404         template_attributes['attr-1'] = {
 405             'not': ['attr-1-value2']
 406         }
 407         self.assertEqual(True,
 408                          self.aai_ep.match_inventory_attributes(template_attributes, inventory_attributes,
 409                                                                 "candidate-id"))
 410
 411         template_attributes['attr-1'] = {
 412             'not': ['attr-1-value1']
 413         }
 414         self.assertEqual(False,
 415                          self.aai_ep.match_inventory_attributes(template_attributes, inventory_attributes,
 416                                                                 "candidate-id"))
 417
 418     def test_refresh_cache(self):
 419         regions_response_file = './conductor/tests/unit/data/plugins/inventory_provider/cache_regions.json'
 420         regions_response = json.loads(open(regions_response_file).read())
 421
 422         complex_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_cached_complex.json'
 423         complex_json = json.loads(open(complex_json_file).read())
 424
 425         flavors_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_get_flavors.json'
 426         flavors_json = json.loads(open(flavors_json_file).read())
 427
 428         response = mock.MagicMock()
 429         response.status_code = 200
 430         response.ok = True
 431         response.json.return_value = regions_response
 432
 433         self.mock_get_regions = mock.patch.object(AAI, '_request', return_value=response)
 434         self.mock_get_regions.start()
 435
 436         self.mock_get_complex = mock.patch.object(AAI, '_get_complex', return_value=complex_json)
 437         self.mock_get_complex.start()
 438
 439         self.mock_get_flavors = mock.patch.object(AAI, '_get_flavors',
 440                                                   return_value=flavors_json)
 441         self.mock_get_flavors.start()
 442
 443         self.assertEqual(None,
 444                          self.aai_ep._refresh_cache())
 445
 446     def test_get_aai_rel_link(self):
 447
 448         relatonship_response_file = './conductor/tests/unit/data/plugins/inventory_provider/relationship_list.json'
 449         relatonship_response = json.loads(open(relatonship_response_file).read())
 450         related_to = "service-instance"
 451
 452         self.assertEqual("relationship-link",
 453                          self.aai_ep._get_aai_rel_link(relatonship_response, related_to))
 454
 455     def test_get_flavor(self):
 456         flavors_json_file = './conductor/tests/unit/data/plugins/inventory_provider/_request_get_flavors.json'
 457         flavors_json = json.loads(open(flavors_json_file).read())
 458
 459         response = mock.MagicMock()
 460         response.json.return_value = None
 461
 462         self.mock_get_request = mock.patch.object(AAI, '_request',
 463                                                   return_value=response)
 464         self.mock_get_request.start()
 465
 466         flavors_info = self.aai_ep._get_flavors("mock-cloud-owner",
 467                                                 "mock-cloud-region-id")
 468         self.assertEqual(None, flavors_info)
 469
 470         response.status_code = 200
 471         response.ok = True
 472         response.json.return_value = flavors_json
 473
 474         flavors_info = self.aai_ep._get_flavors("mock-cloud-owner",
 475                                                 "mock-cloud-region-id")
 476         self.assertEqual(2, len(flavors_info['flavor']))
 477
 478     def test_resolve_complex_info_link_for_v_server(self):
 479         TraigeTranslator.collectDroppedCandiate = mock.MagicMock(return_value=None)
 480         triage_translator_data = None
 481         demand_name = 'vPGN'
 482         service_type = 'vFW'
 483         cloud_owner = 'CloudOwner'
 484         cloud_region_id = 'RegionOne'
 485         v_server_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_vserver.json'
 486         v_server = json.loads(open(v_server_file).read())
 487         region_response_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_region.json'
 488         region_response = json.loads(open(region_response_file).read())
 489
 490         candidate_id = 'some_id'
 491         location_id = 'some_location_id'
 492         inventory_type = 'service'
 493
 494         response = mock.MagicMock()
 495         response.status_code = 200
 496         response.ok = True
 497         response.json.return_value = region_response
 498
 499         self.mock_get_request = mock.patch.object(AAI, '_request', return_value=response)
 500         self.mock_get_request.start()
 501
 502         link_rl_data = self.aai_ep.resolve_complex_info_link_for_v_server(candidate_id, v_server, None,
 503                                                                           cloud_region_id, service_type,
 504                                                                           demand_name, triage_translator_data)
 505         self.assertEqual(None, link_rl_data)
 506
 507         complex_link = {"link": "/aai/v14/cloud-infrastructure/complexes/complex/clli1", "d_value": 'clli1'}
 508         link_rl_data = self.aai_ep.resolve_complex_info_link_for_v_server(candidate_id, v_server, cloud_owner,
 509                                                                           cloud_region_id, service_type,
 510                                                                           demand_name, triage_translator_data)
 511         self.assertEqual(complex_link, link_rl_data)
 512
 513     def test_build_complex_info_for_candidate(self):
 514         TraigeTranslator.collectDroppedCandiate = mock.MagicMock(return_value=None)
 515         triage_translator_data = None
 516         demand_name = 'vPGN'
 517         service_type = 'vFW'
 518         complex_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_complex.json'
 519         complex_response = json.loads(open(complex_file).read())
 520
 521         candidate = dict()
 522         candidate['candidate_id'] = 'some_id'
 523         candidate['location_id'] = 'some_location_id'
 524         candidate['inventory_type'] = 'service'
 525         initial_candidate = copy.deepcopy(candidate)
 526         complex_list_empty = dict()
 527         complex_list = list()
 528         complex_list.append({"link": "/aai/v14/cloud-infrastructure/complexes/complex/clli1", "d_value": 'clli1'})
 529         complex_list.append({"link": "/aai/v14/cloud-infrastructure/complexes/complex/clli2", "d_value": 'clli2'})
 530
 531         self.mock_get_complex = mock.patch.object(AAI, '_get_complex', return_value=complex_response)
 532         self.mock_get_complex.start()
 533
 534         self.aai_ep.build_complex_info_for_candidate(candidate['candidate_id'], candidate['location_id'], None, complex_list_empty, candidate['inventory_type'], demand_name,
 535                                                      triage_translator_data)
 536         self.assertEqual(initial_candidate, candidate)
 537         self.assertEqual(1, TraigeTranslator.collectDroppedCandiate.call_count)
 538
 539         self.aai_ep.build_complex_info_for_candidate(candidate['candidate_id'], candidate['location_id'], None, complex_list, candidate['inventory_type'], demand_name,
 540                                                      triage_translator_data)
 541         self.assertEqual(initial_candidate, candidate)
 542         self.assertEqual(2, TraigeTranslator.collectDroppedCandiate.call_count)
 543
 544         complex_list.pop()
 545         self.aai_ep.build_complex_info_for_candidate(candidate['candidate_id'], candidate['location_id'], None, complex_list, candidate['inventory_type'], demand_name,
 546                                                      triage_translator_data)
 547
 548         self.assertEqual(self.aai_ep.build_complex_info_for_candidate(candidate['candidate_id'], candidate['location_id'], None, complex_list, candidate['inventory_type'], demand_name,
 549                                                      triage_translator_data), {'city': u'example-city-val-27150', 'country': u'example-country-val-94173',
 550                                      'region': u'example-region-val-13893', 'longitude': u'32.89948', 'state': u'example-state-val-59487',
 551                                      'physical_location_id': 'clli1', 'latitude': u'example-latitude-val-89101',
 552                                      'complex_name': u'clli1'})
 553         self.assertEqual(2, TraigeTranslator.collectDroppedCandiate.call_count)
 554
 555     def test_resolve_vnf_parameters(self):
 556         TraigeTranslator.collectDroppedCandiate = mock.MagicMock(return_value=None)
 557         triage_translator_data = None
 558         demand_name = 'vPGN'
 559         service_type = 'vFW'
 560         candidate = dict()
 561         candidate_id = 'some_id'
 562         location_id = 'some_location_id'
 563         candidate['inventory_type'] = 'service'
 564
 565         generic_vnf_list_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_service_generic_vnf_list.json'
 566         good_vnf = json.loads(open(generic_vnf_list_file).read())[0]
 567         bad_generic_vnf_list_file = './conductor/tests/unit/data/plugins/inventory_provider/bad_generic_vnf_list.json'
 568         bad_vnf = json.loads(open(bad_generic_vnf_list_file).read())[0]
 569         region_response_file = './conductor/tests/unit/data/plugins/inventory_provider/vfmodule_region.json'
 570         region_response = json.loads(open(region_response_file).read())
 571
 572         regions = list()
 573         regions.append(region_response)
 574         self.mock_get_regions = mock.patch.object(AAI, 'resolve_cloud_regions_by_cloud_region_id',
 575                                                   return_value=regions)
 576         self.mock_get_regions.start()
 577
 578         good_cloud_info = self.aai_ep.resolve_cloud_for_vnf(candidate_id, location_id, good_vnf, service_type,
 579                                                                  demand_name, triage_translator_data)
 580         bad_cloud_info = self.aai_ep.resolve_cloud_for_vnf(candidate_id, location_id, bad_vnf, service_type,
 581                                                                  demand_name, triage_translator_data)
 582         self.assertEqual("CloudOwner", good_cloud_info['cloud_owner'])
 583         self.assertEqual("RegionOne", good_cloud_info['location_id'])
 584         self.assertEqual("1", good_cloud_info['cloud_region_version'])
 585
 586         self.assertIsNone(bad_cloud_info)
 587
 588         v_server_links = list()
 589         v_server_links.append("/aai/v14/cloud-infrastructure/cloud-regions/cloud-region/CloudOwner/RegionOne/tenants/\
 590 tenant/3c6c471ada7747fe8ff7f28e100b61e8/vservers/vserver/00bddefc-126e-4e4f-a18d-99b94d8d9a30")
 591         v_server_links.append("/aai/v14/cloud-infrastructure/cloud-regions/cloud-region/CloudOwner2/RegionOne2/tenants/\
 592 tenant/3c6c471ada7747fe8ff7f28e100b61e8/vservers/vserver/00bddefc-126e-4e4f-a18d-99b94d8d9a31")
 593         self.assertEqual(v_server_links, self.aai_ep.resolve_v_server_links_for_vnf(bad_vnf))
 594
 595         customer_id = 'Demonstration'
 596         self.assertEqual(customer_id,
 597                          self.aai_ep.resolve_global_customer_id_for_vnf(candidate_id, location_id, good_vnf, customer_id, service_type,
 598                                                                         demand_name,
 599                                                                         triage_translator_data).get('d_value'))
 600         self.assertEqual("3e8d118c-10ca-4b4b-b3db-089b5e9e6a1c",
 601                          self.aai_ep.resolve_service_instance_id_for_vnf(candidate_id, location_id, good_vnf, customer_id, service_type,
 602                                                                          demand_name,
 603                                                                          triage_translator_data).get('d_value'))
 604         self.assertIsNone(self.aai_ep.resolve_service_instance_id_for_vnf(candidate_id, location_id, bad_vnf, customer_id, service_type,
 605                                                                           demand_name, triage_translator_data))
 606
 607     def test_add_passthrough_parameters(self):
 608         triage_translator_data = None
 609
 610         candidate = dict()
 611         candidate['candidate_id'] = 'some_id'
 612         candidate['location_id'] = 'some_location_id'
 613         candidate['inventory_type'] = 'service'
 614
 615         parameters = dict()
 616         parameters['param_one'] = "value"
 617         parameters['param_two'] = "value"
 618
 619         candidate_info = copy.deepcopy(candidate)
 620         candidate_info['passthrough_attributes'] = dict()
 621         candidate_info['passthrough_attributes']['param_one'] = "value"
 622         candidate_info['passthrough_attributes']['param_two'] = "value"
 623
 624         self.aai_ep.add_passthrough_attributes(candidate, parameters, 'demand')
 625         self.assertDictEqual(candidate, candidate_info)
 626
 627     def test_match_candidate_by_list(self):
 628         TraigeTranslator.collectDroppedCandiate = mock.MagicMock(return_value=None)
 629         triage_translator_data = None
 630
 631         candidate = dict()
 632         candidate['candidate_id'] = 'some_id'
 633         candidate['location_id'] = 'some_location_id'
 634         candidate['inventory_type'] = 'service'
 635
 636         candidate_list_empty = list()
 637         candidate_list = list()
 638         candidate_info = copy.deepcopy(candidate)
 639         candidate_info['candidate_id'] = list()
 640         candidate_info['candidate_id'].append(candidate['candidate_id'])
 641         candidate_list.append(candidate_info)
 642
 643         self.assertFalse(self.aai_ep.match_candidate_by_list(candidate, candidate_list_empty, True, 'demand',
 644                                                              triage_translator_data)),
 645         self.assertEqual(0, TraigeTranslator.collectDroppedCandiate.call_count)
 646         self.assertTrue(self.aai_ep.match_candidate_by_list(candidate, candidate_list, True, 'demand',
 647                                                             triage_translator_data))
 648         self.assertEqual(1, TraigeTranslator.collectDroppedCandiate.call_count)
 649         self.assertTrue(self.aai_ep.match_candidate_by_list(candidate, candidate_list, False, 'demand',
 650                                                             triage_translator_data))
 651         self.assertEqual(1, TraigeTranslator.collectDroppedCandiate.call_count)
 652         self.assertFalse(self.aai_ep.match_candidate_by_list(candidate, candidate_list_empty, False, 'demand',
 653                                                              triage_translator_data))
 654         self.assertEqual(2, TraigeTranslator.collectDroppedCandiate.call_count)
 655
 656     def test_match_hpa(self):
 657         flavor_json_file = \
 658             './conductor/tests/unit/data/plugins/inventory_provider/hpa_flavors.json'
 659         flavor_json = json.loads(open(flavor_json_file).read())
 660         feature_json_file = \
 661             './conductor/tests/unit/data/plugins/inventory_provider/hpa_req_features.json'
 662         feature_json = json.loads(open(feature_json_file).read())
 663         candidate_json_file = './conductor/tests/unit/data/candidate_list.json'
 664         candidate_json = json.loads(open(candidate_json_file).read())
 665         candidate_json['candidate_list'][1]['flavors'] = flavor_json
 666
 667         flavor_map = {
 668             "directives": [],
 669             "flavor_map": {"flavor-id": "f5aa2b2e-3206-41b6-80d5-cf041b098c43",
 670                            "flavor-name": "flavor-cpu-pinning-ovsdpdk-instruction-set",
 671                            "score": 0}}
 672         self.assertEqual(flavor_map,
 673                          self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
 674                                                feature_json[0]))
 675
 676         flavor_map = {"flavor_map": {"flavor-id": "f5aa2b2e-3206-41b6-80d5-cf041b098c43",
 677                                      "flavor-name": "flavor-cpu-ovsdpdk-instruction-set",
 678                                      "score": 10},
 679                       "directives": []}
 680         self.assertEqual(flavor_map,
 681                          self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
 682                                                feature_json[1]))
 683         flavor_map = {"flavor_map": {"flavor-id": "f5aa2b2e-3206-41b6-80d5-cf6t2b098c43",
 684                                      "flavor-name": "flavor-ovsdpdk-cpu-pinning-sriov-NIC-Network-set",
 685                                      "score": 13},
 686                       "directives": [{
 687                           "type": "sriovNICNetwork_directives",
 688                           "attributes": [
 689                               {
 690                                   "attribute_name": "A",
 691                                   "attribute_value": "a"
 692                               }
 693                           ]
 694                       }]}
 695         self.assertEqual(flavor_map,
 696                          self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
 697                                                feature_json[2]))
 698         self.assertEqual(None, self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
 699                                                      feature_json[3]))
 700         flavor_map = {"flavor_map": {"flavor-id": "f5aa2b2e-3206-41b6-19d5-cf6t2b098c43",
 701                                      "flavor-name": "flavor-ovsdpdk-cpu-pinning-double-sriov-NIC-Network-set",
 702                                      "score": 6},
 703                       "directives": [
 704                           {
 705                               "type": "sriovNICNetwork_directives",
 706                               "attributes": [
 707                                   {
 708                                       "attribute_name": "A",
 709                                       "attribute_value": "a"
 710                                   }
 711                               ]
 712                           },
 713                           {
 714                               "type": "sriovNICNetwork_directives",
 715                               "attributes": [
 716                                   {
 717                                       "attribute_name": "B",
 718                                       "attribute_value": "b"
 719                                   }
 720                               ]
 721                           }]
 722                       }
 723         self.assertEqual(flavor_map, self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
 724                                                            feature_json[4]))
 725         self.assertEqual(None, self.aai_ep.match_hpa(candidate_json['candidate_list'][1],
 726                                                      feature_json[5]))
 727
 728     def test_filter_nssi_candidates(self):
 729         nssi_response_file = './conductor/tests/unit/data/plugins/inventory_provider/nssi_response.json'
 730         nssi_response = json.loads(open(nssi_response_file).read())
 731         nssi_candidates_file = './conductor/tests/unit/data/plugins/inventory_provider/nssi_candidate.json'
 732         nssi_candidates = json.loads(open(nssi_candidates_file).read())
 733
 734         service_role = 'nssi'
 735         second_level_filter = dict()
 736         second_level_filter['service-role'] = service_role
 737         default_attributes = dict()
 738         default_attributes['creation_cost'] =1
 739         self.assertEqual(nssi_candidates, self.aai_ep.filter_nxi_candidates(nssi_response, second_level_filter,
 740                                                                             default_attributes, "true", service_role))
 741
 742         nssi_response['service-instance'][0]['service-role'] = 'service'
 743
 744         self.assertEqual([], self.aai_ep.filter_nxi_candidates(nssi_response, second_level_filter, default_attributes,
 745                                                                "true", service_role))
 746
 747         self.assertEqual([], self.aai_ep.filter_nxi_candidates(None, second_level_filter, default_attributes,
 748                                                                "true", service_role))
 749
 750         self.assertEqual([], self.aai_ep.filter_nxi_candidates(None, None, default_attributes, "true", service_role))
 751
 752         self.assertEqual(nssi_candidates, self.aai_ep.filter_nxi_candidates(nssi_response, None, default_attributes,
 753                                                                             "true", service_role))
 754         del nssi_candidates[0]['creation_cost']
 755         self.assertEqual(nssi_candidates, self.aai_ep.filter_nxi_candidates(nssi_response, None, None, "true",
 756                                                                             service_role))
 757
 758     def test_resolve_demands_inventory_type_nssi(self):
 759         self.aai_ep.conf.HPA_enabled = True
 760         TraigeTranslator.getPlanIdNAme = mock.MagicMock(return_value=None)
 761         TraigeTranslator.addDemandsTriageTranslator = mock.MagicMock(return_value=None)
 762
 763         plan_info = {
 764             'plan_name': 'name',
 765             'plan_id': 'id'
 766         }
 767         triage_translator_data = None
 768
 769         demands_list_file = './conductor/tests/unit/data/plugins/inventory_provider/nssi_demand_list.json'
 770         demands_list = json.loads(open(demands_list_file).read())
 771
 772         nssi_response_file = './conductor/tests/unit/data/plugins/inventory_provider/nssi_response.json'
 773         nssi_response = json.loads(open(nssi_response_file).read())
 774         nssi_candidates_file = './conductor/tests/unit/data/plugins/inventory_provider/nssi_candidate.json'
 775         nssi_candidates = json.loads(open(nssi_candidates_file).read())
 776         result = dict()
 777         result['embb_cn'] = nssi_candidates
 778
 779         self.mock_get_nxi_candidates = mock.patch.object(AAI, 'get_nxi_candidates',
 780                                                          return_value=nssi_response)
 781         self.mock_get_nxi_candidates.start()
 782
 783         self.assertEqual(result, self.aai_ep.resolve_demands(demands_list, plan_info=plan_info,
 784                                                              triage_translator_data=triage_translator_data))