self.assertIn('jobId', response.data)
self.assertNotIn('responseDescriptor', response.data)
+ def test_query_ns_job_with_error_response_id(self):
+ url = JOB_INSTANCE_URI % self.job_id + "?responseId='zzz'"
+ response = self.client.get(url)
+ self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR, response.status_code)
+
def test_query_job_with_response_id(self):
JobModel(jobid=self.job_id,
jobtype=JOB_TYPE.NS,
--- /dev/null
+{
+ "scale_options": [
+ {
+ "nsd_id": "01",
+ "ns_instanceId": "ns_instanceId_01",
+ "ns_scale_aspect": "TIC_EDGE_IMS",
+ "ns_scale_info_list": [
+ {
+ "step": 1,
+ "vnf_scale_info": [
+ {
+ "vnfInstanceId": "nf_zte_cscf",
+ "vnf_scaleAspectId": "gsu",
+ "numberOfSteps": "1"
+ },
+ {
+ "vnfInstanceId": "nf_zte_hss",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "3"
+ }
+ ]
+ },
+ {
+ "step": 2,
+ "vnf_scale_info": [
+ {
+ "vnfInstanceId": "nf_zte_cscf",
+ "vnf_scaleAspectId": "mpu",
+ "numberOfSteps": "2"
+ },
+ {
+ "vnfInstanceId": "nf_zte_hss",
+ "vnf_scaleAspectId": "mpu",
+ "numberOfSteps": "4"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "nsd_id": "02",
+ "ns_scale_aspect": "TIC_EDGE_HW",
+ "ns_scale_info": [
+ {
+ "step": 4,
+ "vnf_scale_info": [
+ {
+ "vnfd_id": "nf_hw_cscf",
+ "vnf_scaleAspectId": "gsu",
+ "numberOfSteps": "1"
+ },
+ {
+ "vnfd_id": "nf_hw_hss",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "1"
+ }
+ ]
+ },
+ {
+ "step": 6,
+ "vnf_scale_info": [
+ {
+ "vnfd_id": "nf_HW_cscf",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "1"
+ },
+ {
+ "vnfd_id": "nf_HW_hss",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "1"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "nsd_id": "03",
+ "ns_scale_aspect": "TIC_EDGE_HW",
+ "ns_scale_info_list": [
+ {
+ "step": "4",
+ "vnf_scale_info": [
+ {
+ "vnfd_id": "nf_hw_cscf",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "123"
+ },
+ {
+ "vnfd_id": "nf_hw_hss",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "456"
+ }
+ ]
+ },
+ {
+ "step": 6,
+ "vnf_scale_info": [
+ {
+ "vnfd_id": "nf_HW_cscf",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "1"
+ },
+ {
+ "vnfd_id": "nf_HW_hss",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "1"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "nsd_id": "test_ns_manual_scale",
+ "ns_scale_aspect": "test_ns_manual_scale_aspectId",
+ "ns_scale_info": [
+ {
+ "step": 1,
+ "vnf_scale_info": [
+ {
+ "vnfd_id": "nf_001",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "123"
+ },
+ {
+ "vnfd_id": "nf_002",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "456"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
SCALE_DICT = fileutil.read_json_file(cur_path + '/data/scale.json')
SCALING_MAP_DICT = fileutil.read_json_file(cur_path + '/data/scalemapping.json')
SCALE_NS_DICT = fileutil.read_json_file(cur_path + '/data/scale_ns.json')
+SCALE_NS_THREAD_DICT = fileutil.read_json_file(cur_path + '/data/scale_ns_thread.json')
OCCURRENCE_DICT = fileutil.read_json_file(cur_path + '/data/occurrence.json')
NSLCMOP_WITH_EXCLUDE_DEFAULT_DICT = fileutil.read_json_file(cur_path + '/data/occurrence_exclude_default.json')
SUBSCRIPTION_DICT = fileutil.read_json_file(cur_path + '/data/subscription.json')
VCPE_NS_MODEL_DICT = fileutil.read_json_file(cur_path + '/data/vcpe_ns_model.json')
SUBSCRIPTION_NS_OPERATION_DICT = fileutil.read_json_file(cur_path + '/data/subscription_ns_operation.json')
SUBSCRIPTION_NS_DELETION_DICT = fileutil.read_json_file(cur_path + '/data/subscription_ns_deletion.json')
+UPDATE_NS_DICT = fileutil.read_json_file(cur_path + '/data/update_ns.json')
+TERMINATE_NS_DICT = fileutil.read_json_file(cur_path + '/data/terminate_ns.json')
--- /dev/null
+{
+ "scaleType": "SCALE_NS",
+ "scaleNsData":
+ {
+ "scaleNsByStepsData": {
+ "aspectId": "test_ns_manual_scale_aspectId",
+ "numberOfSteps": 1,
+ "scalingDirection": "0"
+ }
+ }
+
+}
{
"scale_options": [
{
- "nsd_id": "23",
+ "nsd_id": "01",
+ "ns_instanceId": "ns_instanceId_01",
"ns_scale_aspect": "TIC_EDGE_IMS",
- "ns_scale_info": [
+ "ns_scale_info_list": [
{
"step": 1,
"vnf_scale_info": [
{
- "vnfd_id": "nf_zte_cscf",
+ "vnfInstanceId": "nf_zte_cscf",
"vnf_scaleAspectId": "gsu",
"numberOfSteps": "1"
},
{
- "vnfd_id": "nf_zte_hss",
+ "vnfInstanceId": "nf_zte_hss",
"vnf_scaleAspectId": "gpu",
"numberOfSteps": "3"
}
"step": 2,
"vnf_scale_info": [
{
- "vnfd_id": "nf_zte_cscf",
+ "vnfInstanceId": "nf_zte_cscf",
"vnf_scaleAspectId": "mpu",
"numberOfSteps": "2"
},
{
- "vnfd_id": "nf_zte_hss",
+ "vnfInstanceId": "nf_zte_hss",
"vnf_scaleAspectId": "mpu",
"numberOfSteps": "4"
}
]
},
{
- "nsd_id": "23",
+ "nsd_id": "02",
"ns_scale_aspect": "TIC_EDGE_HW",
"ns_scale_info": [
{
]
},
{
- "nsd_id": 235,
+ "nsd_id": "03",
"ns_scale_aspect": "TIC_EDGE_HW",
- "ns_scale_info": [
+ "ns_scale_info_list": [
{
"step": "4",
"vnf_scale_info": [
]
}
]
+ },
+ {
+ "nsd_id": "test_ns_manual_scale",
+ "ns_scale_aspect": "test_ns_manual_scale_aspectId",
+ "ns_scale_info": [
+ {
+ "step": 1,
+ "vnf_scale_info": [
+ {
+ "vnfd_id": "nf_001",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "123"
+ },
+ {
+ "vnfd_id": "nf_002",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "456"
+ }
+ ]
+ }
+ ]
}
]
}
--- /dev/null
+{
+ "updateType": "OPERATE_VNF",
+ "OperateVnfData": [{
+ "vnfInstanceId": "test_vnf_001",
+ "changeStateTo": {"OperationalStates": "STOPPED"},
+ "stopType": "GRACEFUL",
+ "gracefulStopTimeout": "2019-01-01"
+ }]
+}
# Copyright 2017 Intel Corporation.
#
-# Licensed under the Apache License, Version 2.0 (the "License");
+# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
+# distributed under the License is distributed on an 'AS IS' BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
+import mock
+import time
from django.test import TestCase
-import mock
from rest_framework.test import APIClient
from rest_framework import status
+
+from lcm.jobs.enum import JOB_TYPE, JOB_ACTION, JOB_PROGRESS
from lcm.ns.biz.ns_heal import NSHealService
from lcm.ns.enum import NS_INST_STATUS
-from lcm.pub.database.models import NSInstModel, NfInstModel
-from lcm.pub.exceptions import NSLCMException
-from lcm.pub.utils.jobutil import JobUtil
-from lcm.jobs.enum import JOB_TYPE, JOB_ACTION
from lcm.ns_vnfs.biz.heal_vnfs import NFHealService
from lcm.ns.tests import HEAL_NS_DICT, HEAL_VNF_DICT, VNFD_MODEL_DICT
+from lcm.pub.database.models import NSInstModel, NfInstModel, JobModel, VNFCInstModel, VmInstModel, NSLcmOpOccModel
+from lcm.pub.exceptions import NSLCMException
+from lcm.pub.utils.jobutil import JobUtil
class TestHealNsViews(TestCase):
self.client = APIClient()
NSInstModel.objects.filter().delete()
NfInstModel.objects.filter().delete()
- NSInstModel(id=self.ns_inst_id, name="ns_name", status='null').save()
+ NSInstModel(id=self.ns_inst_id, name='ns_name', status='null').save()
NfInstModel.objects.create(nfinstid=self.nf_inst_id,
nf_name='name_1',
vnf_id='1',
max_cpu='14',
max_ram='12296',
max_hd='101',
- max_shd="20",
+ max_shd='20',
max_net=10,
status='null',
mnfinstid=self.nf_uuid,
package_id='pkg1',
vnfd_model=VNFD_MODEL_DICT)
+ VNFCInstModel(nfinstid=self.nf_inst_id, vmid='vmid_01', vduid='vduid_01').save()
+ VmInstModel(vmid='vmid_01', vmname='vmname_01').save()
def tearDown(self):
- pass
+ NSInstModel.objects.all().delete()
+ NfInstModel.objects.all().delete()
+ VNFCInstModel.objects.all().delete()
+ VmInstModel.objects.all().delete()
@mock.patch.object(NSHealService, 'run')
def test_heal_vnf_url(self, mock_run):
heal_vnf_json = HEAL_VNF_DICT.copy()
- heal_vnf_json["healVnfData"]["vnfInstanceId"] = self.nf_inst_id
- response = self.client.post("/api/nslcm/v1/ns/%s/heal" % self.ns_inst_id, data=heal_vnf_json, format='json')
+ heal_vnf_json['healVnfData']['vnfInstanceId'] = self.nf_inst_id
+ response = self.client.post('/api/nslcm/v1/ns/%s/heal' % self.ns_inst_id, data=heal_vnf_json, format='json')
self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code, response.data)
self.assertIsNotNone(response.data)
- self.assertIn("jobId", response.data)
- self.assertNotIn("error", response.data)
- response = self.client.delete("/api/nslcm/v1/ns/%s" % self.ns_inst_id)
+ self.assertIn('jobId', response.data)
+ self.assertNotIn('error', response.data)
+ response = self.client.delete('/api/nslcm/v1/ns/%s' % self.ns_inst_id)
self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
# add healNsData
@mock.patch.object(NSHealService, 'run')
def test_heal_ns_url(self, mock_run):
heal_ns_json = HEAL_NS_DICT.copy()
- heal_ns_json["healNsData"]["vnfInstanceId"] = self.nf_inst_id
- response = self.client.post("/api/nslcm/v1/ns/%s/heal" % self.ns_inst_id, data=heal_ns_json, format='json')
+ heal_ns_json['healNsData']['vnfInstanceId'] = self.nf_inst_id
+ response = self.client.post('/api/nslcm/v1/ns/%s/heal' % self.ns_inst_id, data=heal_ns_json, format='json')
self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code, response.data)
self.assertIsNotNone(response.data)
- self.assertIn("jobId", response.data)
- self.assertNotIn("error", response.data)
- response = self.client.delete("/api/nslcm/v1/ns/%s" % self.ns_inst_id)
+ self.assertIn('jobId', response.data)
+ self.assertNotIn('error', response.data)
+ response = self.client.delete('/api/nslcm/v1/ns/%s' % self.ns_inst_id)
self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
- @mock.patch.object(NFHealService, 'start')
- @mock.patch.object(NSHealService, 'wait_job_finish')
- @mock.patch.object(NSHealService, 'update_job')
- def test_heal_vnf_thread(self, mock_start, mock_wait, mock_update):
- heal_vnf_json = HEAL_VNF_DICT.copy()
- heal_vnf_json["healVnfData"]["vnfInstanceId"] = self.nf_inst_id
- NSHealService(self.ns_inst_id, heal_vnf_json, self.job_id).run()
- self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.HEALING)
-
- # add healNsData
- @mock.patch.object(NFHealService, 'start')
- @mock.patch.object(NSHealService, 'wait_job_finish')
- @mock.patch.object(NSHealService, 'update_job')
- def test_heal_ns_thread(self, mock_start, mock_wait, mock_update):
- heal_ns_json = HEAL_NS_DICT.copy()
- heal_ns_json["healNsData"]["vnfInstanceId"] = self.nf_inst_id
- NSHealService(self.ns_inst_id, heal_ns_json, self.job_id).run()
- self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.HEALING)
-
- @mock.patch.object(NSHealService, "start")
+ @mock.patch.object(NSHealService, 'start')
def test_heal_vnf_non_existing_ns(self, mock_start):
- mock_start.side_effect = NSLCMException("NS Not Found")
- ns_inst_id = "2"
+ mock_start.side_effect = NSLCMException('NS Not Found')
+ ns_inst_id = '2'
heal_vnf_json = HEAL_VNF_DICT.copy()
- heal_vnf_json["healVnfData"]["vnfInstanceId"] = self.nf_inst_id
- response = self.client.post("/api/nslcm/v1/ns/%s/heal" % ns_inst_id, data=heal_vnf_json, format='json')
- self.assertEqual(response.data["error"], "NS Not Found")
+ heal_vnf_json['healVnfData']['vnfInstanceId'] = self.nf_inst_id
+ response = self.client.post('/api/nslcm/v1/ns/%s/heal' % ns_inst_id, data=heal_vnf_json, format='json')
+ self.assertEqual(response.data['error'], 'NS Not Found')
self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
- self.assertIn("error", response.data)
+ self.assertIn('error', response.data)
# add healNsData
- @mock.patch.object(NSHealService, "start")
+ @mock.patch.object(NSHealService, 'start')
def test_heal_ns_heal_non_existing_ns(self, mock_start):
- mock_start.side_effect = NSLCMException("NS Not Found")
- ns_inst_id = "2"
+ mock_start.side_effect = NSLCMException('NS Not Found')
+ ns_inst_id = '2'
heal_ns_json = HEAL_NS_DICT.copy()
- heal_ns_json["healNsData"]["vnfInstanceId"] = self.nf_inst_id
- response = self.client.post("/api/nslcm/v1/ns/%s/heal" % ns_inst_id, data=heal_ns_json, format='json')
- self.assertEqual(response.data["error"], "NS Not Found")
+ heal_ns_json['healNsData']['vnfInstanceId'] = self.nf_inst_id
+ response = self.client.post('/api/nslcm/v1/ns/%s/heal' % ns_inst_id, data=heal_ns_json, format='json')
+ self.assertEqual(response.data['error'], 'NS Not Found')
self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
- self.assertIn("error", response.data)
+ self.assertIn('error', response.data)
- @mock.patch.object(NSHealService, "start")
+ @mock.patch.object(NSHealService, 'start')
def test_heal_vnf_empty_post(self, mock_start):
- mock_start.side_effect = NSLCMException("healVnfData parameter does not exist or value is incorrect.")
- response = self.client.post("/api/nslcm/v1/ns/%s/heal" % self.ns_inst_id, data={})
+ mock_start.side_effect = NSLCMException('healVnfData parameter does not exist or value is incorrect.')
+ response = self.client.post('/api/nslcm/v1/ns/%s/heal' % self.ns_inst_id, data={})
self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
- self.assertIn("error", response.data)
+ self.assertIn('error', response.data)
+
+ @mock.patch.object(NFHealService, 'run')
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_heal_vnf_thread(self, mock_get, mock_sleep, mock_run):
+ mock_run.return_value = None
+ mock_sleep.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.FINISHED)
+ heal_vnf_json = HEAL_VNF_DICT.copy()
+ heal_vnf_json['healVnfData']['vnfInstanceId'] = self.nf_inst_id
+ NSHealService(self.ns_inst_id, heal_vnf_json, self.job_id).run()
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+
+ # add healNsData
+ @mock.patch.object(NFHealService, 'run')
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_heal_ns_thread(self, mock_get, mock_sleep, mock_run):
+ mock_run.return_value = None
+ mock_sleep.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.FINISHED)
+ heal_ns_json = HEAL_NS_DICT.copy()
+ heal_ns_json['healNsData']['vnfInstanceId'] = self.nf_inst_id
+ NSHealService(self.ns_inst_id, heal_ns_json, self.job_id).run()
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+
+ def test_heal_when_ns_does_not_exist(self):
+ ns_inst_id = '2'
+ ns_heal_service = NSHealService(ns_inst_id, {}, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_when_healnsdata_and_healvnfdata_parameters_does_not_exist(self):
+ ns_heal_service = NSHealService(self.nf_inst_id, {}, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_when_healnsdata_and_healvnfdata_parameters_exist_together(self):
+ data = {
+ 'healNsData': {'degreeHealing': 'HEAL_RESTORE'},
+ 'healVnfData': {'vnfInstanceId': 'default'}
+ }
+ ns_heal_service = NSHealService(self.nf_inst_id, data, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ @mock.patch.object(NFHealService, 'run')
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_heal_vnf_thread_when_nf_heal_failed(self, mock_get, mock_sleep, mock_run):
+ mock_run.return_value = None
+ mock_sleep.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.ERROR)
+ heal_vnf_json = HEAL_VNF_DICT.copy()
+ heal_vnf_json['healVnfData']['vnfInstanceId'] = self.nf_inst_id
+ ns_heal_service = NSHealService(self.ns_inst_id, heal_vnf_json, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ @mock.patch.object(NFHealService, 'run')
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_heal_ns_thread_when_nf_heal_failed(self, mock_get, mock_sleep, mock_run):
+ mock_run.return_value = None
+ mock_sleep.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.ERROR)
+ heal_ns_json = HEAL_NS_DICT.copy()
+ heal_ns_json['healNsData']['vnfInstanceId'] = self.nf_inst_id
+ ns_heal_service = NSHealService(self.ns_inst_id, heal_ns_json, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_vnf_thread_when_vnfinstanceid_does_not_exist(self):
+ heal_vnf_json = {'healVnfData': {'vnfInstanceId': ''}}
+ ns_heal_service = NSHealService(self.ns_inst_id, heal_vnf_json, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_ns_thread_when_degreeHealing_does_not_exist(self):
+ heal_ns_json = {'healNsData': {'degreeHealing': ''}}
+ ns_heal_service = NSHealService(self.ns_inst_id, heal_ns_json, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_ns_thread_when_the_degree_of_healing_does_not_exist(self):
+ heal_ns_json = {'healNsData': {'degreeHealing': 'xxx'}}
+ ns_heal_service = NSHealService(self.ns_inst_id, heal_ns_json, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_ns_thread_when_nsinsts_does_not_exist(self):
+ NSInstModel(id='text_nsinsts_does_not_exist', name='ns_name', status='null').save()
+ heal_ns_json = HEAL_NS_DICT.copy()
+ heal_ns_json['healNsData']['vnfInstanceId'] = 'text_nsinsts_does_not_exist'
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.HEAL, 'text_nsinsts_does_not_exist')
+ ns_heal_service = NSHealService('text_nsinsts_does_not_exist', heal_ns_json, job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_ns_thread_when_vnfcinsts_does_not_exist(self):
+ NSInstModel(id='text_vnfcinsts_does_not_exist', name='ns_name', status='null').save()
+ NfInstModel.objects.create(nfinstid='text_vnfcinsts_does_not_exist_nf_id',
+ ns_inst_id='text_vnfcinsts_does_not_exist')
+ heal_ns_json = HEAL_NS_DICT.copy()
+ heal_ns_json['healNsData']['vnfInstanceId'] = 'text_vnfcinsts_does_not_exist_nf_id'
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.HEAL, 'text_vnfcinsts_does_not_exist')
+ ns_heal_service = NSHealService('text_vnfcinsts_does_not_exist', heal_ns_json, job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_heal_ns_thread_when_vminstinfo_does_not_exist(self):
+ ns_inst_id = 'text_vminstinfo_does_not_exist'
+ NSInstModel(id=ns_inst_id, name='ns_name', status='null').save()
+ NfInstModel.objects.create(nfinstid='text_vminstinfo_does_not_exist_nf_id',
+ ns_inst_id=ns_inst_id)
+ VNFCInstModel(nfinstid='text_vminstinfo_does_not_exist_nf_id', vmid='text_vminstinfo_does_not_exist_vm_id',
+ vduid='text_vminstinfo_does_not_exist_vdu_id').save()
+ heal_ns_json = HEAL_NS_DICT.copy()
+ heal_ns_json['healNsData']['vnfInstanceId'] = 'text_vminstinfo_does_not_exist_nf_id'
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.HEAL, ns_inst_id)
+ ns_heal_service = NSHealService(ns_inst_id, heal_ns_json, job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
# Copyright 2017 ZTE Corporation.
#
-# Licensed under the Apache License, Version 2.0 (the "License");
+# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
+# distributed under the License is distributed on an 'AS IS' BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
-
-import json
+import mock
+import time
import uuid
+import copy
-import mock
-from rest_framework.test import APIClient
from django.test import TestCase
+from rest_framework.test import APIClient
from rest_framework import status
from lcm.ns.biz.ns_manual_scale import NSManualScaleService
from lcm.ns.enum import NS_INST_STATUS
-from lcm.pub.database.models import NSInstModel, JobModel, NfInstModel
+from lcm.pub.database.models import NSInstModel, JobModel, NfInstModel, NSLcmOpOccModel
from lcm.pub.exceptions import NSLCMException
-from lcm.pub.msapi import catalog
-from lcm.pub.utils import restcall
from lcm.pub.utils.jobutil import JobUtil
-from lcm.jobs.enum import JOB_MODEL_STATUS, JOB_TYPE, JOB_ACTION
-from lcm.ns.tests import SCALING_MAP_DICT, VNFD_MODEL_DICT, SCALE_NS_DICT
+from lcm.jobs.enum import JOB_TYPE, JOB_ACTION, JOB_PROGRESS
+from lcm.ns.tests import SCALING_MAP_DICT, SCALE_NS_THREAD_DICT, SCALE_NS_DICT
+from lcm.ns_vnfs.enum import VNF_STATUS
+from lcm.ns_vnfs.biz.scale_vnfs import NFManualScaleService
class TestNsManualScale(TestCase):
self.ns_inst_id = str(uuid.uuid4())
self.job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE, self.ns_inst_id)
self.client = APIClient()
- self.package_id = "7"
+ self.package_id = '7'
NSInstModel(
id=self.ns_inst_id,
- name="abc",
+ name='abc',
nspackage_id=self.package_id,
- nsd_id="111").save()
+ nsd_id='test_ns_manual_scale').save()
+ NfInstModel(package_id='nf_001', status=VNF_STATUS.ACTIVE, nfinstid='nf_001').save()
+ NfInstModel(package_id='nf_002', status=VNF_STATUS.ACTIVE, nfinstid='nf_002').save()
def tearDown(self):
NSInstModel.objects.filter().delete()
+ NfInstModel.objects.filter().delete()
JobModel.objects.filter().delete()
-
- def insert_new_ns(self):
- ns_inst_id = str(uuid.uuid4())
- job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE, self.ns_inst_id)
- package_id = "23"
- NSInstModel(
- id=ns_inst_id,
- name="abc",
- nspackage_id=package_id,
- nsd_id=package_id).save()
- return ns_inst_id, job_id
-
- def insert_new_nf(self):
- self.vnfm_inst_id = "1"
- NfInstModel.objects.create(
- nfinstid="233",
- nf_name="name_1",
- vnf_id="1",
- vnfm_inst_id="1",
- ns_inst_id=self.ns_inst_id,
- max_cpu='14',
- max_ram='12296',
- max_hd='101',
- max_shd="20",
- max_net=10,
- status='active',
- mnfinstid="ab34-3g5j-de13-ab85-ij93",
- package_id="nf_zte_hss",
- vnfd_model=json.dumps(VNFD_MODEL_DICT))
+ NSLcmOpOccModel.objects.filter().delete()
@mock.patch.object(NSManualScaleService, 'run')
- def test_ns_manual_scale(self, mock_run):
- response = self.client.post("/api/nslcm/v1/ns/%s/scale" % self.ns_inst_id, data=SCALE_NS_DICT, format='json')
+ def test_ns_manual_scale_url(self, mock_run):
+ response = self.client.post('/api/nslcm/v1/ns/%s/scale' % self.ns_inst_id, data=SCALE_NS_DICT, format='json')
self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code)
- def test_ns_manual_scale_error_scaletype(self):
- scale_ns_json = SCALE_NS_DICT.copy()
- scale_ns_json["scaleType"] = "SCALE_ERR"
- NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id).run()
- jobs = JobModel.objects.filter(jobid=self.job_id)
- self.assertEqual(255, jobs[0].progress)
-
- def test_ns_manual_scale_error_nsd_id(self):
- scale_ns_json = SCALE_NS_DICT.copy()
- scale_ns_json["scaleNsData"][0]["scaleNsByStepsData"][0]["aspectId"] = "sss_zte"
- NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id).run()
- jobs = JobModel.objects.filter(jobid=self.job_id)
- self.assertEqual(255, jobs[0].progress)
-
- def test_ns_manual_scale_error_aspect(self):
- scale_ns_json = SCALE_NS_DICT.copy()
- scale_ns_json["scaleNsData"][0]["scaleNsByStepsData"][0]["aspectId"] = "sss_zte"
- ns_inst_id, job_id = self.insert_new_ns()
- job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE, ns_inst_id)
- NSManualScaleService(ns_inst_id, scale_ns_json, job_id).run()
- jobs = JobModel.objects.filter(jobid=job_id)
- self.assertEqual(255, jobs[0].progress)
-
- @mock.patch.object(catalog, 'get_scalingmap_json_package')
- @mock.patch.object(NSManualScaleService, 'do_vnfs_scale')
- def test_ns_manual_scale_success(self, mock_do_vnfs_scale, mock_get_scalingmap_json_package):
- scale_ns_json = SCALE_NS_DICT.copy()
- scale_ns_json["scaleNsData"][0]["scaleNsByStepsData"][0]["aspectId"] = "TIC_EDGE_IMS"
- mock_get_scalingmap_json_package.return_value = self.scaling_map_json
- mock_do_vnfs_scale.return_value = JOB_MODEL_STATUS.FINISHED
- ns_inst_id, job_id = self.insert_new_ns()
- job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.MANUAL_SCALE, ns_inst_id)
- self.insert_new_nf()
- NSManualScaleService(ns_inst_id, scale_ns_json, job_id).run()
- jobs = JobModel.objects.filter(jobid=job_id)
- self.assertEqual(255, jobs[0].progress)
-
- @mock.patch.object(restcall, 'call_req')
- def test_ns_manual_scale_thread(self, mock_call):
- scale_ns_json = SCALE_NS_DICT.copy()
- NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id).run()
- self.assertTrue(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
-
- @mock.patch.object(NSManualScaleService, 'start')
- def test_ns_manual_scale_empty_data(self, mock_start):
- mock_start.side_effect = NSLCMException("NS scale failed.")
- response = self.client.post("/api/nslcm/v1/ns/%s/scale" % self.ns_inst_id, data={}, format='json')
- self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
- self.assertIn("error", response.data)
+ @mock.patch.object(NSManualScaleService, 'run')
+ def test_ns_manual_scale_url_when_require_data_is_not_valid(self, mock_run):
+ response = self.client.post('/api/nslcm/v1/ns/%s/scale' % self.ns_inst_id, data={},
+ format='json')
+ self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
+ self.assertIn('error', response.data)
@mock.patch.object(NSManualScaleService, 'start')
- def test_ns_manual_scale_when_ns_not_exist(self, mock_start):
- mock_start.side_effect = NSLCMException("NS scale failed.")
+ def test_ns_manual_scale_url_when_ns_not_exist(self, mock_start):
+ mock_start.side_effect = NSLCMException('NS scale failed.')
scale_ns_json = SCALE_NS_DICT.copy()
- response = self.client.post("/api/nslcm/v1/ns/11/scale", data=scale_ns_json, format='json')
+ response = self.client.post('/api/nslcm/v1/ns/11/scale', data=scale_ns_json, format='json')
self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR)
- self.assertIn("error", response.data)
+ self.assertIn('error', response.data)
+
+ @mock.patch('lcm.ns.biz.ns_manual_scale.get_scale_vnf_data_info_list')
+ @mock.patch.object(NFManualScaleService, 'run')
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_ns_manual_scale_asynchronous_tasks_success(self, mock_get, mock_sleep, mock_run, mock_vnf_data_info_list):
+ mock_run.return_value = None
+ mock_sleep.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.FINISHED)
+ mock_vnf_data_info_list.return_value = [
+ {
+ "vnfd_id": "nf_001",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "123"
+ },
+ {
+ "vnfd_id": "nf_002",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "456"
+ }
+ ]
+ scale_ns_json = SCALE_NS_THREAD_DICT.copy()
+ ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
+ ns_heal_service.run()
+ jobs = JobModel.objects.filter(jobid=self.job_id)
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+ self.assertEqual(JOB_PROGRESS.FINISHED, jobs[0].progress)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'COMPLETED')
+
+ def test_ns_manual_scale_asynchronous_tasks_when_scale_ns_data_is_none(self):
+ scale_ns_json = SCALE_NS_THREAD_DICT.copy()
+ scale_ns_json['scaleNsData'] = None
+ ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
+ ns_heal_service.run()
+ jobs = JobModel.objects.filter(jobid=self.job_id)
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+ self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_manual_scale_asynchronous_tasks_when_scale_ns_by_steps_data_is_none(self):
+ scale_ns_json = copy.deepcopy(SCALE_NS_THREAD_DICT)
+ scale_ns_json['scaleNsData']["scaleNsByStepsData"] = None
+ ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
+ ns_heal_service.run()
+ jobs = JobModel.objects.filter(jobid=self.job_id)
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+ self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ @mock.patch('lcm.ns.biz.ns_manual_scale.get_scale_vnf_data_info_list')
+ @mock.patch.object(NFManualScaleService, 'run')
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_ns_manual_scale_asynchronous_tasks_when_vnf_scale_failed(self, mock_get, mock_sleep,
+ mock_run, mock_vnf_data_info_list):
+ scale_ns_json = SCALE_NS_THREAD_DICT.copy()
+ mock_run.return_value = None
+ mock_sleep.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.ERROR)
+ mock_vnf_data_info_list.return_value = [
+ {
+ "vnfd_id": "nf_001",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "123"
+ },
+ {
+ "vnfd_id": "nf_002",
+ "vnf_scaleAspectId": "gpu",
+ "numberOfSteps": "456"
+ }
+ ]
+ ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
+ ns_heal_service.run()
+ jobs = JobModel.objects.filter(jobid=self.job_id)
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+ self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_manual_scale_asynchronous_tasks_when_error_scale_type(self):
+ scale_ns_json = SCALE_NS_THREAD_DICT.copy()
+ scale_ns_json['scaleType'] = 'SCALE_ERR'
+ ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
+ ns_heal_service.run()
+ jobs = JobModel.objects.filter(jobid=self.job_id)
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+ self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ @mock.patch('lcm.ns.biz.ns_manual_scale.get_scale_vnf_data_info_list')
+ def test_ns_manual_scale_asynchronous_tasks_when_failed_to_get_scale_vnf_data_parameter(self, mock_vnf_data_info):
+ mock_vnf_data_info.return_value = []
+ scale_ns_json = SCALE_NS_THREAD_DICT.copy()
+ ns_heal_service = NSManualScaleService(self.ns_inst_id, scale_ns_json, self.job_id)
+ ns_heal_service.run()
+ jobs = JobModel.objects.filter(jobid=self.job_id)
+ self.assertEqual(NSInstModel.objects.get(id=self.ns_inst_id).status, NS_INST_STATUS.ACTIVE)
+ self.assertEqual(JOB_PROGRESS.ERROR, jobs[0].progress)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
--- /dev/null
+import mock
+import time
+import httplib2
+
+from django.test import TestCase
+from rest_framework.test import APIClient
+
+from lcm.jobs.enum import JOB_TYPE, JOB_ACTION, JOB_PROGRESS
+from lcm.ns.biz.ns_terminate import TerminateNsService
+from lcm.ns.enum import OWNER_TYPE
+from lcm.ns.tests import TERMINATE_NS_DICT
+from lcm.pub.database.models import NSInstModel, JobModel, FPInstModel, NfInstModel, VLInstModel, PNFInstModel
+from lcm.pub.utils.jobutil import JobUtil
+
+
+class TestScaleAspect(TestCase):
+ def setUp(self):
+ self.client = APIClient()
+ self.ns_inst_id = 'test_ns_terminate_001'
+ self.url = '/api/nslcm/v1/ns/%s/terminate' % self.ns_inst_id
+ self.job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, self.ns_inst_id)
+ NSInstModel(id=self.ns_inst_id).save()
+ NSInstModel(id='test_ns_terminate_002').save()
+ FPInstModel(nsinstid=self.ns_inst_id, sfcid='test_sfc_inst_001', fpname='xxx', status='zzz').save()
+ NfInstModel(ns_inst_id=self.ns_inst_id).save()
+ VLInstModel(ownertype=OWNER_TYPE.NS, ownerid=self.ns_inst_id).save()
+ PNFInstModel(nsInstances=self.ns_inst_id).save()
+
+ def tearDown(self):
+ NSInstModel.objects.all().delete()
+ FPInstModel.objects.all().delete()
+ NfInstModel.objects.all().delete()
+ VLInstModel.objects.all().delete()
+ PNFInstModel.objects.all().delete()
+ JobModel.objects.all().delete()
+
+ def test_ns_terminate_asynchronous_tasks_when_ns_does_not_exist(self):
+ ns_instance_id = 'test_ns_terminate_not_exist'
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, ns_instance_id)
+ TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.FINISHED)
+
+ def test_ns_terminate_asynchronous_tasks_with_none(self):
+ ns_instance_id = 'test_ns_terminate_002'
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, ns_instance_id)
+ TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.FINISHED)
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(httplib2.Http, 'request')
+ def test_ns_terminate_asynchronous_tasks(self, mock_request, mock_sleep):
+ mock_request.side_effect = [
+ ({'status': '200'}, '{"result": "0"}'.encode('utf-8')),
+ ({'status': '200'}, '{"jobId": "zzz"}'.encode('utf-8')),
+ ({'status': '200'}, '{"responseDescriptor": {"progress": 100, "responseId": 1, '
+ '"statusDescription": ""}}'.encode('utf-8')),
+ ({'status': '200'}, '{"result": "0"}'.encode('utf-8')),
+ ({'status': '200'}, '{"result": "0"}'.encode('utf-8'))
+ ]
+ mock_sleep.return_value = None
+
+ TerminateNsService(self.ns_inst_id, self.job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.FINISHED)
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(httplib2.Http, 'request')
+ def test_ns_terminate_asynchronous_tasks_when_cancel_vnf_no_vnfjobid(self, mock_request, mock_sleep):
+ ns_instance_id = 'test_ns_terminate_when_cancel_vnf_no_vnfjobid'
+ NSInstModel(id=ns_instance_id).save()
+ NfInstModel(ns_inst_id=ns_instance_id).save()
+ mock_request.side_effect = [
+ ({'status': '200'}, '{"jobId": ""}'.encode('utf-8'))
+ ]
+ mock_sleep.return_value = None
+
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, ns_instance_id)
+ TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.FINISHED)
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(httplib2.Http, 'request')
+ def test_ns_terminate_asynchronous_tasks_when_terminate_vnf_failed(self, mock_request, mock_sleep):
+ ns_instance_id = 'test_ns_terminate_when_terminate_vnf_failed'
+ NSInstModel(id=ns_instance_id).save()
+ NfInstModel(ns_inst_id=ns_instance_id).save()
+ mock_request.side_effect = [
+ ({'status': '404'}, '{"jobId": "zzz"}'.encode('utf-8'))
+ ]
+ mock_sleep.return_value = None
+
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, ns_instance_id)
+ TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.FINISHED)
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(httplib2.Http, 'request')
+ def test_ns_terminate_asynchronous_tasks_when_failed_to_query_job(self, mock_request, mock_sleep):
+ ns_instance_id = 'test_ns_terminate_when_failed_to_query_job'
+ NSInstModel(id=ns_instance_id).save()
+ NfInstModel(ns_inst_id=ns_instance_id).save()
+ mock_request.side_effect = [
+ ({'status': '200'}, '{"jobId": "zzz"}'.encode('utf-8')),
+ ({'status': '400'}),
+ ({'status': '200'}, '{"responseDescriptor": {"progress": 100, "responseId": 1, '
+ '"statusDescription": ""}}'.encode('utf-8'))
+ ]
+ mock_sleep.return_value = None
+
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, ns_instance_id)
+ TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.FINISHED)
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(httplib2.Http, 'request')
+ def test_ns_terminate_asynchronous_tasks_when_no_new_progress(self, mock_request, mock_sleep):
+ ns_instance_id = 'test_ns_terminate_when_no_new_progress'
+ NSInstModel(id=ns_instance_id).save()
+ NfInstModel(ns_inst_id=ns_instance_id).save()
+ mock_request.side_effect = [
+ ({'status': '200'}, '{"jobId": "zzz"}'.encode('utf-8')),
+ ({'status': '200'}, '{}'.encode('utf-8')),
+ ({'status': '200'}, '{"responseDescriptor": {"progress": 100, "responseId": 1, '
+ '"statusDescription": ""}}'.encode('utf-8'))
+ ]
+ mock_sleep.return_value = None
+
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, ns_instance_id)
+ TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.FINISHED)
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(httplib2.Http, 'request')
+ def test_ns_terminate_asynchronous_tasks_when_job_failed(self, mock_request, mock_sleep):
+ ns_instance_id = 'test_ns_terminate_when_job_failed'
+ NSInstModel(id=ns_instance_id).save()
+ NfInstModel(ns_inst_id=ns_instance_id).save()
+ mock_request.side_effect = [
+ ({'status': '200'}, '{"jobId": "zzz"}'.encode('utf-8')),
+ ({'status': '200'}, '{"responseDescriptor": {"progress": 255, "responseId": 1, '
+ '"statusDescription": ""}}'.encode('utf-8'))
+ ]
+ mock_sleep.return_value = None
+
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.TERMINATE, ns_instance_id)
+ TerminateNsService(ns_instance_id, job_id, TERMINATE_NS_DICT).run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.FINISHED)
--- /dev/null
+import mock
+import time
+
+from django.test import TestCase
+from rest_framework.test import APIClient
+from rest_framework import status
+
+from lcm.jobs.enum import JOB_TYPE, JOB_ACTION, JOB_PROGRESS
+from lcm.ns.biz.ns_update import NSUpdateService
+from lcm.ns.enum import NS_INST_STATUS
+from lcm.ns.tests import UPDATE_NS_DICT
+from lcm.ns_vnfs.biz.update_vnfs import NFOperateService
+from lcm.pub.database.models import NSInstModel, JobModel, NSLcmOpOccModel
+from lcm.pub.utils.jobutil import JobUtil
+
+
+class TestScaleAspect(TestCase):
+ def setUp(self):
+ self.client = APIClient()
+ self.ns_inst_id = 'test_ns_update_001'
+ self.url = '/api/nslcm/v1/ns/%s/update' % self.ns_inst_id
+ self.job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.HEAL, self.ns_inst_id)
+ NSInstModel(id=self.ns_inst_id).save()
+
+ def tearDown(self):
+ NSInstModel.objects.all().delete()
+ JobModel.objects.all().delete()
+
+ def test_ns_update_when_require_is_not_valid(self):
+ response = self.client.post(self.url, data={}, format='json')
+ self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
+
+ @mock.patch.object(NSUpdateService, 'run')
+ def test_ns_update_url(self, mock_run):
+ mock_run.return_value = None
+ response = self.client.post(self.url, data=UPDATE_NS_DICT, format='json')
+ self.assertEqual(status.HTTP_202_ACCEPTED, response.status_code)
+
+ @mock.patch.object(JobUtil, 'create_job')
+ @mock.patch.object(NSUpdateService, 'run')
+ def test_ns_update_url_nslcmexception(self, mock_run, mock_create_job):
+ mock_run.return_value = None
+ mock_create_job.return_value = None
+ response = self.client.post(self.url, data=UPDATE_NS_DICT, format='json')
+ self.assertEqual(status.HTTP_500_INTERNAL_SERVER_ERROR, response.status_code)
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(NFOperateService, 'run')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_ns_update_asynchronous_tasks(self, mock_get, mock_run, mock_sleep):
+ mock_sleep.return_value = None
+ mock_run.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.FINISHED)
+ ns_heal_service = NSUpdateService(self.ns_inst_id, UPDATE_NS_DICT, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(NSInstModel.objects.filter(id=self.ns_inst_id).first().status, NS_INST_STATUS.ACTIVE)
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.FINISHED)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'COMPLETED')
+
+ @mock.patch.object(time, 'sleep')
+ @mock.patch.object(NFOperateService, 'run')
+ @mock.patch.object(JobModel.objects, 'get')
+ def test_ns_update_asynchronous_tasks_when_nf_update_error(self, mock_get, mock_run, mock_sleep):
+ mock_sleep.return_value = None
+ mock_run.return_value = None
+ mock_get.return_value = JobModel(progress=JOB_PROGRESS.ERROR)
+ ns_heal_service = NSUpdateService(self.ns_inst_id, UPDATE_NS_DICT, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(NSInstModel.objects.filter(id=self.ns_inst_id).first().status, NS_INST_STATUS.UPDATING)
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_update_asynchronous_tasks_when_ns_does_not_exist(self):
+ ns_instance_id = 'test_ns_update_002'
+ job_id = JobUtil.create_job(JOB_TYPE.NS, JOB_ACTION.UPDATE, ns_instance_id)
+ ns_heal_service = NSUpdateService(ns_instance_id, UPDATE_NS_DICT, job_id)
+ ns_heal_service.run()
+ self.assertEqual(JobModel.objects.filter(jobid=job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_update_asynchronous_tasks_when_updatetype_parameter_does_not_exist(self):
+ request_data = {"updateType": ""}
+ ns_heal_service = NSUpdateService(self.ns_inst_id, request_data, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(NSInstModel.objects.filter(id=self.ns_inst_id).first().status, None)
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_update_asynchronous_tasks_when_updatetype_not_operate_vnf(self):
+ request_data = {"updateType": "ADD_VNF"}
+ ns_heal_service = NSUpdateService(self.ns_inst_id, request_data, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(NSInstModel.objects.filter(id=self.ns_inst_id).first().status, NS_INST_STATUS.UPDATING)
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_update_asynchronous_tasks_when_operatevnfdata_does_not_exist(self):
+ request_data = {"updateType": "OPERATE_VNF"}
+ ns_heal_service = NSUpdateService(self.ns_inst_id, request_data, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(NSInstModel.objects.filter(id=self.ns_inst_id).first().status, NS_INST_STATUS.UPDATING)
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_update_asynchronous_tasks_when_vnfinstanceid_does_not_exist(self):
+ request_data = {
+ "updateType": "OPERATE_VNF",
+ "OperateVnfData": [{}]
+ }
+ ns_heal_service = NSUpdateService(self.ns_inst_id, request_data, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(NSInstModel.objects.filter(id=self.ns_inst_id).first().status, NS_INST_STATUS.UPDATING)
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
+
+ def test_ns_update_asynchronous_tasks_when_changestateto_does_not_exist(self):
+ request_data = {
+ "updateType": "OPERATE_VNF",
+ "OperateVnfData": [
+ {
+ "vnfInstanceId": "test_vnf_001"
+ }
+ ]
+ }
+ ns_heal_service = NSUpdateService(self.ns_inst_id, request_data, self.job_id)
+ ns_heal_service.run()
+ self.assertEqual(NSInstModel.objects.filter(id=self.ns_inst_id).first().status, NS_INST_STATUS.UPDATING)
+ self.assertEqual(JobModel.objects.filter(jobid=self.job_id).first().progress, JOB_PROGRESS.ERROR)
+ self.assertEqual(NSLcmOpOccModel.objects.filter(id=ns_heal_service.occ_id).first().operation_state, 'FAILED')
# Copyright 2016-2018 ZTE Corporation.
#
-# Licensed under the Apache License, Version 2.0 (the "License");
+# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
+# distributed under the License is distributed on an 'AS IS' BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
+import mock
+import os
-import json
from django.test import TestCase
-from lcm.pub.database.models import NSInstModel
-from lcm.pub.database.models import NfInstModel
-from lcm.pub.utils.timeutil import now_time
-from lcm.ns.tests import VNFD_MODEL_DICT
+from lcm.pub.database.models import NSInstModel, NfInstModel
+from lcm.ns_vnfs.enum import VNF_STATUS
+from lcm.ns.biz.scaleaspect import mapping_conv, get_vnf_instance_id_list, check_scale_list, get_scale_vnf_data, \
+ get_nsdId, check_and_set_params, get_scale_vnf_data_info_list, get_vnf_scale_info, get_scale_vnf_data_from_json
class TestScaleAspect(TestCase):
def setUp(self):
- self.initInstModel()
+ pass
- self.init_scale_ns_data()
-
- self.vnf_scale_info_list = [
+ def tearDown(self):
+ NSInstModel.objects.all().delete()
+ NfInstModel.objects.all().delete()
+
+ def test_mapping_conv(self):
+ keyword_map = {'a': 1, 'b': 2, 'c': 3, 'd': {'d.1': 'd.1'}}
+ rest_return = {'b': 2, 'C': 3}
+ resp_data = mapping_conv(keyword_map, rest_return)
+ self.assertEqual(resp_data, {'a': '', 'b': 2, 'c': 3, 'd': {'d.1': ''}})
+
+ def test_get_vnf_instance_id_list_when_no_model(self):
+ self.assertEqual(get_vnf_instance_id_list('package_1'), [])
+
+ def test_check_scale_list_when_empty_vnf_scale_list(self):
+ try:
+ check_scale_list([], 'ns_instanceId_01', '', '')
+ except Exception as e:
+ self.assertEqual(e.args, ('The scaling option[ns=ns_instanceId_01, aspect=, step=] does not exist. '
+ 'Pls check the config file.',))
+
+ @mock.patch.object(os.path, 'abspath')
+ def test_get_scale_vnf_data(self, mock_abspath):
+ mock_abspath.return_value = 'lcm/1/2/3.py'
+ scale_ns_data = {'scaleNsByStepsData': {'aspectId': 'TIC_EDGE_IMS', 'numberOfSteps': 1,
+ 'scalingDirection': 'r'}}
+ ns_instance_id = 'ns_instanceId_01'
+ scale_vnf_data_list = get_scale_vnf_data(scale_ns_data, ns_instance_id)
+ success_list = [
{
- "vnfd_id": "nf_zte_cscf",
- "vnf_scaleAspectId": "mpu",
- "numberOfSteps": "1"
+ 'vnfInstanceId': 'nf_zte_cscf',
+ 'scaleByStepData': {
+ 'type': 'r',
+ 'aspectId': 'gsu',
+ 'numberOfSteps': '1'
+ }
},
{
- "vnfd_id": "nf_zte_hss",
- "vnf_scaleAspectId": "gsu",
- "numberOfSteps": "2"
+ 'vnfInstanceId': 'nf_zte_hss',
+ 'scaleByStepData': {
+ 'type': 'r',
+ 'aspectId': 'gpu',
+ 'numberOfSteps': '3'
+ }
}
]
-
- def init_scale_ns_data(self):
- self.ns_scale_aspect = "TIC_EDGE_IMS"
- self.ns_scale_steps = "1"
- self.ns_scale_direction = "SCALE_IN"
- self.scaleNsData = [{
- "scaleNsByStepsData": [
- {
- "aspectId": self.ns_scale_aspect,
- "numberOfSteps": self.ns_scale_steps,
- "scalingDirection": self.ns_scale_direction
- }
- ]
- }]
-
- self.ns_scale_aspect2 = "TIC_EDGE_HW"
- self.ns_scale_steps2 = "4"
- self.scaleNsData2 = [{
- "scaleNsByStepsData": [
- {
- "aspectId": self.ns_scale_aspect2,
- "numberOfSteps": self.ns_scale_steps2,
- "scalingDirection": self.ns_scale_direction
+ self.assertEqual(scale_vnf_data_list, success_list)
+
+ def test_get_nsd_id_when_none(self):
+ self.assertEqual(get_nsdId('ns_instance_id_01'), None)
+
+ def test_check_and_set_params_when_scale_ns_data_is_none(self):
+ try:
+ check_and_set_params(None, '')
+ except Exception as e:
+ self.assertEqual(e.args, ('Error! scaleNsData in the request is Empty!',))
+
+ def test_check_and_set_params_when_scale_ns_by_steps_data_is_none(self):
+ scale_ns_data = {'scaleNsByStepsData': None}
+ try:
+ check_and_set_params(scale_ns_data, '')
+ except Exception as e:
+ self.assertEqual(e.args, ('Error! scaleNsByStepsData in the request is Empty!',))
+
+ @mock.patch.object(os.path, 'abspath')
+ def test_get_scale_vnf_data_info_list(self, mock_abspath):
+ NSInstModel(id='ns_instanceId_02', nsd_id='02').save()
+ NfInstModel(package_id='nf_hw_cscf', status=VNF_STATUS.ACTIVE, nfinstid='nfinst_01').save()
+ mock_abspath.return_value = 'lcm/1/2/3.py'
+ scale_ns_data = {
+ 'scaleNsByStepsData': {'aspectId': 'TIC_EDGE_HW', 'numberOfSteps': 4, 'scalingDirection': 'r'}}
+ ns_instance_id = 'ns_instanceId_02'
+ scale_vnf_data_info_list = get_scale_vnf_data_info_list(scale_ns_data, ns_instance_id)
+ success_list = [
+ {
+ 'vnfInstanceId': 'nfinst_01',
+ 'scaleByStepData': {
+ 'type': 'r',
+ 'aspectId': 'gsu',
+ 'numberOfSteps': '1'
}
- ]
- }]
-
- def initInstModel(self):
- self.nsd_id = "23"
- self.ns_inst_id = "1"
- self.ns_name = "ns_1"
- self.ns_package_id = "ns_zte"
- self.description = "ns_zte"
- self.global_customer_id = "global_customer_id"
- self.service_type = "service_role"
-
- NSInstModel(id=self.ns_inst_id,
- name=self.ns_name,
- nspackage_id=self.ns_package_id,
- nsd_id=self.nsd_id,
- description=self.description,
- status='empty',
- lastuptime=now_time(),
- global_customer_id=self.global_customer_id,
- service_type=self.service_type).save()
-
- self.nf_inst_id = "231"
- self.ns_inst_id = "1"
- self.nf_name = "name_1"
- self.vnf_id = "1"
- self.vnfm_inst_id = "1"
- self.package_id = "nf_zte_cscf"
- self.nf_uuid = "abc34-345a-de13-ab85-ijs9"
-
- NfInstModel.objects.create(
- nfinstid=self.nf_inst_id,
- nf_name=self.nf_name,
- vnf_id=self.vnf_id,
- vnfm_inst_id=self.vnfm_inst_id,
- ns_inst_id=self.ns_inst_id,
- max_cpu='14',
- max_ram='12296',
- max_hd='101',
- max_shd="20",
- max_net=10,
- status='active',
- mnfinstid=self.nf_uuid,
- package_id=self.package_id,
- vnfd_model=json.dumps(VNFD_MODEL_DICT))
-
- # Create a second vnf instance
- self.nf_inst_id = "232"
- self.package_id = "nf_zte_hss"
- self.nf_uuid = "abc34-3g5a-de13-ab85-ijs3"
-
- NfInstModel.objects.create(
- nfinstid=self.nf_inst_id,
- nf_name=self.nf_name,
- vnf_id=self.vnf_id,
- vnfm_inst_id=self.vnfm_inst_id,
- ns_inst_id=self.ns_inst_id,
- max_cpu='14',
- max_ram='12296',
- max_hd='101',
- max_shd="20",
- max_net=10,
- status='active',
- mnfinstid=self.nf_uuid,
- package_id=self.package_id,
- vnfd_model=json.dumps(VNFD_MODEL_DICT))
-
- def add_another_nf_instance(self):
- # Create a third vnf instance
- nf_inst_id = "233"
- package_id = "nf_zte_hss"
- nf_uuid = "ab34-3g5j-de13-ab85-ij93"
-
- NfInstModel.objects.create(
- nfinstid=nf_inst_id,
- nf_name=self.nf_name,
- vnf_id=self.vnf_id,
- vnfm_inst_id=self.vnfm_inst_id,
- ns_inst_id=self.ns_inst_id,
- max_cpu='14',
- max_ram='12296',
- max_hd='101',
- max_shd="20",
- max_net=10,
- status='active',
- mnfinstid=nf_uuid,
- package_id=package_id,
- vnfd_model=json.dumps(VNFD_MODEL_DICT))
-
- def add_new_vnf_instance(self):
- # Create a third vnf instance
- nf_inst_id = "241"
- package_id = "nf_hw_cscf"
- nf_uuid = "ab34-3g5j-de13-aa85-ij93"
-
- NfInstModel.objects.create(
- nfinstid=nf_inst_id,
- nf_name=self.nf_name,
- vnf_id=self.vnf_id,
- vnfm_inst_id=self.vnfm_inst_id,
- ns_inst_id=self.ns_inst_id,
- max_cpu='14',
- max_ram='12296',
- max_hd='101',
- max_shd="20",
- max_net=10,
- status='active',
- mnfinstid=nf_uuid,
- package_id=package_id,
- vnfd_model=json.dumps(VNFD_MODEL_DICT))
-
- # Create a third vnf instance
- nf_inst_id = "242"
- package_id = "nf_hw_hss"
- nf_uuid = "ab34-3g5j-de13-aa85-id93"
+ }
+ ]
+ self.assertEqual(scale_vnf_data_info_list, success_list)
- NfInstModel.objects.create(
- nfinstid=nf_inst_id,
- nf_name=self.nf_name,
- vnf_id=self.vnf_id,
- vnfm_inst_id=self.vnfm_inst_id,
- ns_inst_id=self.ns_inst_id,
- max_cpu='14',
- max_ram='12296',
- max_hd='101',
- max_shd="20",
- max_net=10,
- status='active',
- mnfinstid=nf_uuid,
- package_id=package_id,
- vnfd_model=json.dumps(VNFD_MODEL_DICT))
+ def test_get_vnf_scale_info_when_return_none(self):
+ filename = 'lcm/ns/tests/data/scalemapping.json'
+ ns_instance_id = 'ns_instanceId_03'
+ self.assertEqual(get_vnf_scale_info(filename, ns_instance_id, '', ''), None)
- def tearDown(self):
- NSInstModel().clean()
- NfInstModel().clean()
+ def test_get_scale_vnf_data_from_json_when_return_none(self):
+ self.assertEqual(get_scale_vnf_data_from_json({}, '', '', ''), None)
Code Review / vfc / nfvo / lcm.git / commitdiff