lcm/ns/tests/test_ns_manual_scale.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 import mock
  15 import time
  16 import uuid
  17 import copy
  18
  19 from django.test import TestCase
  20 from rest_framework.test import APIClient
  21 from rest_framework import status
  22
  23 from lcm.ns.biz.ns_manual_scale import NSManualScaleService
  24 from lcm.ns.enum import NS_INST_STATUS
  25 from lcm.pub.database.models import NSInstModel, JobModel, NfInstModel, NSLcmOpOccModel
  26 from lcm.pub.exceptions import NSLCMException
  27 from lcm.pub.utils.jobutil import JobUtil
  28 from lcm.jobs.enum import JOB_TYPE, JOB_ACTION, JOB_PROGRESS
  29 from lcm.ns.tests import SCALING_MAP_DICT, SCALE_NS_THREAD_DICT, SCALE_NS_DICT
  30 from lcm.ns_vnfs.enum import VNF_STATUS
  31 from lcm.ns_vnfs.biz.scale_vnfs import NFManualScaleService
  32
  33
  34 class TestNsManualScale(TestCase):
  35
  36     def setUp(self):
  37         self.scaling_map_json = SCALING_MAP_DICT
  38         self.ns_inst_id = str(uuid.uuid4())
  39         self.job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE, self.ns_inst_id)
  40         self.client = APIClient()
  41         self.package_id = '7'
  42         NSInstModel(
  43             id=self.ns_inst_id,
  44             name='abc',
  45             nspackage_id=self.package_id,
  46             nsd_id='test_ns_manual_scale').save()
  47         NfInstModel(package_id='nf_001', status=VNF_STATUS.ACTIVE, nfinstid='nf_001').save()
  48         NfInstModel(package_id='nf_002', status=VNF_STATUS.ACTIVE, nfinstid='nf_002').save()
  49
  50     def tearDown(self):
  51         NSInstModel.objects.filter().delete()
  52         NfInstModel.objects.filter().delete()
  53         JobModel.objects.filter().delete()
  54         NSLcmOpOccModel.objects.filter().delete()
  55
  56     @mock.patch.object(NSManualScaleService, 'run')
  57     def test_ns_manual_scale_url(self, mock_run):
  58         response = self.client.post('/api/nslcm/v1/ns/%s/scale' % self.ns_inst_id, data=SCALE_NS_DICT, format='json')
  59         self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code)
  60
  61     @mock.patch.object(NSManualScaleService, 'run')
  62     def test_ns_manual_scale_url_when_require_data_is_not_valid(self, mock_run):
  63         response = self.client.post('/api/nslcm/v1/ns/%s/scale' % self.ns_inst_id, data={},
  64                                     format='json')
  65         self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
  66         self.assertIn('error', response.data)
  67
  68     @mock.patch.object(NSManualScaleService, 'start')
  69     def test_ns_manual_scale_url_when_ns_not_exist(self, mock_start):
  70         mock_start.side_effect = NSLCMException('NS scale failed.')
  71         scale_ns_json = SCALE_NS_DICT.copy()
  72         response = self.client.post('/api/nslcm/v1/ns/11/scale', data=scale_ns_json, format='json')
  73         self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
  74         self.assertIn('error', response.data)
  75
  76     @mock.patch('lcm.ns.biz.ns_manual_scale.get_scale_vnf_data_info_list')
  77     @mock.patch.object(NFManualScaleService, 'run')
  78     @mock.patch.object(time, 'sleep')
  79     @mock.patch.object(JobModel.objects, 'get')
  80     def test_ns_manual_scale_asynchronous_tasks_success(self, mock_get, mock_sleep, mock_run, mock_vnf_data_info_list):
  81         mock_run.return_value = None
  82         mock_sleep.return_value = None
  83         mock_get.return_value = JobModel(progress=JOB_PROGRESS.FINISHED)
  84         mock_vnf_data_info_list.return_value = [
  85             {
  86                 "vnfd_id": "nf_001",
  87                 "vnf_scaleAspectId": "gpu",
  88                 "numberOfSteps": "123"
  89             },
  90             {
  91                 "vnfd_id": "nf_002",
  92                 "vnf_scaleAspectId": "gpu",
  93                 "numberOfSteps": "456"
  94             }
  95         ]
  96         scale_ns_json = SCALE_NS_THREAD_DICT.copy()
  97         ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
  98         ns_heal_service.run()
  99         jobs = JobModel.objects.filter(jobid=self.job_id)
 100         self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
 101         self.assertEqual(JOB_PROGRESS.FINISHED, jobs[0].progress)
 102         self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'COMPLETED')
 103
 104     def test_ns_manual_scale_asynchronous_tasks_when_scale_ns_data_is_none(self):
 105         scale_ns_json = SCALE_NS_THREAD_DICT.copy()
 106         scale_ns_json['scaleNsData'] = None
 107         ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
 108         ns_heal_service.run()
 109         jobs = JobModel.objects.filter(jobid=self.job_id)
 110         self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
 111         self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
 112         self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
 113
 114     def test_ns_manual_scale_asynchronous_tasks_when_scale_ns_by_steps_data_is_none(self):
 115         scale_ns_json = copy.deepcopy(SCALE_NS_THREAD_DICT)
 116         scale_ns_json['scaleNsData']["scaleNsByStepsData"] = None
 117         ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
 118         ns_heal_service.run()
 119         jobs = JobModel.objects.filter(jobid=self.job_id)
 120         self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
 121         self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
 122         self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
 123
 124     @mock.patch('lcm.ns.biz.ns_manual_scale.get_scale_vnf_data_info_list')
 125     @mock.patch.object(NFManualScaleService, 'run')
 126     @mock.patch.object(time, 'sleep')
 127     @mock.patch.object(JobModel.objects, 'get')
 128     def test_ns_manual_scale_asynchronous_tasks_when_vnf_scale_failed(self, mock_get, mock_sleep,
 129                                                                       mock_run, mock_vnf_data_info_list):
 130         scale_ns_json = SCALE_NS_THREAD_DICT.copy()
 131         mock_run.return_value = None
 132         mock_sleep.return_value = None
 133         mock_get.return_value = JobModel(progress=JOB_PROGRESS.ERROR)
 134         mock_vnf_data_info_list.return_value = [
 135             {
 136                 "vnfd_id": "nf_001",
 137                 "vnf_scaleAspectId": "gpu",
 138                 "numberOfSteps": "123"
 139             },
 140             {
 141                 "vnfd_id": "nf_002",
 142                 "vnf_scaleAspectId": "gpu",
 143                 "numberOfSteps": "456"
 144             }
 145         ]
 146         ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
 147         ns_heal_service.run()
 148         jobs = JobModel.objects.filter(jobid=self.job_id)
 149         self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
 150         self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
 151         self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
 152
 153     def test_ns_manual_scale_asynchronous_tasks_when_error_scale_type(self):
 154         scale_ns_json = SCALE_NS_THREAD_DICT.copy()
 155         scale_ns_json['scaleType'] = 'SCALE_ERR'
 156         ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
 157         ns_heal_service.run()
 158         jobs = JobModel.objects.filter(jobid=self.job_id)
 159         self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
 160         self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
 161         self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
 162
 163     @mock.patch('lcm.ns.biz.ns_manual_scale.get_scale_vnf_data_info_list')
 164     def test_ns_manual_scale_asynchronous_tasks_when_failed_to_get_scale_vnf_data_parameter(self, mock_vnf_data_info):
 165         mock_vnf_data_info.return_value = []
 166         scale_ns_json = SCALE_NS_THREAD_DICT.copy()
 167         ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
 168         ns_heal_service.run()
 169         jobs = JobModel.objects.filter(jobid=self.job_id)
 170         self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
 171         self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
 172         self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')