genericparser/packages/tests/test_vnfpackage.py

   1 # Copyright 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 rest_framework.test import APIClient
  18 from django.test import TestCase
  19 from rest_framework import status
  20 from genericparser.packages.biz.sdc_vnf_package import NfDistributeThread, NfPkgDeleteThread
  21 from genericparser.pub.database.models import JobStatusModel, JobModel
  22 from genericparser.pub.database.models import VnfPackageModel
  23 from genericparser.pub.msapi import sdc
  24 from genericparser.pub.utils import restcall, toscaparsers
  25
  26
  27 class TestNfPackage(TestCase):
  28     def setUp(self):
  29         self.client = APIClient()
  30         VnfPackageModel.objects.filter().delete()
  31         JobModel.objects.filter().delete()
  32         JobStatusModel.objects.filter().delete()
  33         self.vnfd_data = {
  34             "volume_storages": [
  35                 {
  36                     "properties": {
  37                         "size_of_storage": {
  38                             "factor": 10,
  39                             "value": 10000000000,
  40                             "unit": "GB",
  41                             "unit_size": 1000000000
  42                         },
  43                         "type_of_storage": "volume",
  44                         "rdma_enabled": False,
  45                         "size": "10 GB"
  46                     },
  47                     "volume_storage_id": "vNAT_Storage_6wdgwzedlb6sq18uzrr41sof7",
  48                     "description": ""
  49                 }
  50             ],
  51             "inputs": {},
  52             "vdus": [
  53                 {
  54                     "volume_storages": [
  55                         "vNAT_Storage_6wdgwzedlb6sq18uzrr41sof7"
  56                     ],
  57                     "description": "",
  58                     "dependencies": [],
  59                     "vls": [],
  60                     "properties": {
  61                         "name": "vNat",
  62                         "configurable_properties": {
  63                             "test": {
  64                                 "additional_vnfc_configurable_properties": {
  65                                     "aaa": "1",
  66                                     "bbb": "2",
  67                                     "ccc": "3"
  68                                 }
  69                             }
  70                         },
  71                         "description": "the virtual machine of vNat",
  72                         "nfvi_constraints": [
  73                             "test"
  74                         ],
  75                         "boot_order": [
  76                             "vNAT_Storage"
  77                         ]
  78                     },
  79                     "vdu_id": "vdu_vNat",
  80                     "artifacts": [
  81                         {
  82                             "artifact_name": "vNatVNFImage",
  83                             "type": "tosca.artifacts.nfv.SwImage",
  84                             "properties": {
  85                                 "operating_system": "linux",
  86                                 "sw_image": "/swimages/vRouterVNF_ControlPlane.qcow2",
  87                                 "name": "vNatVNFImage",
  88                                 "container_format": "bare",
  89                                 "min_ram": "1 GB",
  90                                 "disk_format": "qcow2",
  91                                 "supported_virtualisation_environments": [
  92                                     "test_0"
  93                                 ],
  94                                 "version": "1.0",
  95                                 "checksum": "5000",
  96                                 "min_disk": "10 GB",
  97                                 "size": "10 GB"
  98                             },
  99                             "file": "/swimages/vRouterVNF_ControlPlane.qcow2"
 100                         }
 101                     ],
 102                     "nfv_compute": {
 103                         "flavor_extra_specs": {
 104                             "hw:cpu_sockets": "2",
 105                             "sw:ovs_dpdk": "true",
 106                             "hw:cpu_threads": "2",
 107                             "hw:numa_mem.1": "3072",
 108                             "hw:numa_mem.0": "1024",
 109                             "hw:numa_nodes": "2",
 110                             "hw:numa_cpus.0": "0,1",
 111                             "hw:numa_cpus.1": "2,3,4,5",
 112                             "hw:cpu_cores": "2",
 113                             "hw:cpu_threads_policy": "isolate"
 114                         },
 115                         "cpu_frequency": "2.4 GHz",
 116                         "num_cpus": 2,
 117                         "mem_size": "10 GB"
 118                     },
 119                     "local_storages": [],
 120                     "image_file": "vNatVNFImage",
 121                     "cps": []
 122                 }
 123             ],
 124             "image_files": [
 125                 {
 126                     "properties": {
 127                         "operating_system": "linux",
 128                         "sw_image": "/swimages/vRouterVNF_ControlPlane.qcow2",
 129                         "name": "vNatVNFImage",
 130                         "container_format": "bare",
 131                         "min_ram": "1 GB",
 132                         "disk_format": "qcow2",
 133                         "supported_virtualisation_environments": [
 134                             "test_0"
 135                         ],
 136                         "version": "1.0",
 137                         "checksum": "5000",
 138                         "min_disk": "10 GB",
 139                         "size": "10 GB"
 140                     },
 141                     "image_file_id": "vNatVNFImage",
 142                     "description": ""
 143                 }
 144             ],
 145             "routers": [],
 146             "local_storages": [],
 147             "vnf_exposed": {
 148                 "external_cps": [
 149                     {
 150                         "key_name": "sriov_plane",
 151                         "cp_id": "SRIOV_Port"
 152                     }
 153                 ],
 154                 "forward_cps": []
 155             },
 156             "vls": [
 157                 {
 158                     "route_id": "",
 159                     "vl_id": "sriov_link",
 160                     "route_external": False,
 161                     "description": "",
 162                     "properties": {
 163                         "vl_flavours": {
 164                             "vl_id": "aaaa"
 165                         },
 166                         "connectivity_type": {
 167                             "layer_protocol": "ipv4",
 168                             "flow_pattern": "flat"
 169                         },
 170                         "description": "sriov_link",
 171                         "test_access": [
 172                             "test"
 173                         ]
 174                     }
 175                 }
 176             ],
 177             "cps": [
 178                 {
 179                     "vl_id": "sriov_link",
 180                     "vdu_id": "vdu_vNat",
 181                     "description": "",
 182                     "cp_id": "SRIOV_Port",
 183                     "properties": {
 184                         "address_data": [
 185                             {
 186                                 "address_type": "ip_address",
 187                                 "l3_address_data": {
 188                                     "ip_address_type": "ipv4",
 189                                     "floating_ip_activated": False,
 190                                     "number_of_ip_address": 1,
 191                                     "ip_address_assignment": True
 192                                 }
 193                             }
 194                         ],
 195                         "description": "sriov port",
 196                         "layer_protocol": "ipv4",
 197                         "virtual_network_interface_requirements": [
 198                             {
 199                                 "requirement": {
 200                                     "SRIOV": "true"
 201                                 },
 202                                 "support_mandatory": False,
 203                                 "name": "sriov",
 204                                 "description": "sriov"
 205                             },
 206                             {
 207                                 "requirement": {
 208                                     "SRIOV": "False"
 209                                 },
 210                                 "support_mandatory": False,
 211                                 "name": "normal",
 212                                 "description": "normal"
 213                             }
 214                         ],
 215                         "role": "root",
 216                         "bitrate_requirement": 10
 217                     }
 218                 }
 219             ],
 220             "metadata": {
 221                 "vnfSoftwareVersion": "1.0.0",
 222                 "vnfProductName": "zte",
 223                 "localizationLanguage": [
 224                     "english",
 225                     "chinese"
 226                 ],
 227                 "vnfProvider": "zte",
 228                 "vnfmInfo": "zte",
 229                 "defaultLocalizationLanguage": "english",
 230                 "vnfdId": "zte-hss-1.0",
 231                 "id": "zte-hss-1.0",
 232                 "vnfProductInfoDescription": "hss",
 233                 "vnfdVersion": "1.0.0",
 234                 "vnfProductInfoName": "hss"
 235             },
 236             "vnf": {
 237                 "properties": {
 238                     "descriptor_id": "zte-hss-1.0",
 239                     "descriptor_verison": "1.0.0",
 240                     "software_version": "1.0.0",
 241                     "provider": "zte"
 242                 },
 243                 "metadata": {
 244                 }
 245             }
 246         }
 247
 248     def tearDown(self):
 249         pass
 250
 251     def assert_job_result(self, job_id, job_progress, job_detail):
 252         jobs = JobStatusModel.objects.filter(
 253             jobid=job_id,
 254             progress=job_progress,
 255             descp=job_detail)
 256         self.assertEqual(1, len(jobs))
 257
 258     @mock.patch.object(NfDistributeThread, 'run')
 259     def test_nf_pkg_distribute_normal(self, mock_run):
 260         resp = self.client.post("/api/parser/v1/vnfpackages", {
 261             "csarId": "1",
 262             "vimIds": ["1"]
 263         }, format='json')
 264         self.assertEqual(resp.status_code, status.HTTP_202_ACCEPTED)
 265
 266     def test_nf_pkg_distribute_when_csar_already_exist(self):
 267         VnfPackageModel(vnfPackageId="1", vnfdId="vcpe_vfw_zte_1_0").save()
 268         NfDistributeThread(csar_id="1",
 269                            vim_ids=["1"],
 270                            lab_vim_id="",
 271                            job_id="2").run()
 272         self.assert_job_result("2", 255, "NF CSAR(1) already exists.")
 273
 274     @mock.patch.object(restcall, 'call_req')
 275     @mock.patch.object(sdc, 'download_artifacts')
 276     @mock.patch.object(toscaparsers, 'parse_vnfd')
 277     def test_nf_pkg_distribute_when_vnfd_already_exist(self,
 278                                                        mock_parse_vnfd, mock_download_artifacts, mock_call_req):
 279         mock_parse_vnfd.return_value = json.JSONEncoder().encode(self.vnfd_data)
 280         mock_download_artifacts.return_value = "/home/hss.csar"
 281         mock_call_req.return_value = [0, json.JSONEncoder().encode([{
 282             "uuid": "1",
 283             "toscaModelURL": "https://127.0.0.1:1234/sdc/v1/hss.csar"
 284         }]), '200']
 285         VnfPackageModel(vnfPackageId="2", vnfdId="zte-hss-1.0").save()
 286         NfDistributeThread(csar_id="1",
 287                            vim_ids=["1"],
 288                            lab_vim_id="",
 289                            job_id="2").run()
 290         self.assert_job_result("2", 255, "VNF package(zte-hss-1.0) already exists.")
 291
 292     @mock.patch.object(restcall, 'call_req')
 293     @mock.patch.object(sdc, 'download_artifacts')
 294     @mock.patch.object(toscaparsers, 'parse_vnfd')
 295     def test_nf_pkg_distribute_successfully(self,
 296                                             mock_parse_vnfd, mock_download_artifacts, mock_call_req):
 297         mock_parse_vnfd.return_value = json.JSONEncoder().encode(self.vnfd_data)
 298         mock_download_artifacts.return_value = "/home/hss.csar"
 299         mock_call_req.return_value = [0, json.JSONEncoder().encode([{
 300             "uuid": "1",
 301             "toscaModelURL": "https://127.0.0.1:1234/sdc/v1/hss.csar"
 302         }]), '200']
 303         NfDistributeThread(csar_id="1",
 304                            vim_ids=["1"],
 305                            lab_vim_id="",
 306                            job_id="4").run()
 307         self.assert_job_result("4", 100, "CSAR(1) distribute successfully.")
 308
 309     ###############################################################################################################
 310
 311     @mock.patch.object(NfPkgDeleteThread, 'run')
 312     def test_nf_pkg_delete_normal(self, mock_run):
 313         resp = self.client.delete("/api/parser/v1/vnfpackages/1")
 314         self.assertEqual(resp.status_code, status.HTTP_202_ACCEPTED)
 315
 316     def test_nf_pkg_normal_delete(self):
 317         VnfPackageModel(vnfPackageId="2", vnfdId="vcpe_vfw_zte_1_0").save()
 318         NfPkgDeleteThread(csar_id="2", job_id="2").run()
 319         self.assert_job_result("2", 100, "Delete CSAR(2) successfully.")
 320
 321     def test_nf_pkg_get_all(self):
 322         VnfPackageModel(vnfPackageId="3", vnfdId="3", vnfVendor='3', vnfdVersion='3',
 323                         vnfSoftwareVersion='', vnfPackageUri='', vnfdModel='').save()
 324         VnfPackageModel(vnfPackageId="4", vnfdId="4", vnfVendor='4', vnfdVersion='4',
 325                         vnfSoftwareVersion='', vnfPackageUri='', vnfdModel='').save()
 326         resp = self.client.get("/api/parser/v1/vnfpackages")
 327         self.assertEqual(resp.status_code, status.HTTP_200_OK)
 328         expect_data = [
 329             {
 330                 "imageInfo": [],
 331                 "csarId": "3",
 332                 "packageInfo": {
 333                     "csarName": "",
 334                     "vnfdModel": "",
 335                     "vnfdProvider": "3",
 336                     "vnfdId": "3",
 337                     "downloadUrl": "http://127.0.0.1:8806/static/genericparser/3/",
 338                     "vnfVersion": "",
 339                     "vnfdVersion": "3",
 340                     "vnfPackageId": "3"
 341                 }
 342             },
 343             {
 344                 "imageInfo": [],
 345                 "csarId": "4",
 346                 "packageInfo": {
 347                     "csarName": "",
 348                     "vnfdModel": "",
 349                     "vnfdProvider": "4",
 350                     "vnfdId": "4",
 351                     "downloadUrl": "http://127.0.0.1:8806/static/genericparser/4/",
 352                     "vnfVersion": "",
 353                     "vnfdVersion": "4",
 354                     "vnfPackageId": "4"
 355                 }
 356             }
 357         ]
 358         self.assertEqual(expect_data, resp.data)
 359
 360     def test_nf_pkg_get_one(self):
 361         VnfPackageModel(vnfPackageId="4", vnfdId="4", vnfVendor='4', vnfdVersion='4',
 362                         vnfSoftwareVersion='', vnfPackageUri='', vnfdModel='').save()
 363
 364         resp = self.client.get("/api/parser/v1/vnfpackages/4")
 365         self.assertEqual(resp.status_code, status.HTTP_200_OK)
 366         expect_data = {
 367             "imageInfo": [],
 368             "csarId": "4",
 369             "packageInfo": {
 370                 "csarName": "",
 371                 "vnfdModel": "",
 372                 "vnfdProvider": "4",
 373                 "vnfdId": "4",
 374                 "downloadUrl": "http://127.0.0.1:8806/static/genericparser/4/",
 375                 "vnfVersion": "",
 376                 "vnfdVersion": "4",
 377                 "vnfPackageId": "4"
 378             }
 379         }
 380         self.assertEqual(expect_data, resp.data)
 381
 382     def test_nf_pkg_get_one_failed(self):
 383         VnfPackageModel(vnfPackageId="4", vnfdId="4", vnfVendor='4', vnfdVersion='4',
 384                         vnfSoftwareVersion='', vnfPackageUri='', vnfdModel='').save()
 385
 386         resp = self.client.get("/api/parser/v1/vnfpackages/2")
 387         self.assertEqual(resp.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
 388         self.assertEqual({'error': 'Vnf package[2] not Found.'}, resp.data)
 389
 390     ###############################################################################################################
 391
 392     @mock.patch.object(toscaparsers, 'parse_vnfd')
 393     def test_vnfd_parse_normal(self, mock_parse_vnfd):
 394         VnfPackageModel(vnfPackageId="8", vnfdId="10").save()
 395         mock_parse_vnfd.return_value = json.JSONEncoder().encode({"c": "d"})
 396         req_data = {"csarId": "8", "inputs": []}
 397         resp = self.client.post("/api/parser/v1/parservnfd", req_data, format='json')
 398         self.assertEqual(resp.status_code, status.HTTP_202_ACCEPTED)
 399         self.assertEqual({"model": '{"c": "d"}'}, resp.data)
 400
 401     def test_vnfd_parse_when_csar_not_exist(self):
 402         req_data = {"csarId": "1", "inputs": []}
 403         resp = self.client.post("/api/parser/v1/parservnfd", req_data, format='json')
 404         self.assertEqual(resp.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
 405         self.assertEqual(resp.data, {"error": "VNF CSAR(1) does not exist."})