lcm/lcm/nf/tests/test_query_vnf_lcm_op.py

   1 # Copyright (C) 2018 Verizon. All Rights Reserved
   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 copy
  17
  18 from django.test import TestCase, Client
  19 from rest_framework import status
  20
  21 from lcm.pub.database.models import VNFLcmOpOccModel
  22 from .const import single_vnf_lcm_op
  23 from .const import vnflcmop_with_exclude_default
  24 from .const import multiple_vnf_lcm_op
  25
  26
  27 class TestVNFLcmOpOccs(TestCase):
  28     def setUp(self):
  29         self.client = Client()
  30         self.vnf_lcm_op_occ_id = "99442b18-a5c7-11e8-998c-bf1755941f16"
  31         VNFLcmOpOccModel.objects.all().delete()
  32         self.test_single_vnf_lcm_op = single_vnf_lcm_op
  33         self.test_vnflcmop_with_exclude_default = vnflcmop_with_exclude_default
  34         self.test_multiple_vnf_lcm_op = copy.copy(multiple_vnf_lcm_op)
  35         self.test_multiple_vnf_lcm_op.append(self.test_single_vnf_lcm_op)
  36         self.maxdiff = None
  37
  38     def tearDown(self):
  39         pass
  40
  41     def test_get_vnflcmopoccs(self):
  42         lcm_op_id = "99442b18-a5c7-11e8-998c-bf1755941f16"
  43         vnf_instance_id = "cd552c9c-ab6f-11e8-b354-236c32aa91a1"
  44         VNFLcmOpOccModel(
  45             id=lcm_op_id,
  46             operation_state="STARTING",
  47             state_entered_time="2018-07-09",
  48             start_time="2018-07-09",
  49             vnf_instance_id=vnf_instance_id,
  50             grant_id=None,
  51             operation="SCALE",
  52             is_automatic_invocation=False,
  53             operation_params='{}',
  54             is_cancel_pending=False,
  55             cancel_mode=None,
  56             error=None,
  57             resource_changes=None,
  58             changed_ext_connectivity=None,
  59             links=json.dumps({
  60                 "self": {
  61                     "href": "demo"
  62                 },
  63                 "vnfInstance": "demo"
  64             })).save()
  65         response = self.client.get(
  66             "/api/vnflcm/v1/vnf_lcm_op_occs",
  67             format='json'
  68         )
  69         self.assertEqual(
  70             response.status_code,
  71             status.HTTP_200_OK
  72         )
  73         self.maxDiff = None
  74         self.assertEqual(
  75             [self.test_single_vnf_lcm_op],
  76             response.data
  77         )
  78
  79     def test_get_vnflcmopoccs_with_id_not_exist(self):
  80         response = self.client.get(
  81             "/api/vnflcm/v1/vnf_lcm_op_occs?id=dummy",
  82             format='json'
  83         )
  84         self.assertEqual(
  85             response.status_code,
  86             status.HTTP_500_INTERNAL_SERVER_ERROR
  87         )
  88         expected_data = {
  89             "status": 500,
  90             "detail": "LCM Operation Occurances do not exist"
  91         }
  92         self.assertEqual(
  93             expected_data,
  94             response.data
  95         )
  96
  97     def test_get_vnflcmopoccs_with_filters(self):
  98         lcm_op_id = "a6b9415c-ab99-11e8-9d37-dbb5e0378955"
  99         vnf_instance_id = "cd552c9c-ab6f-11e8-b354-236c32aa91a1"
 100         VNFLcmOpOccModel(
 101             id=lcm_op_id,
 102             operation_state="STARTING",
 103             state_entered_time="2018-07-09",
 104             start_time="2018-07-09",
 105             vnf_instance_id=vnf_instance_id,
 106             grant_id=None,
 107             operation="INSTANTIATE",
 108             is_automatic_invocation=False,
 109             operation_params='{}',
 110             is_cancel_pending=False,
 111             cancel_mode=None,
 112             error=None,
 113             resource_changes=None,
 114             changed_ext_connectivity=None,
 115             links=json.dumps({
 116                 "self": {
 117                     "href": "demo"
 118                 },
 119                 "vnfInstance": "demo"
 120             })).save()
 121
 122         lcm_op_id = "99442b18-a5c7-11e8-998c-bf1755941f16"
 123         VNFLcmOpOccModel(
 124             id=lcm_op_id,
 125             operation_state="STARTING",
 126             state_entered_time="2018-07-09",
 127             start_time="2018-07-09",
 128             vnf_instance_id=vnf_instance_id,
 129             grant_id=None,
 130             operation="SCALE",
 131             is_automatic_invocation=False,
 132             operation_params='{}',
 133             is_cancel_pending=False,
 134             cancel_mode=None,
 135             error=None,
 136             resource_changes=None,
 137             changed_ext_connectivity=None,
 138             links=json.dumps({
 139                 "self": {
 140                     "href": "demo"
 141                 },
 142                 "vnfInstance": "demo"
 143             })).save()
 144         response = self.client.get(
 145             "/api/vnflcm/v1/vnf_lcm_op_occs",
 146             format='json'
 147         )
 148         self.assertEqual(
 149             response.status_code,
 150             status.HTTP_200_OK
 151         )
 152         self.maxDiff = None
 153         self.assertEqual(
 154             self.test_multiple_vnf_lcm_op,
 155             response.data
 156         )
 157
 158         response = self.client.get(
 159             "/api/vnflcm/v1/vnf_lcm_op_occs?operation=SCALE",
 160             format='json'
 161         )
 162         self.assertEqual(
 163             response.status_code,
 164             status.HTTP_200_OK
 165         )
 166         self.assertEqual(
 167             [self.test_single_vnf_lcm_op],
 168             response.data
 169         )
 170
 171         response = self.client.get(
 172             "/api/vnflcm/v1/vnf_lcm_op_occs?vnfInstanceId=%s" % vnf_instance_id,
 173             format='json'
 174         )
 175         self.assertEqual(
 176             response.status_code,
 177             status.HTTP_200_OK
 178         )
 179         self.assertEqual(
 180             self.test_multiple_vnf_lcm_op,
 181             response.data
 182         )
 183
 184     def test_get_vnflcmopoccs_with_extra_flags(self):
 185         lcm_op_id = "99442b18-a5c7-11e8-998c-bf1755941f16"
 186         vnf_instance_id = "cd552c9c-ab6f-11e8-b354-236c32aa91a1"
 187         VNFLcmOpOccModel(
 188             id=lcm_op_id,
 189             operation_state="STARTING",
 190             state_entered_time="2018-07-09",
 191             start_time="2018-07-09",
 192             vnf_instance_id=vnf_instance_id,
 193             grant_id=None,
 194             operation="SCALE",
 195             is_automatic_invocation=False,
 196             operation_params='{}',
 197             is_cancel_pending=False,
 198             cancel_mode=None,
 199             error=None,
 200             resource_changes=None,
 201             changed_ext_connectivity=None,
 202             links=json.dumps({
 203                 "self": {
 204                     "href": "demo"
 205                 },
 206                 "vnfInstance": "demo"
 207             })).save()
 208         response = self.client.get(
 209             "/api/vnflcm/v1/vnf_lcm_op_occs?exclude_default",
 210             format='json'
 211         )
 212         self.assertEqual(
 213             response.status_code,
 214             status.HTTP_200_OK
 215         )
 216         self.maxDiff = None
 217         self.assertEqual(
 218             self.test_vnflcmop_with_exclude_default,
 219             response.data
 220         )
 221
 222     def test_get_vnflcmopocc_with_id(self):
 223         lcm_op_id = "99442b18-a5c7-11e8-998c-bf1755941f16"
 224         vnf_instance_id = "cd552c9c-ab6f-11e8-b354-236c32aa91a1"
 225         VNFLcmOpOccModel(
 226             id=lcm_op_id,
 227             operation_state="STARTING",
 228             state_entered_time="2018-07-09",
 229             start_time="2018-07-09",
 230             vnf_instance_id=vnf_instance_id,
 231             grant_id=None,
 232             operation="SCALE",
 233             is_automatic_invocation=False,
 234             operation_params='{}',
 235             is_cancel_pending=False,
 236             cancel_mode=None,
 237             error=None,
 238             resource_changes=None,
 239             changed_ext_connectivity=None,
 240             links=json.dumps({
 241                 "self": {
 242                     "href": "demo"
 243                 },
 244                 "vnfInstance": "demo"
 245             })).save()
 246         response = self.client.get(
 247             "/api/vnflcm/v1/vnf_lcm_op_occs/%s" % lcm_op_id,
 248             format='json'
 249         )
 250         self.assertEqual(
 251             response.status_code,
 252             status.HTTP_200_OK
 253         )
 254         self.maxDiff = None
 255         self.assertEqual(
 256             self.test_single_vnf_lcm_op,
 257             response.data
 258         )
 259
 260     def test_single_vnflcmopocc_with_unknown_id(self):
 261         lcm_op_id = "99442b18-a5c7-11e8-998c-bf1755941f16"
 262         response = self.client.get(
 263             "/api/vnflcm/v1/vnf_lcm_op_occs/%s" % lcm_op_id,
 264             format='json'
 265         )
 266         self.assertEqual(
 267             response.status_code,
 268             status.HTTP_500_INTERNAL_SERVER_ERROR
 269         )
 270         expected_data = {
 271             "status": 500,
 272             "detail": "LCM Operation Occurance does not exist"
 273         }
 274         self.assertEqual(
 275             expected_data,
 276             response.data
 277         )