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