1 #######################################################################################
2 # Copyright ETSI Contributors and Others.
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
16 #######################################################################################
19 from unittest
.mock
import MagicMock
, Mock
, patch
21 from jinja2
import TemplateError
, TemplateNotFound
, UndefinedError
22 from osm_ng_ro
.ns
import Ns
, NsException
25 __author__
= "Eduardo Sousa"
26 __date__
= "$19-NOV-2021 00:00:00$"
29 class TestNs(unittest
.TestCase
):
33 def test__create_task_without_extra_dict(self
):
35 "target_id": "vim_openstack_1",
36 "action_id": "123456",
38 "task_id": "123456:1",
39 "status": "SCHEDULED",
42 "target_record": "test_target_record",
43 "target_record_id": "test_target_record_id",
46 "action_id": "123456",
51 task
= Ns
._create
_task
(
52 deployment_info
=deployment_info
,
53 target_id
="vim_openstack_1",
56 target_record
="test_target_record",
57 target_record_id
="test_target_record_id",
60 self
.assertEqual(deployment_info
.get("task_index"), 2)
61 self
.assertDictEqual(task
, expected_result
)
63 def test__create_task(self
):
65 "target_id": "vim_openstack_1",
66 "action_id": "123456",
68 "task_id": "123456:1",
69 "status": "SCHEDULED",
72 "target_record": "test_target_record",
73 "target_record_id": "test_target_record_id",
74 # values coming from extra_dict
75 "params": "test_params",
76 "find_params": "test_find_params",
77 "depends_on": "test_depends_on",
80 "action_id": "123456",
85 task
= Ns
._create
_task
(
86 deployment_info
=deployment_info
,
87 target_id
="vim_openstack_1",
90 target_record
="test_target_record",
91 target_record_id
="test_target_record_id",
93 "params": "test_params",
94 "find_params": "test_find_params",
95 "depends_on": "test_depends_on",
99 self
.assertEqual(deployment_info
.get("task_index"), 2)
100 self
.assertDictEqual(task
, expected_result
)
102 @patch("osm_ng_ro.ns.time")
103 def test__create_ro_task(self
, mock_time
: Mock
):
104 now
= 1637324838.994551
105 mock_time
.return_value
= now
107 "target_id": "vim_openstack_1",
108 "action_id": "123456",
110 "task_id": "123456:1",
111 "status": "SCHEDULED",
114 "target_record": "test_target_record",
115 "target_record_id": "test_target_record_id",
116 # values coming from extra_dict
117 "params": "test_params",
118 "find_params": "test_find_params",
119 "depends_on": "test_depends_on",
125 "target_id": "vim_openstack_1",
128 "created_items": None,
142 ro_task
= Ns
._create
_ro
_task
(
143 target_id
="vim_openstack_1",
147 self
.assertDictEqual(ro_task
, expected_result
)
149 def test__process_image_params_with_empty_target_image(self
):
155 result
= Ns
._process
_image
_params
(
156 target_image
=target_image
,
159 target_record_id
=None,
162 self
.assertDictEqual(expected_result
, result
)
164 def test__process_image_params_with_wrong_target_image(self
):
169 "no_image": "to_see_here",
172 result
= Ns
._process
_image
_params
(
173 target_image
=target_image
,
176 target_record_id
=None,
179 self
.assertDictEqual(expected_result
, result
)
181 def test__process_image_params_with_image(self
):
193 result
= Ns
._process
_image
_params
(
194 target_image
=target_image
,
197 target_record_id
=None,
200 self
.assertDictEqual(expected_result
, result
)
202 def test__process_image_params_with_vim_image_id(self
):
211 "vim_image_id": "123456",
214 result
= Ns
._process
_image
_params
(
215 target_image
=target_image
,
218 target_record_id
=None,
221 self
.assertDictEqual(expected_result
, result
)
223 def test__process_image_params_with_image_checksum(self
):
227 "checksum": "e3fc50a88d0a364313df4b21ef20c29e",
232 "image_checksum": "e3fc50a88d0a364313df4b21ef20c29e",
235 result
= Ns
._process
_image
_params
(
236 target_image
=target_image
,
239 target_record_id
=None,
242 self
.assertDictEqual(expected_result
, result
)
244 def test__get_resource_allocation_params_with_empty_target_image(self
):
246 quota_descriptor
= {}
248 result
= Ns
._get
_resource
_allocation
_params
(
249 quota_descriptor
=quota_descriptor
,
252 self
.assertDictEqual(expected_result
, result
)
254 def test__get_resource_allocation_params_with_wrong_target_image(self
):
257 "no_quota": "present_here",
260 result
= Ns
._get
_resource
_allocation
_params
(
261 quota_descriptor
=quota_descriptor
,
264 self
.assertDictEqual(expected_result
, result
)
266 def test__get_resource_allocation_params_with_limit(self
):
274 result
= Ns
._get
_resource
_allocation
_params
(
275 quota_descriptor
=quota_descriptor
,
278 self
.assertDictEqual(expected_result
, result
)
280 def test__get_resource_allocation_params_with_reserve(self
):
288 result
= Ns
._get
_resource
_allocation
_params
(
289 quota_descriptor
=quota_descriptor
,
292 self
.assertDictEqual(expected_result
, result
)
294 def test__get_resource_allocation_params_with_shares(self
):
302 result
= Ns
._get
_resource
_allocation
_params
(
303 quota_descriptor
=quota_descriptor
,
306 self
.assertDictEqual(expected_result
, result
)
308 def test__get_resource_allocation_params(self
):
320 result
= Ns
._get
_resource
_allocation
_params
(
321 quota_descriptor
=quota_descriptor
,
324 self
.assertDictEqual(expected_result
, result
)
326 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
327 def test__process_guest_epa_quota_params_with_empty_quota_epa_cpu(
335 result
= Ns
._process
_guest
_epa
_quota
_params
(
336 guest_epa_quota
=guest_epa_quota
,
337 epa_vcpu_set
=epa_vcpu_set
,
340 self
.assertDictEqual(expected_result
, result
)
341 self
.assertFalse(resource_allocation
.called
)
343 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
344 def test__process_guest_epa_quota_params_with_empty_quota_false_epa_cpu(
352 result
= Ns
._process
_guest
_epa
_quota
_params
(
353 guest_epa_quota
=guest_epa_quota
,
354 epa_vcpu_set
=epa_vcpu_set
,
357 self
.assertDictEqual(expected_result
, result
)
358 self
.assertFalse(resource_allocation
.called
)
360 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
361 def test__process_guest_epa_quota_params_with_wrong_quota_epa_cpu(
367 "no-quota": "nothing",
371 result
= Ns
._process
_guest
_epa
_quota
_params
(
372 guest_epa_quota
=guest_epa_quota
,
373 epa_vcpu_set
=epa_vcpu_set
,
376 self
.assertDictEqual(expected_result
, result
)
377 self
.assertFalse(resource_allocation
.called
)
379 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
380 def test__process_guest_epa_quota_params_with_wrong_quota_false_epa_cpu(
386 "no-quota": "nothing",
390 result
= Ns
._process
_guest
_epa
_quota
_params
(
391 guest_epa_quota
=guest_epa_quota
,
392 epa_vcpu_set
=epa_vcpu_set
,
395 self
.assertDictEqual(expected_result
, result
)
396 self
.assertFalse(resource_allocation
.called
)
398 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
399 def test__process_guest_epa_quota_params_with_cpu_quota_epa_cpu(
413 result
= Ns
._process
_guest
_epa
_quota
_params
(
414 guest_epa_quota
=guest_epa_quota
,
415 epa_vcpu_set
=epa_vcpu_set
,
418 self
.assertDictEqual(expected_result
, result
)
419 self
.assertFalse(resource_allocation
.called
)
421 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
422 def test__process_guest_epa_quota_params_with_cpu_quota_false_epa_cpu(
442 resource_allocation_param
= {
447 resource_allocation
.return_value
= {
453 result
= Ns
._process
_guest
_epa
_quota
_params
(
454 guest_epa_quota
=guest_epa_quota
,
455 epa_vcpu_set
=epa_vcpu_set
,
458 resource_allocation
.assert_called_once_with(resource_allocation_param
)
459 self
.assertDictEqual(expected_result
, result
)
461 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
462 def test__process_guest_epa_quota_params_with_mem_quota_epa_cpu(
482 resource_allocation_param
= {
487 resource_allocation
.return_value
= {
493 result
= Ns
._process
_guest
_epa
_quota
_params
(
494 guest_epa_quota
=guest_epa_quota
,
495 epa_vcpu_set
=epa_vcpu_set
,
498 resource_allocation
.assert_called_once_with(resource_allocation_param
)
499 self
.assertDictEqual(expected_result
, result
)
501 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
502 def test__process_guest_epa_quota_params_with_mem_quota_false_epa_cpu(
522 resource_allocation_param
= {
527 resource_allocation
.return_value
= {
533 result
= Ns
._process
_guest
_epa
_quota
_params
(
534 guest_epa_quota
=guest_epa_quota
,
535 epa_vcpu_set
=epa_vcpu_set
,
538 resource_allocation
.assert_called_once_with(resource_allocation_param
)
539 self
.assertDictEqual(expected_result
, result
)
541 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
542 def test__process_guest_epa_quota_params_with_disk_io_quota_epa_cpu(
562 resource_allocation_param
= {
567 resource_allocation
.return_value
= {
573 result
= Ns
._process
_guest
_epa
_quota
_params
(
574 guest_epa_quota
=guest_epa_quota
,
575 epa_vcpu_set
=epa_vcpu_set
,
578 resource_allocation
.assert_called_once_with(resource_allocation_param
)
579 self
.assertDictEqual(expected_result
, result
)
581 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
582 def test__process_guest_epa_quota_params_with_disk_io_quota_false_epa_cpu(
602 resource_allocation_param
= {
607 resource_allocation
.return_value
= {
613 result
= Ns
._process
_guest
_epa
_quota
_params
(
614 guest_epa_quota
=guest_epa_quota
,
615 epa_vcpu_set
=epa_vcpu_set
,
618 resource_allocation
.assert_called_once_with(resource_allocation_param
)
619 self
.assertDictEqual(expected_result
, result
)
621 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
622 def test__process_guest_epa_quota_params_with_vif_quota_epa_cpu(
642 resource_allocation_param
= {
647 resource_allocation
.return_value
= {
653 result
= Ns
._process
_guest
_epa
_quota
_params
(
654 guest_epa_quota
=guest_epa_quota
,
655 epa_vcpu_set
=epa_vcpu_set
,
658 resource_allocation
.assert_called_once_with(resource_allocation_param
)
659 self
.assertDictEqual(expected_result
, result
)
661 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
662 def test__process_guest_epa_quota_params_with_vif_quota_false_epa_cpu(
682 resource_allocation_param
= {
687 resource_allocation
.return_value
= {
693 result
= Ns
._process
_guest
_epa
_quota
_params
(
694 guest_epa_quota
=guest_epa_quota
,
695 epa_vcpu_set
=epa_vcpu_set
,
698 resource_allocation
.assert_called_once_with(resource_allocation_param
)
699 self
.assertDictEqual(expected_result
, result
)
701 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
702 def test__process_guest_epa_quota_params_with_quota_epa_cpu(
747 resource_allocation
.return_value
= {
753 result
= Ns
._process
_guest
_epa
_quota
_params
(
754 guest_epa_quota
=guest_epa_quota
,
755 epa_vcpu_set
=epa_vcpu_set
,
758 self
.assertTrue(resource_allocation
.called
)
759 self
.assertDictEqual(expected_result
, result
)
761 @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
762 def test__process_guest_epa_quota_params_with_quota_epa_cpu_no_set(
812 resource_allocation
.return_value
= {
818 result
= Ns
._process
_guest
_epa
_quota
_params
(
819 guest_epa_quota
=guest_epa_quota
,
820 epa_vcpu_set
=epa_vcpu_set
,
823 self
.assertTrue(resource_allocation
.called
)
824 self
.assertDictEqual(expected_result
, result
)
826 def test__process_guest_epa_numa_params_with_empty_numa_params(self
):
827 expected_numa_result
= {}
828 expected_epa_vcpu_set_result
= False
831 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
832 guest_epa_quota
=guest_epa_quota
,
835 self
.assertDictEqual(expected_numa_result
, numa_result
)
836 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
838 def test__process_guest_epa_numa_params_with_wrong_numa_params(self
):
839 expected_numa_result
= {}
840 expected_epa_vcpu_set_result
= False
841 guest_epa_quota
= {"no_nume": "here"}
843 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
844 guest_epa_quota
=guest_epa_quota
,
847 self
.assertDictEqual(expected_numa_result
, numa_result
)
848 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
850 def test__process_guest_epa_numa_params_with_numa_node_policy(self
):
851 expected_numa_result
= {}
852 expected_epa_vcpu_set_result
= False
853 guest_epa_quota
= {"numa-node-policy": {}}
855 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
856 guest_epa_quota
=guest_epa_quota
,
859 self
.assertDictEqual(expected_numa_result
, numa_result
)
860 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
862 def test__process_guest_epa_numa_params_with_no_node(self
):
863 expected_numa_result
= {}
864 expected_epa_vcpu_set_result
= False
866 "numa-node-policy": {
871 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
872 guest_epa_quota
=guest_epa_quota
,
875 self
.assertDictEqual(expected_numa_result
, numa_result
)
876 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
878 def test__process_guest_epa_numa_params_with_1_node_num_cores(self
):
879 expected_numa_result
= {"cores": 3}
880 expected_epa_vcpu_set_result
= True
882 "numa-node-policy": {
891 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
892 guest_epa_quota
=guest_epa_quota
,
895 self
.assertDictEqual(expected_numa_result
, numa_result
)
896 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
898 def test__process_guest_epa_numa_params_with_1_node_paired_threads(self
):
899 expected_numa_result
= {"paired-threads": 3}
900 expected_epa_vcpu_set_result
= True
902 "numa-node-policy": {
905 "paired-threads": {"num-paired-threads": "3"},
911 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
912 guest_epa_quota
=guest_epa_quota
,
915 self
.assertDictEqual(expected_numa_result
, numa_result
)
916 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
918 def test__process_guest_epa_numa_params_with_1_node_paired_threads_ids(self
):
919 expected_numa_result
= {
920 "paired-threads-id": [("0", "1"), ("4", "5")],
922 expected_epa_vcpu_set_result
= False
924 "numa-node-policy": {
928 "paired-thread-ids": [
944 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
945 guest_epa_quota
=guest_epa_quota
,
948 self
.assertDictEqual(expected_numa_result
, numa_result
)
949 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
951 def test__process_guest_epa_numa_params_with_1_node_num_threads(self
):
952 expected_numa_result
= {"threads": 3}
953 expected_epa_vcpu_set_result
= True
955 "numa-node-policy": {
964 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
965 guest_epa_quota
=guest_epa_quota
,
968 self
.assertDictEqual(expected_numa_result
, numa_result
)
969 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
971 def test__process_guest_epa_numa_params_with_1_node_memory_mb(self
):
972 expected_numa_result
= {"memory": 2}
973 expected_epa_vcpu_set_result
= False
975 "numa-node-policy": {
984 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
985 guest_epa_quota
=guest_epa_quota
,
988 self
.assertDictEqual(expected_numa_result
, numa_result
)
989 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
991 def test__process_guest_epa_numa_params_with_1_node(self
):
992 expected_numa_result
= {
995 "paired-threads-id": [("0", "1"), ("4", "5")],
999 expected_epa_vcpu_set_result
= True
1001 "numa-node-policy": {
1006 "num-paired-threads": "3",
1007 "paired-thread-ids": [
1025 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
1026 guest_epa_quota
=guest_epa_quota
,
1029 self
.assertDictEqual(expected_numa_result
, numa_result
)
1030 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1032 def test__process_guest_epa_numa_params_with_2_nodes(self
):
1033 expected_numa_result
= {
1035 "paired-threads": 3,
1036 "paired-threads-id": [("0", "1"), ("4", "5")],
1040 expected_epa_vcpu_set_result
= True
1042 "numa-node-policy": {
1047 "num-paired-threads": "3",
1048 "paired-thread-ids": [
1065 "num-paired-threads": "7",
1066 "paired-thread-ids": [
1084 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_numa
_params
(
1085 guest_epa_quota
=guest_epa_quota
,
1088 self
.assertDictEqual(expected_numa_result
, numa_result
)
1089 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1091 def test__process_guest_epa_cpu_pinning_params_with_empty_params(self
):
1092 expected_numa_result
= {}
1093 expected_epa_vcpu_set_result
= False
1094 guest_epa_quota
= {}
1096 epa_vcpu_set
= False
1098 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1099 guest_epa_quota
=guest_epa_quota
,
1100 vcpu_count
=vcpu_count
,
1101 epa_vcpu_set
=epa_vcpu_set
,
1104 self
.assertDictEqual(expected_numa_result
, numa_result
)
1105 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1107 def test__process_guest_epa_cpu_pinning_params_with_wrong_params(self
):
1108 expected_numa_result
= {}
1109 expected_epa_vcpu_set_result
= False
1111 "no-cpu-pinning-policy": "here",
1114 epa_vcpu_set
= False
1116 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1117 guest_epa_quota
=guest_epa_quota
,
1118 vcpu_count
=vcpu_count
,
1119 epa_vcpu_set
=epa_vcpu_set
,
1122 self
.assertDictEqual(expected_numa_result
, numa_result
)
1123 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1125 def test__process_guest_epa_cpu_pinning_params_with_epa_vcpu_set(self
):
1126 expected_numa_result
= {}
1127 expected_epa_vcpu_set_result
= True
1129 "cpu-pinning-policy": "DEDICATED",
1134 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1135 guest_epa_quota
=guest_epa_quota
,
1136 vcpu_count
=vcpu_count
,
1137 epa_vcpu_set
=epa_vcpu_set
,
1140 self
.assertDictEqual(expected_numa_result
, numa_result
)
1141 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1143 def test__process_guest_epa_cpu_pinning_params_with_threads(self
):
1144 expected_numa_result
= {"threads": 3}
1145 expected_epa_vcpu_set_result
= True
1147 "cpu-pinning-policy": "DEDICATED",
1148 "cpu-thread-pinning-policy": "PREFER",
1151 epa_vcpu_set
= False
1153 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1154 guest_epa_quota
=guest_epa_quota
,
1155 vcpu_count
=vcpu_count
,
1156 epa_vcpu_set
=epa_vcpu_set
,
1159 self
.assertDictEqual(expected_numa_result
, numa_result
)
1160 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1162 def test__process_guest_epa_cpu_pinning_params(self
):
1163 expected_numa_result
= {"cores": 3}
1164 expected_epa_vcpu_set_result
= True
1166 "cpu-pinning-policy": "DEDICATED",
1169 epa_vcpu_set
= False
1171 numa_result
, epa_vcpu_set_result
= Ns
._process
_guest
_epa
_cpu
_pinning
_params
(
1172 guest_epa_quota
=guest_epa_quota
,
1173 vcpu_count
=vcpu_count
,
1174 epa_vcpu_set
=epa_vcpu_set
,
1177 self
.assertDictEqual(expected_numa_result
, numa_result
)
1178 self
.assertEqual(expected_epa_vcpu_set_result
, epa_vcpu_set_result
)
1180 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1181 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1182 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1183 def test__process_guest_epa_params_with_empty_params(
1185 guest_epa_numa_params
,
1186 guest_epa_cpu_pinning_params
,
1187 guest_epa_quota_params
,
1189 expected_result
= {}
1192 result
= Ns
._process
_epa
_params
(
1193 target_flavor
=target_flavor
,
1196 self
.assertDictEqual(expected_result
, result
)
1197 self
.assertFalse(guest_epa_numa_params
.called
)
1198 self
.assertFalse(guest_epa_cpu_pinning_params
.called
)
1199 self
.assertFalse(guest_epa_quota_params
.called
)
1201 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1202 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1203 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1204 def test__process_guest_epa_params_with_wrong_params(
1206 guest_epa_numa_params
,
1207 guest_epa_cpu_pinning_params
,
1208 guest_epa_quota_params
,
1210 expected_result
= {}
1212 "no-guest-epa": "here",
1215 result
= Ns
._process
_epa
_params
(
1216 target_flavor
=target_flavor
,
1219 self
.assertDictEqual(expected_result
, result
)
1220 self
.assertFalse(guest_epa_numa_params
.called
)
1221 self
.assertFalse(guest_epa_cpu_pinning_params
.called
)
1222 self
.assertFalse(guest_epa_quota_params
.called
)
1224 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1225 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1226 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1227 def test__process_guest_epa_params(
1229 guest_epa_numa_params
,
1230 guest_epa_cpu_pinning_params
,
1231 guest_epa_quota_params
,
1233 expected_result
= {}
1240 guest_epa_numa_params
.return_value
= ({}, False)
1241 guest_epa_cpu_pinning_params
.return_value
= ({}, False)
1242 guest_epa_quota_params
.return_value
= {}
1244 result
= Ns
._process
_epa
_params
(
1245 target_flavor
=target_flavor
,
1248 self
.assertDictEqual(expected_result
, result
)
1249 self
.assertTrue(guest_epa_numa_params
.called
)
1250 self
.assertTrue(guest_epa_cpu_pinning_params
.called
)
1251 self
.assertTrue(guest_epa_quota_params
.called
)
1253 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1254 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1255 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1256 def test__process_guest_epa_params_with_mempage_size(
1258 guest_epa_numa_params
,
1259 guest_epa_cpu_pinning_params
,
1260 guest_epa_quota_params
,
1263 "mempage-size": "1G",
1266 "guest-epa": {"vcpu-count": 1, "mempage-size": "1G"},
1269 guest_epa_numa_params
.return_value
= ({}, False)
1270 guest_epa_cpu_pinning_params
.return_value
= ({}, False)
1271 guest_epa_quota_params
.return_value
= {}
1273 result
= Ns
._process
_epa
_params
(
1274 target_flavor
=target_flavor
,
1277 self
.assertDictEqual(expected_result
, result
)
1278 self
.assertTrue(guest_epa_numa_params
.called
)
1279 self
.assertTrue(guest_epa_cpu_pinning_params
.called
)
1280 self
.assertTrue(guest_epa_quota_params
.called
)
1282 @patch("osm_ng_ro.ns.Ns._process_guest_epa_quota_params")
1283 @patch("osm_ng_ro.ns.Ns._process_guest_epa_cpu_pinning_params")
1284 @patch("osm_ng_ro.ns.Ns._process_guest_epa_numa_params")
1285 def test__process_guest_epa_params_with_numa(
1287 guest_epa_numa_params
,
1288 guest_epa_cpu_pinning_params
,
1289 guest_epa_quota_params
,
1292 "mempage-size": "1G",
1297 "paired-threads": 3,
1298 "paired-threads-id": [("0", "1"), ("4", "5")],
1302 "cpu-quota": {"limit": 10, "reserve": 20, "shares": 30},
1303 "disk-io-quota": {"limit": 10, "reserve": 20, "shares": 30},
1304 "mem-quota": {"limit": 10, "reserve": 20, "shares": 30},
1305 "vif-quota": {"limit": 10, "reserve": 20, "shares": 30},
1310 "mempage-size": "1G",
1311 "cpu-pinning-policy": "DEDICATED",
1312 "cpu-thread-pinning-policy": "PREFER",
1313 "numa-node-policy": {
1318 "num-paired-threads": "3",
1319 "paired-thread-ids": [
1358 guest_epa_numa_params
.return_value
= (
1361 "paired-threads": 3,
1362 "paired-threads-id": [("0", "1"), ("4", "5")],
1368 guest_epa_cpu_pinning_params
.return_value
= (
1374 guest_epa_quota_params
.return_value
= {
1397 result
= Ns
._process
_epa
_params
(
1398 target_flavor
=target_flavor
,
1401 self
.assertDictEqual(expected_result
, result
)
1402 self
.assertTrue(guest_epa_numa_params
.called
)
1403 self
.assertTrue(guest_epa_cpu_pinning_params
.called
)
1404 self
.assertTrue(guest_epa_quota_params
.called
)
1406 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1407 def test__process_flavor_params_with_empty_target_flavor(
1414 target_record_id
= ""
1416 with self
.assertRaises(KeyError):
1417 Ns
._process
_flavor
_params
(
1418 target_flavor
=target_flavor
,
1421 target_record_id
=target_record_id
,
1424 self
.assertFalse(epa_params
.called
)
1426 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1427 def test__process_flavor_params_with_wrong_target_flavor(
1432 "no-target-flavor": "here",
1436 target_record_id
= ""
1438 with self
.assertRaises(KeyError):
1439 Ns
._process
_flavor
_params
(
1440 target_flavor
=target_flavor
,
1443 target_record_id
=target_record_id
,
1446 self
.assertFalse(epa_params
.called
)
1448 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1449 def test__process_flavor_params_with_empty_indata(
1473 "memory-mb": "1024",
1478 target_record_id
= ""
1480 epa_params
.return_value
= {}
1482 result
= Ns
._process
_flavor
_params
(
1483 target_flavor
=target_flavor
,
1486 target_record_id
=target_record_id
,
1489 self
.assertTrue(epa_params
.called
)
1490 self
.assertDictEqual(result
, expected_result
)
1492 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1493 def test__process_flavor_params_with_wrong_indata(
1517 "memory-mb": "1024",
1524 target_record_id
= ""
1526 epa_params
.return_value
= {}
1528 result
= Ns
._process
_flavor
_params
(
1529 target_flavor
=target_flavor
,
1532 target_record_id
=target_record_id
,
1535 self
.assertTrue(epa_params
.called
)
1536 self
.assertDictEqual(result
, expected_result
)
1538 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1539 def test__process_flavor_params_with_ephemeral_disk(
1566 "memory-mb": "1024",
1574 "ns-flavor-id": "test_id",
1575 "virtual-storages": [
1577 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1578 "size-of-storage": "10",
1587 target_record_id
= ""
1589 epa_params
.return_value
= {}
1591 result
= Ns
._process
_flavor
_params
(
1592 target_flavor
=target_flavor
,
1595 target_record_id
=target_record_id
,
1598 self
.assertTrue(epa_params
.called
)
1599 self
.assertDictEqual(result
, expected_result
)
1601 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1602 def test__process_flavor_params_with_swap_disk(
1629 "memory-mb": "1024",
1637 "ns-flavor-id": "test_id",
1638 "virtual-storages": [
1640 "type-of-storage": "etsi-nfv-descriptors:swap-storage",
1641 "size-of-storage": "20",
1650 target_record_id
= ""
1652 epa_params
.return_value
= {}
1654 result
= Ns
._process
_flavor
_params
(
1655 target_flavor
=target_flavor
,
1658 target_record_id
=target_record_id
,
1661 self
.assertTrue(epa_params
.called
)
1662 self
.assertDictEqual(result
, expected_result
)
1664 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1665 def test__process_flavor_params_with_epa_params(
1676 "numa": "there-is-numa-here",
1687 "numa": "there-is-numa-here",
1696 "memory-mb": "1024",
1701 target_record_id
= ""
1703 epa_params
.return_value
= {
1704 "numa": "there-is-numa-here",
1707 result
= Ns
._process
_flavor
_params
(
1708 target_flavor
=target_flavor
,
1711 target_record_id
=target_record_id
,
1714 self
.assertTrue(epa_params
.called
)
1715 self
.assertDictEqual(result
, expected_result
)
1717 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1718 def test__process_flavor_params(
1731 "numa": "there-is-numa-here",
1744 "numa": "there-is-numa-here",
1753 "memory-mb": "1024",
1761 "ns-flavor-id": "test_id",
1762 "virtual-storages": [
1764 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1765 "size-of-storage": "10",
1768 "type-of-storage": "etsi-nfv-descriptors:swap-storage",
1769 "size-of-storage": "20",
1778 target_record_id
= ""
1780 epa_params
.return_value
= {
1781 "numa": "there-is-numa-here",
1784 result
= Ns
._process
_flavor
_params
(
1785 target_flavor
=target_flavor
,
1788 target_record_id
=target_record_id
,
1791 self
.assertTrue(epa_params
.called
)
1792 self
.assertDictEqual(result
, expected_result
)
1794 def test__ip_profile_to_ro_with_none(self
):
1797 result
= Ns
._ip
_profile
_to
_ro
(
1798 ip_profile
=ip_profile
,
1801 self
.assertIsNone(result
)
1803 def test__ip_profile_to_ro_with_empty_profile(self
):
1806 result
= Ns
._ip
_profile
_to
_ro
(
1807 ip_profile
=ip_profile
,
1810 self
.assertIsNone(result
)
1812 def test__ip_profile_to_ro_with_wrong_profile(self
):
1814 "no-profile": "here",
1817 "ip_version": "IPv4",
1818 "subnet_address": None,
1819 "gateway_address": None,
1820 "dhcp_enabled": False,
1821 "dhcp_start_address": None,
1825 result
= Ns
._ip
_profile
_to
_ro
(
1826 ip_profile
=ip_profile
,
1829 self
.assertDictEqual(expected_result
, result
)
1831 def test__ip_profile_to_ro_with_ipv4_profile(self
):
1833 "ip-version": "ipv4",
1834 "subnet-address": "192.168.0.0/24",
1835 "gateway-address": "192.168.0.254",
1838 "start-address": "192.168.0.10",
1843 "ip_version": "IPv4",
1844 "subnet_address": "192.168.0.0/24",
1845 "gateway_address": "192.168.0.254",
1846 "dhcp_enabled": True,
1847 "dhcp_start_address": "192.168.0.10",
1851 result
= Ns
._ip
_profile
_to
_ro
(
1852 ip_profile
=ip_profile
,
1855 self
.assertDictEqual(expected_result
, result
)
1857 def test__ip_profile_to_ro_with_ipv6_profile(self
):
1859 "ip-version": "ipv6",
1860 "subnet-address": "2001:0200:0001::/48",
1861 "gateway-address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe",
1864 "start-address": "2001:0200:0001::0010",
1869 "ip_version": "IPv6",
1870 "subnet_address": "2001:0200:0001::/48",
1871 "gateway_address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe",
1872 "dhcp_enabled": True,
1873 "dhcp_start_address": "2001:0200:0001::0010",
1877 result
= Ns
._ip
_profile
_to
_ro
(
1878 ip_profile
=ip_profile
,
1881 self
.assertDictEqual(expected_result
, result
)
1883 def test__ip_profile_to_ro_with_dns_server(self
):
1885 "ip-version": "ipv4",
1886 "subnet-address": "192.168.0.0/24",
1887 "gateway-address": "192.168.0.254",
1890 "start-address": "192.168.0.10",
1895 "address": "8.8.8.8",
1898 "address": "1.1.1.1",
1901 "address": "1.0.0.1",
1906 "ip_version": "IPv4",
1907 "subnet_address": "192.168.0.0/24",
1908 "gateway_address": "192.168.0.254",
1909 "dhcp_enabled": True,
1910 "dhcp_start_address": "192.168.0.10",
1912 "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
1915 result
= Ns
._ip
_profile
_to
_ro
(
1916 ip_profile
=ip_profile
,
1919 self
.assertDictEqual(expected_result
, result
)
1921 def test__ip_profile_to_ro_with_security_group(self
):
1923 "ip-version": "ipv4",
1924 "subnet-address": "192.168.0.0/24",
1925 "gateway-address": "192.168.0.254",
1928 "start-address": "192.168.0.10",
1932 "some-security-group": "here",
1936 "ip_version": "IPv4",
1937 "subnet_address": "192.168.0.0/24",
1938 "gateway_address": "192.168.0.254",
1939 "dhcp_enabled": True,
1940 "dhcp_start_address": "192.168.0.10",
1943 "some-security-group": "here",
1947 result
= Ns
._ip
_profile
_to
_ro
(
1948 ip_profile
=ip_profile
,
1951 self
.assertDictEqual(expected_result
, result
)
1953 def test__ip_profile_to_ro(self
):
1955 "ip-version": "ipv4",
1956 "subnet-address": "192.168.0.0/24",
1957 "gateway-address": "192.168.0.254",
1960 "start-address": "192.168.0.10",
1965 "address": "8.8.8.8",
1968 "address": "1.1.1.1",
1971 "address": "1.0.0.1",
1975 "some-security-group": "here",
1979 "ip_version": "IPv4",
1980 "subnet_address": "192.168.0.0/24",
1981 "gateway_address": "192.168.0.254",
1982 "dhcp_enabled": True,
1983 "dhcp_start_address": "192.168.0.10",
1985 "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
1987 "some-security-group": "here",
1991 result
= Ns
._ip
_profile
_to
_ro
(
1992 ip_profile
=ip_profile
,
1995 self
.assertDictEqual(expected_result
, result
)
1997 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
1998 def test__process_net_params_with_empty_params(
2009 "provider_network": "some-profile-here",
2011 target_record_id
= ""
2014 "net_name": "ns-name-vld-name",
2015 "net_type": "bridge",
2017 "some_ip_profile": "here",
2019 "provider_network_profile": "some-profile-here",
2023 ip_profile_to_ro
.return_value
= {
2024 "some_ip_profile": "here",
2027 result
= Ns
._process
_net
_params
(
2028 target_vld
=target_vld
,
2031 target_record_id
=target_record_id
,
2034 self
.assertDictEqual(expected_result
, result
)
2035 self
.assertTrue(ip_profile_to_ro
.called
)
2037 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2038 def test__process_net_params_with_vim_info_sdn(
2050 "sdn-ports": ["some", "ports", "here"],
2051 "vlds": ["some", "vlds", "here"],
2054 target_record_id
= "vld.sdn.something"
2057 "sdn-ports": ["some", "ports", "here"],
2058 "vlds": ["some", "vlds", "here"],
2063 result
= Ns
._process
_net
_params
(
2064 target_vld
=target_vld
,
2067 target_record_id
=target_record_id
,
2070 self
.assertDictEqual(expected_result
, result
)
2071 self
.assertFalse(ip_profile_to_ro
.called
)
2073 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2074 def test__process_net_params_with_vim_info_sdn_target_vim(
2086 "sdn-ports": ["some", "ports", "here"],
2087 "vlds": ["some", "vlds", "here"],
2088 "target_vim": "some-vim",
2091 target_record_id
= "vld.sdn.something"
2093 "depends_on": ["some-vim vld.sdn"],
2095 "sdn-ports": ["some", "ports", "here"],
2096 "vlds": ["some", "vlds", "here"],
2097 "target_vim": "some-vim",
2102 result
= Ns
._process
_net
_params
(
2103 target_vld
=target_vld
,
2106 target_record_id
=target_record_id
,
2109 self
.assertDictEqual(expected_result
, result
)
2110 self
.assertFalse(ip_profile_to_ro
.called
)
2112 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2113 def test__process_net_params_with_vim_network_name(
2124 "vim_network_name": "some-network-name",
2126 target_record_id
= "vld.sdn.something"
2130 "name": "some-network-name",
2135 result
= Ns
._process
_net
_params
(
2136 target_vld
=target_vld
,
2139 target_record_id
=target_record_id
,
2142 self
.assertDictEqual(expected_result
, result
)
2143 self
.assertFalse(ip_profile_to_ro
.called
)
2145 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2146 def test__process_net_params_with_vim_network_id(
2157 "vim_network_id": "some-network-id",
2159 target_record_id
= "vld.sdn.something"
2163 "id": "some-network-id",
2168 result
= Ns
._process
_net
_params
(
2169 target_vld
=target_vld
,
2172 target_record_id
=target_record_id
,
2175 self
.assertDictEqual(expected_result
, result
)
2176 self
.assertFalse(ip_profile_to_ro
.called
)
2178 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2179 def test__process_net_params_with_mgmt_network(
2186 "mgmt-network": "some-mgmt-network",
2192 target_record_id
= "vld.sdn.something"
2200 result
= Ns
._process
_net
_params
(
2201 target_vld
=target_vld
,
2204 target_record_id
=target_record_id
,
2207 self
.assertDictEqual(expected_result
, result
)
2208 self
.assertFalse(ip_profile_to_ro
.called
)
2210 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2211 def test__process_net_params_with_underlay_eline(
2217 "underlay": "some-underlay-here",
2224 "provider_network": "some-profile-here",
2226 target_record_id
= ""
2230 "some_ip_profile": "here",
2232 "net_name": "ns-name-vld-name",
2234 "provider_network_profile": "some-profile-here",
2238 ip_profile_to_ro
.return_value
= {
2239 "some_ip_profile": "here",
2242 result
= Ns
._process
_net
_params
(
2243 target_vld
=target_vld
,
2246 target_record_id
=target_record_id
,
2249 self
.assertDictEqual(expected_result
, result
)
2250 self
.assertTrue(ip_profile_to_ro
.called
)
2252 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2253 def test__process_net_params_with_underlay_elan(
2259 "underlay": "some-underlay-here",
2266 "provider_network": "some-profile-here",
2268 target_record_id
= ""
2272 "some_ip_profile": "here",
2274 "net_name": "ns-name-vld-name",
2276 "provider_network_profile": "some-profile-here",
2280 ip_profile_to_ro
.return_value
= {
2281 "some_ip_profile": "here",
2284 result
= Ns
._process
_net
_params
(
2285 target_vld
=target_vld
,
2288 target_record_id
=target_record_id
,
2291 self
.assertDictEqual(expected_result
, result
)
2292 self
.assertTrue(ip_profile_to_ro
.called
)
2294 def test__get_cloud_init_exception(self
):
2295 db_mock
= MagicMock(name
="database mock")
2300 with self
.assertRaises(NsException
):
2301 Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2303 def test__get_cloud_init_file_fs_exception(self
):
2304 db_mock
= MagicMock(name
="database mock")
2307 location
= "vnfr_id_123456:file:test_file"
2308 db_mock
.get_one
.return_value
= {
2311 "folder": "/home/osm",
2312 "pkg-dir": "vnfr_test_dir",
2317 with self
.assertRaises(NsException
):
2318 Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2320 def test__get_cloud_init_file(self
):
2321 db_mock
= MagicMock(name
="database mock")
2322 fs_mock
= MagicMock(name
="filesystem mock")
2323 file_mock
= MagicMock(name
="file mock")
2325 location
= "vnfr_id_123456:file:test_file"
2326 cloud_init_content
= "this is a cloud init file content"
2328 db_mock
.get_one
.return_value
= {
2331 "folder": "/home/osm",
2332 "pkg-dir": "vnfr_test_dir",
2336 fs_mock
.file_open
.return_value
= file_mock
2337 file_mock
.__enter
__.return_value
.read
.return_value
= cloud_init_content
2339 result
= Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2341 self
.assertEqual(cloud_init_content
, result
)
2343 def test__get_cloud_init_vdu(self
):
2344 db_mock
= MagicMock(name
="database mock")
2347 location
= "vnfr_id_123456:vdu:0"
2348 cloud_init_content
= "this is a cloud init file content"
2350 db_mock
.get_one
.return_value
= {
2353 "cloud-init": cloud_init_content
,
2358 result
= Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2360 self
.assertEqual(cloud_init_content
, result
)
2362 @patch("jinja2.Environment.__init__")
2363 def test__parse_jinja2_undefined_error(self
, env_mock
: Mock
):
2364 cloud_init_content
= None
2368 env_mock
.side_effect
= UndefinedError("UndefinedError occurred.")
2370 with self
.assertRaises(NsException
):
2372 cloud_init_content
=cloud_init_content
, params
=params
, context
=context
2375 @patch("jinja2.Environment.__init__")
2376 def test__parse_jinja2_template_error(self
, env_mock
: Mock
):
2377 cloud_init_content
= None
2381 env_mock
.side_effect
= TemplateError("TemplateError occurred.")
2383 with self
.assertRaises(NsException
):
2385 cloud_init_content
=cloud_init_content
, params
=params
, context
=context
2388 @patch("jinja2.Environment.__init__")
2389 def test__parse_jinja2_template_not_found(self
, env_mock
: Mock
):
2390 cloud_init_content
= None
2394 env_mock
.side_effect
= TemplateNotFound("TemplateNotFound occurred.")
2396 with self
.assertRaises(NsException
):
2398 cloud_init_content
=cloud_init_content
, params
=params
, context
=context
2401 def test__parse_jinja2(self
):
2404 def test__process_vdu_params_empty_kargs(self
):
2407 def test__process_vdu_params_interface_ns_vld_id(self
):
2410 def test__process_vdu_params_interface_vnf_vld_id(self
):
2413 def test__process_vdu_params_interface_unknown(self
):
2416 def test__process_vdu_params_interface_port_security_enabled(self
):
2419 def test__process_vdu_params_interface_port_security_disable_strategy(self
):
2422 def test__process_vdu_params_interface_sriov(self
):
2425 def test__process_vdu_params_interface_pci_passthrough(self
):
2428 def test__process_vdu_params_interface_om_mgmt(self
):
2431 def test__process_vdu_params_interface_mgmt_interface(self
):
2434 def test__process_vdu_params_interface_mgmt_vnf(self
):
2437 def test__process_vdu_params_interface_bridge(self
):
2440 def test__process_vdu_params_interface_ip_address(self
):
2443 def test__process_vdu_params_interface_mac_address(self
):
2446 def test__process_vdu_params_vdu_cloud_init_missing(self
):
2449 def test__process_vdu_params_vdu_cloud_init_present(self
):
2452 def test__process_vdu_params_vdu_boot_data_drive(self
):
2455 def test__process_vdu_params_vdu_ssh_keys(self
):
2458 def test__process_vdu_params_vdu_ssh_access_required(self
):
2461 @patch("osm_ng_ro.ns.Ns._get_cloud_init")
2462 @patch("osm_ng_ro.ns.Ns._parse_jinja2")
2463 def test__process_vdu_params_vdu_persistent_root_volume(
2464 self
, get_cloud_init
, parse_jinja2
2466 db
= MagicMock(name
="database mock")
2469 "vdu2cloud_init": {},
2471 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2472 "member-vnf-index-ref": "vnf-several-volumes",
2475 get_cloud_init
.return_value
= {}
2476 parse_jinja2
.return_value
= {}
2477 db
.get_one
.return_value
= {
2478 "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2483 {"id": "several_volumes-VM", "min-number-of-instances": 1}
2487 "id": "several_volumes-vnf",
2488 "product-name": "several_volumes-vnf",
2491 "id": "several_volumes-VM",
2492 "name": "several_volumes-VM",
2493 "sw-image-desc": "ubuntu20.04",
2494 "alternative-sw-image-desc": [
2496 "ubuntu20.04-azure",
2498 "virtual-storage-desc": [
2499 "persistent-root-volume",
2500 "persistent-volume2",
2506 "virtual-storage-desc": [
2508 "id": "persistent-volume2",
2509 "type-of-storage": "persistent-storage:persistent-storage",
2510 "size-of-storage": "10",
2513 "id": "persistent-root-volume",
2514 "type-of-storage": "persistent-storage:persistent-storage",
2515 "size-of-storage": "10",
2518 "id": "ephemeral-volume",
2519 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2520 "size-of-storage": "1",
2526 "path": "/app/storage/",
2533 "_id": "09a0baa7-b7cb-4924-bd63-9f04a1c23960",
2534 "ns-flavor-id": "0",
2536 "vdu-name": "several_volumes-VM",
2540 "ns-vld-id": "mgmtnet",
2543 "virtual-storages": [
2545 "id": "persistent-volume2",
2546 "size-of-storage": "10",
2547 "type-of-storage": "persistent-storage:persistent-storage",
2550 "id": "persistent-root-volume",
2551 "size-of-storage": "10",
2552 "type-of-storage": "persistent-storage:persistent-storage",
2555 "id": "ephemeral-volume",
2556 "size-of-storage": "1",
2557 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2562 "name": "sample_name",
2564 expected_result
= [{"image_id": "ubuntu20.04", "size": "10"}, {"size": "10"}]
2565 result
= Ns
._process
_vdu
_params
(
2566 target_vdu
, indata
, vim_info
=None, target_record_id
=None, **kwargs
2569 expected_result
, result
["params"]["disk_list"], "Wrong Disk List"
2572 @patch("osm_ng_ro.ns.Ns._get_cloud_init")
2573 @patch("osm_ng_ro.ns.Ns._parse_jinja2")
2574 def test__process_vdu_params_vdu_without_persistent_storage(
2575 self
, get_cloud_init
, parse_jinja2
2577 db
= MagicMock(name
="database mock")
2580 "vdu2cloud_init": {},
2582 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2583 "member-vnf-index-ref": "vnf-several-volumes",
2586 get_cloud_init
.return_value
= {}
2587 parse_jinja2
.return_value
= {}
2588 db
.get_one
.return_value
= {
2589 "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2594 {"id": "without_volumes-VM", "min-number-of-instances": 1}
2598 "id": "without_volumes-vnf",
2599 "product-name": "without_volumes-vnf",
2602 "id": "without_volumes-VM",
2603 "name": "without_volumes-VM",
2604 "sw-image-desc": "ubuntu20.04",
2605 "alternative-sw-image-desc": [
2607 "ubuntu20.04-azure",
2609 "virtual-storage-desc": ["root-volume", "ephemeral-volume"],
2613 "virtual-storage-desc": [
2614 {"id": "root-volume", "size-of-storage": "10"},
2616 "id": "ephemeral-volume",
2617 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2618 "size-of-storage": "1",
2624 "path": "/app/storage/",
2631 "_id": "09a0baa7-b7cb-4924-bd63-9f04a1c23960",
2632 "ns-flavor-id": "0",
2634 "vdu-name": "without_volumes-VM",
2638 "ns-vld-id": "mgmtnet",
2641 "virtual-storages": [
2643 "id": "root-volume",
2644 "size-of-storage": "10",
2647 "id": "ephemeral-volume",
2648 "size-of-storage": "1",
2649 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2654 "name": "sample_name",
2656 expected_result
= []
2657 result
= Ns
._process
_vdu
_params
(
2658 target_vdu
, indata
, vim_info
=None, target_record_id
=None, **kwargs
2661 expected_result
, result
["params"]["disk_list"], "Wrong Disk List"
2664 def test__process_vdu_params(self
):
2667 @patch("osm_ng_ro.ns.Ns._assign_vim")
2668 def test__rebuild_start_stop_task(self
, assign_vim
):
2671 actions
= ["start", "stop", "rebuild"]
2672 vdu_id
= "bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
2673 vnf_id
= "665b4165-ce24-4320-bf19-b9a45bade49f"
2675 action_id
= "bb937f49-3870-4169-b758-9732e1ff40f3"
2676 nsr_id
= "993166fe-723e-4680-ac4b-b1af2541ae31"
2678 target_vim
= "vim:f9f370ac-0d44-41a7-9000-457f2332bc35"
2679 t
= "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
2680 for action
in actions
:
2682 "target_id": "vim:f9f370ac-0d44-41a7-9000-457f2332bc35",
2683 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
2684 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
2685 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
2686 "status": "SCHEDULED",
2689 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
2690 "target_record_id": t
,
2692 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2696 extra_dict
["params"] = {
2697 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2700 task
= self
.ns
.rebuild_start_stop_task(
2710 self
.assertEqual(task
.get("action_id"), action_id
)
2711 self
.assertEqual(task
.get("nsr_id"), nsr_id
)
2712 self
.assertEqual(task
.get("target_id"), target_vim
)
2713 self
.assertDictEqual(task
, expected_result
)