zte/vmanager/driver/interfaces/tests.py

   1 # Copyright 2016-2017 ZTE Corporation.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import json
  16 import mock
  17 from django.test import Client
  18 from django.test import TestCase
  19 from rest_framework import status
  20 from driver.pub.utils import restcall
  21
  22
  23 class InterfacesTest(TestCase):
  24     def setUp(self):
  25         self.client = Client()
  26
  27     def tearDown(self):
  28         pass
  29
  30     # @mock.patch.object(restcall, 'call_req_aai')
  31     @mock.patch.object(restcall, 'call_req')
  32     def test_instantiate_vnf_001(self, mock_call_req):
  33         """
  34         Initate_VNF
  35         """
  36         vnfm_info = {u'userName': u'admin',
  37                      u'vendor': u'ZTE',
  38                      u'name': u'ZTE_VNFM_237_62',
  39                      u'vimId': u'516cee95-e8ca-4d26-9268-38e343c2e31e',
  40                      u'url': u'http://192.168.237.165:2324',
  41                      u'certificateUrl': u'',
  42                      u'version': u'V1.0',
  43                      u'vnfmId': u'b0797c9b-3da9-459c-b25c-3813e9d8fd70',
  44                      u'password': u'admin',
  45                      u'type': u'ztevmanagerdriver',
  46                      u'createTime': u'2016-10-31 11:08:39',
  47                      u'description': u''}
  48         vnfd_info = {u'vnfInstanceInfo': [{u'vnfInstanceId': u'59b79a9f-9e37-4f6c-acaf-5f41d9cb3f76',
  49                                            u'vnfInstanceName': u'VFW_59b79a9f-9e37-4f6c-acaf-5f41d9cb3f76'},
  50                                           {u'vnfInstanceId': u'6c5e4bd3-e8a6-42d8-a7a4-53a8ef74c6ac',
  51                                            u'vnfInstanceName': u'VFW_6c5e4bd3-e8a6-42d8-a7a4-53a8ef74c6ac'},
  52                                           {u'vnfInstanceId': u'930de5c9-8043-41df-ace8-ede2262a3713',
  53                                            u'vnfInstanceName': u'VFW_930de5c9-8043-41df-ace8-ede2262a3713'},
  54                                           {u'vnfInstanceId': u'c677a305-a7bd-4baf-9eee-c383c588bb3c',
  55                                            u'vnfInstanceName': u'VFW_c677a305-a7bd-4baf-9eee-c383c588bb3c'},
  56                                           {u'vnfInstanceId': u'e708e5c5-bdf4-436a-b928-826887806d82',
  57                                            u'vnfInstanceName': u'VFW_e708e5c5-bdf4-436a-b928-826887806d82'}],
  58                      u'csarId': u'd852e1be-0aac-48f1-b1a4-cd825f6cdf9a',
  59                      u'imageInfo': [
  60                          {u'status': u'Enable', u'index': u'0',
  61                           u'vimId': u'516cee95-e8ca-4d26-9268-38e343c2e31e',
  62                           u'fileName': u'VFW_IMAGE_VCPE_ZTE',
  63                           u'vimUser': u'admin',
  64                           u'imageId': u'd2b73154-0414-466a-a1e6-51b9461b753a',
  65                           u'tenant': u'admin'}],
  66                      u'packageInfo': {u'usageState': u'NotInUse',
  67                                       u'onBoardState': u'onBoarded',
  68                                       u'name': u'VFW',
  69                                       u'format': u'yaml',
  70                                       u'provider': u'ZTE',
  71                                       u'vnfdProvider': u'zte',
  72                                       u'vnfdId': u'vcpe_vfw_zte_1_0',
  73                                       u'deletionPending': False,
  74                                       u'version': u'v1.0',
  75                                       u'vnfVersion': u'1.0',
  76                                       u'vnfdVersion': u'1.0.0',
  77                                       u'processState': u'normal',
  78                                       u'modifyTime': u'2016-10-31 16:21:32',
  79                                       u'downloadUri': u'http://192.168.233.226:80/',
  80                                       u'operationalState': u'Disabled',
  81                                       u'createTime': u'2016-10-31 16:21:11',
  82                                       u'size': u'12.1 MB'}}
  83         packageInfo = {
  84             "size": "12.1 MB",
  85             "usageState": "NotInUse",
  86             "onBoardState": "onBoarded",
  87             "name": "VFW",
  88             "format": "yaml",
  89             "packageInfo": {
  90                 "vnfdModel": json.dumps({"metadata": {"name": "ZTE-MME-FIX-VL"}})
  91             },
  92             "modifyTime": "2016-10-31 16:21:32",
  93             "vnfdProvider": "zte",
  94             "vnfdId": "vcpe_vfw_zte_1_0",
  95             "deletionPending": False,
  96             "version": "v1.0",
  97             "vnfVersion": "1.0",
  98             "vnfdVersion": "1.0.0",
  99             "processState": "normal",
 100             "provider": "ZTE",
 101             "operationalState": "Disabled",
 102             "createTime": "2016-10-31 16:21:11",
 103             "downloadUri": "http://192.168.233.226:80/files/catalog-http/NFAR/ZTE/VFW/v1.0/VFW.csar"
 104         }
 105
 106         inst_response = {
 107             u'vnfInstanceId': u'8',
 108             u'jobid': u'NF-CREATE-8-b384535c-9f45-11e6-8749-fa163e91c2f9'
 109         }
 110         ret = [0, json.JSONEncoder().encode(inst_response), '200']
 111
 112         r1 = [0, json.JSONEncoder().encode(vnfm_info), "200"]
 113
 114         r2 = [0, json.JSONEncoder().encode(vnfd_info), "200"]
 115
 116         r3 = [0, json.JSONEncoder().encode(packageInfo), "200"]
 117
 118         # mock_call_req_aai.side_effect =[r1]
 119         mock_call_req.side_effect = [r1, r2, r3, ret]
 120
 121         req_data = {
 122             'vnfInstanceName': 'VFW_f88c0cb7-512a-44c4-bd09-891663f19367',
 123             'vnfPackageId': 'd852e1be-0aac-48f1-b1a4-cd825f6cdf9a',
 124             'vnfDescriptorId': 'vcpe_vfw_zte_1_0',
 125             'additionalParam': {
 126                 'sdncontroller': 'e4d637f1-a4ec-4c59-8b20-4e8ab34daba9',
 127                 'NatIpRange': '192.167.0.10-192.168.0.20',
 128                 'm6000_mng_ip': '192.168.11.11',
 129                 'externalPluginManageNetworkName': 'plugin_net_2014',
 130                 'location': '516cee95-e8ca-4d26-9268-38e343c2e31e',
 131                 'externalManageNetworkName': 'mng_net_2017',
 132                 'sfc_data_network': 'sfc_data_net_2016',
 133                 'externalDataNetworkName': 'Flow_out_net',
 134                 'inputs': {}
 135             }
 136         }
 137
 138         response = self.client.post("/api/ztevmanagerdriver/v1/ztevnfmid/vnfs",
 139                                     data=json.dumps(req_data), content_type="application/json")
 140         self.assertEqual(str(status.HTTP_200_OK), response.status_code)
 141         expect_resp_data = {"jobid": "NF-CREATE-8-b384535c-9f45-11e6-8749-fa163e91c2f9", "vnfInstanceId": "8"}
 142         self.assertEqual(expect_resp_data, response.data)
 143
 144     # @mock.patch.object(restcall, 'call_req_aai')
 145     @mock.patch.object(restcall, 'call_req')
 146     def test_terminate_vnf__002(self, mock_call_req):
 147         """
 148         Terminate_VNF
 149         """
 150         r1 = [0, json.JSONEncoder().encode({
 151             "vnfmId": "19ecbb3a-3242-4fa3-9926-8dfb7ddc29ee",
 152             "name": "g_vnfm",
 153             "type": "vnfm",
 154             "vimId": "",
 155             "vendor": "ZTE",
 156             "version": "v1.0",
 157             "description": "vnfm",
 158             "certificateUrl": "",
 159             "url": "http://10.74.44.11",
 160             "userName": "admin",
 161             "password": "admin",
 162             "createTime": "2016-07-06 15:33:18"}), "200"]
 163
 164         r2 = [0, json.JSONEncoder().encode({"vnfInstanceId": "1", "JobId": "1"}), "200"]
 165         # mock_call_req_aai.side_effect = [r1]
 166         mock_call_req.side_effect = [r1, r2]
 167
 168         response = self.client.post("/api/ztevmanagerdriver/v1/ztevnfmid/vnfs/vbras_innstance_id/terminate")
 169
 170         self.assertEqual(str(status.HTTP_200_OK), response.status_code)
 171         expect_resp_data = {"jobid": "1", "vnfInstanceId": "1"}
 172         self.assertEqual(expect_resp_data, response.data)
 173
 174     # @mock.patch.object(restcall, 'call_req_aai')
 175     @mock.patch.object(restcall, 'call_req')
 176     def test_query_vnf_003(self, mock_call_req):
 177         """
 178         Query_VNF
 179         """
 180         r1 = [0, json.JSONEncoder().encode({
 181             "vnfmId": "19ecbb3a-3242-4fa3-9926-8dfb7ddc29ee",
 182             "name": "g_vnfm",
 183             "type": "vnfm",
 184             "vimId": "",
 185             "vendor": "ZTE",
 186             "version": "v1.0",
 187             "description": "vnfm",
 188             "certificateUrl": "",
 189             "url": "http://10.74.44.11",
 190             "userName": "admin",
 191             "password": "admin",
 192             "createTime": "2016-07-06 15:33:18"}), "200"]
 193
 194         r2 = [0, json.JSONEncoder().encode({"vnfinstancestatus": "1"}), "200"]
 195         # mock_call_req_aai.side_effect = [r1]
 196         mock_call_req.side_effect = [r1, r2]
 197
 198         response = self.client.get("/api/ztevmanagerdriver/v1/ztevnfmid/vnfs/vbras_innstance_id")
 199
 200         self.assertEqual(str(status.HTTP_200_OK), response.status_code)
 201
 202         expect_resp_data = {"vnfInfo": {"vnfStatus": "1"}}
 203         self.assertEqual(expect_resp_data, response.data)
 204
 205     # @mock.patch.object(restcall, 'call_req_aai')
 206     @mock.patch.object(restcall, 'call_req')
 207     def test_operation_status_004(self, mock_call_req):
 208         """
 209         Operation_status
 210         """
 211         vnfm_info = {u'userName': u'admin',
 212                      u'vendor': u'ZTE',
 213                      u'name': u'ZTE_VNFM_237_62',
 214                      u'vimId': u'516cee95-e8ca-4d26-9268-38e343c2e31e',
 215                      u'url': u'http://192.168.237.165:2324',
 216                      u'certificateUrl': u'',
 217                      u'version': u'V1.0',
 218                      u'vnfmId': u'b0797c9b-3da9-459c-b25c-3813e9d8fd70',
 219                      u'password': u'admin',
 220                      u'type': u'ztevmanagerdriver',
 221                      u'createTime': u'2016-10-31 11:08:39',
 222                      u'description': u''}
 223         resp_body = {
 224             "responsedescriptor": {
 225                 "status": "processing",
 226                 "responsehistorylist": [
 227                     {
 228                         "status": "error",
 229                         "progress": 255,
 230                         "errorcode": "",
 231                         "responseid": 20,
 232                         "statusdescription": "'JsonParser' object has no attribute 'parser_info'"
 233                     }
 234                 ],
 235                 "responseid": 21,
 236                 "errorcode": "",
 237                 "progress": 40,
 238                 "statusdescription": "Create nf apply resource failed"
 239             },
 240             "jobid": "NF-CREATE-11-ec6c2f2a-9f48-11e6-9405-fa163e91c2f9"
 241         }
 242         r1 = [0, json.JSONEncoder().encode(vnfm_info), '200']
 243         r2 = [0, json.JSONEncoder().encode(resp_body), '200']
 244         # mock_call_req_aai.side_effect = [r1]
 245         mock_call_req.side_effect = [r1, r2]
 246         response = self.client.get("/api/ztevmanagerdriver/v1/{vnfmid}/jobs/{jobid}?responseId={responseId}".format(
 247             vnfmid=vnfm_info["vnfmId"],
 248             jobid=resp_body["jobid"],
 249             responseId=resp_body["responsedescriptor"]["responseid"])
 250         )
 251
 252         self.assertEqual(str(status.HTTP_200_OK), response.status_code)
 253
 254         expect_resp_data = resp_body
 255         self.assertDictEqual(expect_resp_data, response.data)
 256
 257     @mock.patch.object(restcall, 'call_req')
 258     def test_grantvnf_005(self, mock_call_req):
 259         """
 260         Grant_VNF
 261         """
 262         ret = [0,
 263                '{"vim":{"accessinfo":{"tenant":"admin"},"vimid":"516cee95-e8ca-4d26-9268-38e343c2e31e"}}',
 264                '201']
 265
 266         req_data = {
 267             "vnfmid": "13232222",
 268             "nfvoid": "03212234",
 269             "vimid": "12345678",
 270             "exvimidlist ": [
 271                 "exvimid"
 272             ],
 273             "tenant": " tenant1",
 274             "vnfistanceid": "1234",
 275             "operationright": "0",
 276             "vmlist": [
 277                 {
 278                     "vmflavor": "SMP",
 279                     "vmnumber": "3"
 280                 },
 281                 {
 282                     "vmflavor": "CMP",
 283                     "vmnumber": "3"
 284                 }
 285             ]
 286         }
 287
 288         mock_call_req.return_value = ret
 289         response = self.client.put("/api/ztevmanagerdriver/v1/resource/grant",
 290                                    data=json.dumps(req_data), content_type='application/json')
 291
 292         self.assertEqual(str(status.HTTP_201_CREATED), response.status_code)
 293
 294         expect_resp_data = {
 295             "vimid": "516cee95-e8ca-4d26-9268-38e343c2e31e",
 296             "tenant": "admin"}
 297         self.assertDictEqual(expect_resp_data, response.data)
 298
 299     @mock.patch.object(restcall, 'call_req')
 300     def test_notify_006(self, mock_call_req):
 301         """
 302         Notification
 303         """
 304         r1 = [0, json.JSONEncoder().encode(
 305             {"vim":
 306                 {
 307                     "vimInfoId": "111111",
 308                     "vimId": "12345678",
 309                     "interfaceInfo": {
 310                         "vimType": "vnf",
 311                         "apiVersion": "v1",
 312                         "protocolType": "None"},
 313                     "accessInfo": {
 314                         "tenant": "tenant1",
 315                         "username": "admin",
 316                         "password": "password"},
 317                     "interfaceEndpoint": "http://127.0.0.1/api/v1"},
 318                 "zone": "",
 319                 "addResource": {
 320                     "resourceDefinitionId": "xxxxx",
 321                     "vimId": "12345678",
 322                     "zoneId": "000"},
 323                 "removeResource": "",
 324                 "vimAssets": {
 325                     "computeResourceFlavour": {
 326                         "vimId": "12345678",
 327                         "vduId": "sdfasdf",
 328                         "vimFlavourId": "12"},
 329                     "softwareImage": {
 330                         "vimId": "12345678",
 331                         "imageName": "AAA",
 332                         "vimImageId": ""}},
 333                 "additionalParam": ""
 334              }), "200"]
 335
 336         req_data = {
 337             "nfvoid": "1",
 338             "vnfmid": "876543211",
 339             "vimid": "6543211",
 340             "timestamp": "1234567890",
 341             "vnfinstanceid": "1",
 342             "eventtype": "0",
 343             "vmlist":
 344                 [
 345                     {
 346                         "vmflavor": "SMP",
 347                         "vmnumber": "3",
 348                         "vmidlist ": ["vmuuid"]},
 349                     {
 350                         "vmflavor": "CMP",
 351                         "vmnumber": "3",
 352                         "vmidlist ": ["vmuuid"]}]}
 353         mock_call_req.side_effect = [r1]
 354         response = self.client.post("/api/ztevmanagerdriver/v1/vnfs/lifecyclechangesnotification",
 355                                     data=json.dumps(req_data), content_type='application/json')
 356
 357         self.assertEqual(str(status.HTTP_200_OK), response.status_code)
 358
 359         expect_resp_data = None
 360         self.assertEqual(expect_resp_data, response.data)
 361
 362     # @mock.patch.object(restcall, 'call_req_aai')
 363     @mock.patch.object(restcall, 'call_req')
 364     def test_scale(self, mock_call_req):
 365         job_info = {"jobid": "801", "nfInstanceId": "101"}
 366         vnfm_info = {u'userName': u'admin',
 367                      u'vendor': u'ZTE',
 368                      u'name': u'ZTE_VNFM_237_62',
 369                      u'vimId': u'516cee95-e8ca-4d26-9268-38e343c2e31e',
 370                      u'url': u'http://192.168.237.165:2324',
 371                      u'certificateUrl': u'',
 372                      u'version': u'V1.0',
 373                      u'vnfmId': u'b0797c9b-3da9-459c-b25c-3813e9d8fd70',
 374                      u'password': u'admin',
 375                      u'type': u'ztevmanagerdriver',
 376                      u'createTime': u'2016-10-31 11:08:39',
 377                      u'description': u''}
 378
 379         ret = [0, json.JSONEncoder().encode(job_info), "202"]
 380         ret_vnfm = [0, json.JSONEncoder().encode(vnfm_info), "200"]
 381         # mock_call_req_aai.side_effect = [ret_vnfm]
 382         mock_call_req.side_effect = [ret_vnfm, ret]
 383
 384         vnfd_info = {
 385             "vnf_flavours": [
 386                 {
 387                     "flavour_id": "flavour1",
 388                     "description": "",
 389                     "vdu_profiles": [
 390                         {
 391                             "vdu_id": "vdu1Id",
 392                             "instances_minimum_number": 1,
 393                             "instances_maximum_number": 4,
 394                             "local_affinity_antiaffinity_rule": [
 395                                 {
 396                                     "affinity_antiaffinity": "affinity",
 397                                     "scope": "node",
 398
 399                                 }
 400                             ]
 401                         }
 402                     ],
 403                     "scaling_aspects": [
 404                         {
 405                             "id": "demo_aspect",
 406                             "name": "demo_aspect",
 407                             "description": "demo_aspect",
 408                             "associated_group": "elementGroup1",
 409                             "max_scale_level": 5
 410                         }
 411                     ]
 412                 }
 413             ],
 414             "element_groups": [
 415                 {
 416                     "group_id": "elementGroup1",
 417                     "description": "",
 418                     "properties": {
 419                         "name": "elementGroup1"
 420                     },
 421                     "members": [
 422                         "gsu_vm",
 423                         "pfu_vm"
 424                     ]
 425                 }
 426             ]
 427         }
 428
 429         scale_vnf_data = {
 430             "type": "SCALE_OUT",
 431             "aspectId": "demo_aspect",
 432             "numberOfSteps": "3",
 433             "additionalParam": {
 434                 "vnfdModel": vnfd_info
 435             }
 436         }
 437
 438         response = self.client.post("/api/ztevmanagerdriver/v1/100/vnfs/101/scale",
 439                                     data=json.dumps(scale_vnf_data), content_type='application/json')
 440         self.assertEqual(str(status.HTTP_202_ACCEPTED), response.status_code)
 441         self.assertDictEqual(job_info, response.data)
 442
 443     # @mock.patch.object(restcall, 'call_req_aai')
 444     @mock.patch.object(restcall, 'call_req')
 445     def test_heal(self, mock_call_req):
 446         job_info = {"jobid": "12234455", "nfInstanceId": "10144445666"}
 447         vnfm_info = {u'userName': u'admin',
 448                      u'vendor': u'ZTE',
 449                      u'name': u'ZTE_VNFM_237_62',
 450                      u'vimId': u'516cee95-e8ca-4d26-9268-38e343c2e31e',
 451                      u'url': u'http://192.168.237.165:2324',
 452                      u'certificateUrl': u'',
 453                      u'version': u'V1.0',
 454                      u'vnfmId': u'b0797c9b-3da9-459c-b25c-3813e9d8fd70',
 455                      u'password': u'admin',
 456                      u'type': u'ztevmanagerdriver',
 457                      u'createTime': u'2016-10-31 11:08:39',
 458                      u'description': u''}
 459
 460         ret = [0, json.JSONEncoder().encode(job_info), "202"]
 461         ret_vnfm = [0, json.JSONEncoder().encode(vnfm_info), "200"]
 462         # mock_call_req_aai.side_effect = [ret_vnfm]
 463         mock_call_req.side_effect = [ret_vnfm, ret]
 464
 465         heal_vnf_data = {
 466             'action': 'vmReset',
 467             'affectedvm': [{
 468                 'flavour': {
 469
 470                 },
 471                 'extention': '',
 472                 'vmid': '804cca71-9ae9-4511-8e30-d1387718caff',
 473                 'changtype': 'changed',
 474                 'vduid': 'vdu_100',
 475                 'vmname': 'ZTE_SSS_111_PP_2_L'
 476             }],
 477             'lifecycleoperation': 'operate',
 478             'isgrace': 'force'
 479         }
 480
 481         response = self.client.post("/api/ztevmanagerdriver/v1/200/vnfs/201/heal",
 482                                     data=json.dumps(heal_vnf_data), content_type='application/json')
 483
 484         self.assertEqual(str(status.HTTP_202_ACCEPTED), response.status_code)
 485         self.assertDictEqual(job_info, response.data)