lcm/ns/tests/vls/tests.py

   1 # Copyright 2016 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 uuid
  17
  18 import mock
  19 from django.test import TestCase, Client
  20 from rest_framework import status
  21
  22 from lcm.pub.database.models import VLInstModel, NSInstModel, VNFFGInstModel
  23 from lcm.pub.nfvi.vim import vimadaptor
  24 from lcm.pub.utils import restcall
  25
  26 vim_info = {"cloud-owner": "example-cloud-owner-val-97336",
  27             "cloud-region-id": "example-cloud-region-id-val-35532",
  28             "cloud-type": "example-cloud-type-val-18046",
  29             "owner-defined-type": "example-owner-defined-type-val-9413",
  30             "cloud-region-version": "example-cloud-region-version-val-85706",
  31             "identity-url": "example-identity-url-val-71252",
  32             "cloud-zone": "example-cloud-zone-val-27112",
  33             "complex-name": "example-complex-name-val-85283",
  34             "sriov-automation": True,
  35             "cloud-extra-info": "example-cloud-extra-info-val-90854",
  36             "cloud-epa-caps": "example-cloud-epa-caps-val-2409",
  37             "resource-version": "example-resource-version-val-42094",
  38             "esr-system-info-list": {
  39                 "esr-system-info": [
  40                     {
  41                         "esr-system-info-id": "example-esr-system-info-id-val-7713",
  42                         "system-name": "example-system-name-val-19801",
  43                         "type": "example-type-val-24477",
  44                         "vendor": "example-vendor-val-50079",
  45                         "version": "example-version-val-93146",
  46                         "service-url": "example-service-url-val-68090",
  47                         "user-name": "example-user-name-val-14470",
  48                         "password": "example-password-val-84190",
  49                         "system-type": "example-system-type-val-42773",
  50                         "protocal": "example-protocal-val-85736",
  51                         "ssl-cacert": "example-ssl-cacert-val-33989",
  52                         "ssl-insecure": True,
  53                         "ip-address": "example-ip-address-val-99038",
  54                         "port": "example-port-val-27323",
  55                         "cloud-domain": "example-cloud-domain-val-55163",
  56                         "default-tenant": "example-default-tenant-val-99383",
  57                         "resource-version": "example-resource-version-val-15424"
  58                     }
  59                 ]
  60             }
  61             }
  62
  63 class TestVlViews(TestCase):
  64     def setUp(self):
  65         self.client = Client()
  66         self.ns_inst_id = str(uuid.uuid4())
  67         self.vnffg_id = str(uuid.uuid4())
  68         self.vl_id_1 = 1
  69         self.vl_id_2 = 1
  70         self.vim_id = str(uuid.uuid4())
  71         self.tenant = "tenantname"
  72         properties = {"network_type": "vlan", "name": "externalMNetworkName", "dhcp_enabled": False,
  73                       "location_info": {"host": True, "vimid": self.vim_id, "region": True, "tenant": self.tenant},
  74                       "end_ip": "190.168.100.100", "gateway_ip": "190.168.100.1", "start_ip": "190.168.100.2",
  75                       "cidr": "190.168.100.0/24", "mtu": 1500, "network_name": "sub_mnet", "ip_version": 4}
  76         self.context = {
  77             "vls": [{"vl_id": self.vl_id_1, "description": "", "properties": properties, "route_external": False},
  78                     {"vl_id": self.vl_id_2, "description": "", "properties": properties, "route_external": False}],
  79             "vnffgs": [{"vnffg_id": self.vnffg_id, "description": "",
  80                         "properties": {"vendor": "zte", "version": "1.1.2", "number_of_endpoints": 7,
  81                                        "dependent_virtual_link": [self.vl_id_2, self.vl_id_1],
  82                                        "connection_point": ["CP01", "CP02"],
  83                                        "constituent_vnfs": ["VNF1", "VNF2", "VNF3"],
  84                                        "constituent_pnfs": ["pnf1", "pnf2"]},
  85                         "members": ["forwarding_path1", "forwarding_path2"]}]}
  86         NSInstModel(id=self.ns_inst_id, name="ns_name").save()
  87         VNFFGInstModel(vnffgdid=self.vnffg_id, vnffginstid="", nsinstid=self.ns_inst_id, endpointnumber=0, vllist="",
  88                        cplist="", vnflist="", fplist="", status="").save()
  89
  90     def tearDown(self):
  91         VLInstModel.objects.all().delete()
  92         NSInstModel.objects.all().delete()
  93         VNFFGInstModel.objects.all().delete()
  94
  95     @mock.patch.object(restcall, "call_req")
  96     @mock.patch.object(vimadaptor.VimAdaptor, "create_network")
  97     def test_create_vl(self, mock_create_network, mock_req_by_rest):
  98         network_id = str(uuid.uuid4())
  99         subnetwork_id = str(uuid.uuid4())
 100         mock_create_network.return_value = [0,
 101                                             {"status": "ACTIVE", "id": network_id, "name": "net1",
 102                                              "provider:segmentation_id": 204, "provider:network_type": "vlan",
 103                                              "res_type": 1,
 104                                              "subnet_list": [
 105                                                  {"id": subnetwork_id, "name": "subnet1", "res_type": 1}]}]
 106         mock_req_by_rest.return_value = [0, json.JSONEncoder().encode(vim_info), '200']
 107
 108         self.create_vl(self.vl_id_1)
 109         self.create_vl(self.vl_id_2)
 110         vl_from_vl_1 = VLInstModel.objects.filter(vldid=self.vl_id_1, ownerid=self.ns_inst_id)
 111         self.assertEqual(network_id, vl_from_vl_1[0].relatednetworkid)
 112         self.assertEqual(subnetwork_id, vl_from_vl_1[0].relatedsubnetworkid)
 113         #self.assertEqual(self.vim_id, vl_from_vl_1[0].vimid)
 114         self.assertEqual(self.tenant, vl_from_vl_1[0].tenant)
 115         vl_from_vl_2 = VLInstModel.objects.filter(vldid=self.vl_id_2, ownerid=self.ns_inst_id)
 116         self.assertEqual(VNFFGInstModel.objects.filter(vnffgdid=self.vnffg_id, nsinstid=self.ns_inst_id)[0].vllist,
 117                          vl_from_vl_2[0].vlinstanceid + "," + vl_from_vl_1[0].vlinstanceid)
 118
 119     def create_vl(self, vl_id):
 120         req_data = {
 121             "nsInstanceId": self.ns_inst_id,
 122             "context": json.JSONEncoder().encode(self.context),
 123             "vlindex": vl_id}
 124         response = self.client.post("/api/nslcm/v1/ns/vls", data=req_data)
 125         self.assertEqual(status.HTTP_201_CREATED, response.status_code)
 126         self.assertEqual(0, response.data["result"])
 127
 128     @mock.patch.object(restcall, "call_req")
 129     @mock.patch.object(vimadaptor.VimAdaptor, "create_network")
 130     @mock.patch.object(uuid, "uuid4")
 131     def test_create_network_fail_when_send_to_vim(self, mock_uuid4, mock_create_network, mock_req_by_rest):
 132         req_data = {
 133             "nsInstanceId": self.ns_inst_id,
 134             "context": json.JSONEncoder().encode(self.context),
 135             "vlindex": self.vl_id_1}
 136         mock_uuid4.return_value = '999'
 137         mock_req_by_rest.return_value = [0, json.JSONEncoder().encode(vim_info), '200']
 138         mock_create_network.return_value = [1, (1)]
 139         response = self.client.post("/api/nslcm/v1/ns/vls", data=req_data)
 140         retinfo = {"detail": "vl instantiation failed, detail message: Send post vl request to vim failed."}
 141         self.assertEqual(retinfo["detail"], response.data["detail"])
 142
 143
 144 class TestVlDetailViews(TestCase):
 145     def setUp(self):
 146         self.client = Client()
 147         self.vl_inst_id = str(uuid.uuid4())
 148         self.vl_name = str(uuid.uuid4())
 149         self.ns_inst_id = str(uuid.uuid4())
 150         VLInstModel(vlinstanceid=self.vl_inst_id, vldid="", vlinstancename=self.vl_name, ownertype=1,
 151                     ownerid=self.ns_inst_id, relatednetworkid="network1", relatedsubnetworkid="subnet1,subnet2",
 152                     vimid="",
 153                     tenant="").save()
 154         VNFFGInstModel(vnffgdid="", vnffginstid="", nsinstid=self.ns_inst_id,
 155                        vllist="test1," + self.vl_inst_id + ",test2,test3", endpointnumber=0, cplist="", vnflist="",
 156                        fplist="", status="").save()
 157
 158     def tearDown(self):
 159         VLInstModel.objects.all().delete()
 160         VNFFGInstModel.objects.all().delete()
 161
 162     @mock.patch.object(restcall, "call_req")
 163     @mock.patch.object(vimadaptor.VimAdaptor, "delete_network")
 164     @mock.patch.object(vimadaptor.VimAdaptor, "delete_subnet")
 165     def test_delete_vl(self, mock_delete_subnet, mock_delete_network, mock_req_by_rest):
 166         mock_req_by_rest.return_value = [0, json.JSONEncoder().encode(vim_info), '200']
 167         response = self.client.delete("/api/nslcm/v1/ns/vls/%s" % self.vl_inst_id)
 168         self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code)
 169         expect_resp_data = {"result": 0, "detail": "delete vl success"}
 170         self.assertEqual(expect_resp_data, response.data)
 171
 172         for vnffg_info in VNFFGInstModel.objects.filter(nsinstid=self.ns_inst_id):
 173             self.assertEqual(vnffg_info.vllist, "test1,test2,test3")
 174         if VLInstModel.objects.filter(vlinstanceid=self.vl_inst_id):
 175             self.fail()
 176
 177         response = self.client.delete("/api/nslcm/v1/ns/vls/%s" % "notExist")
 178         self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code)
 179         expect_resp_data = {"result": 0, "detail": "vl is not exist or has been already deleted"}
 180         self.assertEqual(expect_resp_data, response.data)
 181
 182     def test_query_vl(self):
 183         response = self.client.get("/api/nslcm/v1/ns/vls/%s" % self.vl_inst_id)
 184         self.assertEqual(status.HTTP_200_OK, response.status_code)
 185         expect_resp_data = {'vlId': self.vl_inst_id, 'vlName': self.vl_name, 'vlStatus': "active"}
 186         self.assertEqual(expect_resp_data, response.data)
 187
 188         response = self.client.get("/api/nslcm/v1/ns/vls/%s" % "notExist")
 189         self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)