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(
1416 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1421 target_record_id
= ""
1423 with self
.assertRaises(KeyError):
1424 Ns
._process
_flavor
_params
(
1425 target_flavor
=target_flavor
,
1428 target_record_id
=target_record_id
,
1431 self
.assertFalse(epa_params
.called
)
1433 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1434 def test__process_flavor_params_with_wrong_target_flavor(
1440 "no-target-flavor": "here",
1444 target_record_id
= ""
1446 with self
.assertRaises(KeyError):
1447 Ns
._process
_flavor
_params
(
1448 target_flavor
=target_flavor
,
1451 target_record_id
=target_record_id
,
1454 self
.assertFalse(epa_params
.called
)
1456 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1457 def test__process_flavor_params_with_empty_indata(
1482 "memory-mb": "1024",
1487 target_record_id
= ""
1489 epa_params
.return_value
= {}
1491 result
= Ns
._process
_flavor
_params
(
1492 target_flavor
=target_flavor
,
1495 target_record_id
=target_record_id
,
1498 self
.assertTrue(epa_params
.called
)
1499 self
.assertDictEqual(result
, expected_result
)
1501 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1502 def test__process_flavor_params_with_wrong_indata(
1527 "memory-mb": "1024",
1534 target_record_id
= ""
1536 epa_params
.return_value
= {}
1538 result
= Ns
._process
_flavor
_params
(
1539 target_flavor
=target_flavor
,
1542 target_record_id
=target_record_id
,
1545 self
.assertTrue(epa_params
.called
)
1546 self
.assertDictEqual(result
, expected_result
)
1548 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1549 def test__process_flavor_params_with_ephemeral_disk(
1553 db
= MagicMock(name
="database mock")
1558 db
.get_one
.return_value
= {
1559 "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1564 {"id": "without_volumes-VM", "min-number-of-instances": 1}
1568 "id": "without_volumes-vnf",
1569 "product-name": "without_volumes-vnf",
1572 "id": "without_volumes-VM",
1573 "name": "without_volumes-VM",
1574 "sw-image-desc": "ubuntu20.04",
1575 "alternative-sw-image-desc": [
1577 "ubuntu20.04-azure",
1579 "virtual-storage-desc": ["root-volume", "ephemeral-volume"],
1583 "virtual-storage-desc": [
1584 {"id": "root-volume", "size-of-storage": "10"},
1586 "id": "ephemeral-volume",
1587 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1588 "size-of-storage": "1",
1594 "path": "/app/storage/",
1622 "memory-mb": "1024",
1630 "ns-flavor-id": "test_id",
1631 "virtual-storages": [
1633 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1634 "size-of-storage": "10",
1639 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1644 target_record_id
= ""
1646 epa_params
.return_value
= {}
1648 result
= Ns
._process
_flavor
_params
(
1649 target_flavor
=target_flavor
,
1652 target_record_id
=target_record_id
,
1656 self
.assertTrue(epa_params
.called
)
1657 self
.assertDictEqual(result
, expected_result
)
1659 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1660 def test__process_flavor_params_with_swap_disk(
1688 "memory-mb": "1024",
1696 "ns-flavor-id": "test_id",
1697 "virtual-storages": [
1699 "type-of-storage": "etsi-nfv-descriptors:swap-storage",
1700 "size-of-storage": "20",
1705 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1710 target_record_id
= ""
1712 epa_params
.return_value
= {}
1714 result
= Ns
._process
_flavor
_params
(
1715 target_flavor
=target_flavor
,
1718 target_record_id
=target_record_id
,
1721 self
.assertTrue(epa_params
.called
)
1722 self
.assertDictEqual(result
, expected_result
)
1724 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1725 def test__process_flavor_params_with_persistent_root_disk(
1729 db
= MagicMock(name
="database mock")
1735 db
.get_one
.return_value
= {
1736 "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1741 {"id": "several_volumes-VM", "min-number-of-instances": 1}
1745 "id": "several_volumes-vnf",
1746 "product-name": "several_volumes-vnf",
1749 "id": "several_volumes-VM",
1750 "name": "several_volumes-VM",
1751 "sw-image-desc": "ubuntu20.04",
1752 "alternative-sw-image-desc": [
1754 "ubuntu20.04-azure",
1756 "virtual-storage-desc": [
1757 "persistent-root-volume",
1762 "virtual-storage-desc": [
1764 "id": "persistent-root-volume",
1765 "type-of-storage": "persistent-storage:persistent-storage",
1766 "size-of-storage": "10",
1772 "path": "/app/storage/",
1798 "memory-mb": "1024",
1806 "vdu-name": "several_volumes-VM",
1807 "ns-flavor-id": "test_id",
1808 "virtual-storages": [
1810 "type-of-storage": "persistent-storage:persistent-storage",
1811 "size-of-storage": "10",
1816 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1821 target_record_id
= ""
1823 epa_params
.return_value
= {}
1825 result
= Ns
._process
_flavor
_params
(
1826 target_flavor
=target_flavor
,
1829 target_record_id
=target_record_id
,
1833 self
.assertTrue(epa_params
.called
)
1834 self
.assertDictEqual(result
, expected_result
)
1836 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1837 def test__process_flavor_params_with_epa_params(
1849 "numa": "there-is-numa-here",
1860 "numa": "there-is-numa-here",
1869 "memory-mb": "1024",
1877 "ns-flavor-id": "test_id",
1880 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1885 target_record_id
= ""
1887 epa_params
.return_value
= {
1888 "numa": "there-is-numa-here",
1891 result
= Ns
._process
_flavor
_params
(
1892 target_flavor
=target_flavor
,
1895 target_record_id
=target_record_id
,
1898 self
.assertTrue(epa_params
.called
)
1899 self
.assertDictEqual(result
, expected_result
)
1901 @patch("osm_ng_ro.ns.Ns._process_epa_params")
1902 def test__process_flavor_params(
1906 db
= MagicMock(name
="database mock")
1912 db
.get_one
.return_value
= {
1913 "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
1918 {"id": "without_volumes-VM", "min-number-of-instances": 1}
1922 "id": "without_volumes-vnf",
1923 "product-name": "without_volumes-vnf",
1926 "id": "without_volumes-VM",
1927 "name": "without_volumes-VM",
1928 "sw-image-desc": "ubuntu20.04",
1929 "alternative-sw-image-desc": [
1931 "ubuntu20.04-azure",
1933 "virtual-storage-desc": ["root-volume", "ephemeral-volume"],
1937 "virtual-storage-desc": [
1938 {"id": "root-volume", "size-of-storage": "10"},
1940 "id": "ephemeral-volume",
1941 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1942 "size-of-storage": "1",
1948 "path": "/app/storage/",
1963 "numa": "there-is-numa-here",
1976 "numa": "there-is-numa-here",
1985 "memory-mb": "1024",
1993 "ns-flavor-id": "test_id",
1994 "virtual-storages": [
1996 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1997 "size-of-storage": "10",
2000 "type-of-storage": "etsi-nfv-descriptors:swap-storage",
2001 "size-of-storage": "20",
2006 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2011 target_record_id
= ""
2013 epa_params
.return_value
= {
2014 "numa": "there-is-numa-here",
2017 result
= Ns
._process
_flavor
_params
(
2018 target_flavor
=target_flavor
,
2021 target_record_id
=target_record_id
,
2025 self
.assertTrue(epa_params
.called
)
2026 self
.assertDictEqual(result
, expected_result
)
2028 def test__ip_profile_to_ro_with_none(self
):
2031 result
= Ns
._ip
_profile
_to
_ro
(
2032 ip_profile
=ip_profile
,
2035 self
.assertIsNone(result
)
2037 def test__ip_profile_to_ro_with_empty_profile(self
):
2040 result
= Ns
._ip
_profile
_to
_ro
(
2041 ip_profile
=ip_profile
,
2044 self
.assertIsNone(result
)
2046 def test__ip_profile_to_ro_with_wrong_profile(self
):
2048 "no-profile": "here",
2051 "ip_version": "IPv4",
2052 "subnet_address": None,
2053 "gateway_address": None,
2054 "dhcp_enabled": False,
2055 "dhcp_start_address": None,
2059 result
= Ns
._ip
_profile
_to
_ro
(
2060 ip_profile
=ip_profile
,
2063 self
.assertDictEqual(expected_result
, result
)
2065 def test__ip_profile_to_ro_with_ipv4_profile(self
):
2067 "ip-version": "ipv4",
2068 "subnet-address": "192.168.0.0/24",
2069 "gateway-address": "192.168.0.254",
2072 "start-address": "192.168.0.10",
2077 "ip_version": "IPv4",
2078 "subnet_address": "192.168.0.0/24",
2079 "gateway_address": "192.168.0.254",
2080 "dhcp_enabled": True,
2081 "dhcp_start_address": "192.168.0.10",
2085 result
= Ns
._ip
_profile
_to
_ro
(
2086 ip_profile
=ip_profile
,
2089 self
.assertDictEqual(expected_result
, result
)
2091 def test__ip_profile_to_ro_with_ipv6_profile(self
):
2093 "ip-version": "ipv6",
2094 "subnet-address": "2001:0200:0001::/48",
2095 "gateway-address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe",
2098 "start-address": "2001:0200:0001::0010",
2103 "ip_version": "IPv6",
2104 "subnet_address": "2001:0200:0001::/48",
2105 "gateway_address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe",
2106 "dhcp_enabled": True,
2107 "dhcp_start_address": "2001:0200:0001::0010",
2111 result
= Ns
._ip
_profile
_to
_ro
(
2112 ip_profile
=ip_profile
,
2115 self
.assertDictEqual(expected_result
, result
)
2117 def test__ip_profile_to_ro_with_dns_server(self
):
2119 "ip-version": "ipv4",
2120 "subnet-address": "192.168.0.0/24",
2121 "gateway-address": "192.168.0.254",
2124 "start-address": "192.168.0.10",
2129 "address": "8.8.8.8",
2132 "address": "1.1.1.1",
2135 "address": "1.0.0.1",
2140 "ip_version": "IPv4",
2141 "subnet_address": "192.168.0.0/24",
2142 "gateway_address": "192.168.0.254",
2143 "dhcp_enabled": True,
2144 "dhcp_start_address": "192.168.0.10",
2146 "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
2149 result
= Ns
._ip
_profile
_to
_ro
(
2150 ip_profile
=ip_profile
,
2153 self
.assertDictEqual(expected_result
, result
)
2155 def test__ip_profile_to_ro_with_security_group(self
):
2157 "ip-version": "ipv4",
2158 "subnet-address": "192.168.0.0/24",
2159 "gateway-address": "192.168.0.254",
2162 "start-address": "192.168.0.10",
2166 "some-security-group": "here",
2170 "ip_version": "IPv4",
2171 "subnet_address": "192.168.0.0/24",
2172 "gateway_address": "192.168.0.254",
2173 "dhcp_enabled": True,
2174 "dhcp_start_address": "192.168.0.10",
2177 "some-security-group": "here",
2181 result
= Ns
._ip
_profile
_to
_ro
(
2182 ip_profile
=ip_profile
,
2185 self
.assertDictEqual(expected_result
, result
)
2187 def test__ip_profile_to_ro(self
):
2189 "ip-version": "ipv4",
2190 "subnet-address": "192.168.0.0/24",
2191 "gateway-address": "192.168.0.254",
2194 "start-address": "192.168.0.10",
2199 "address": "8.8.8.8",
2202 "address": "1.1.1.1",
2205 "address": "1.0.0.1",
2209 "some-security-group": "here",
2213 "ip_version": "IPv4",
2214 "subnet_address": "192.168.0.0/24",
2215 "gateway_address": "192.168.0.254",
2216 "dhcp_enabled": True,
2217 "dhcp_start_address": "192.168.0.10",
2219 "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
2221 "some-security-group": "here",
2225 result
= Ns
._ip
_profile
_to
_ro
(
2226 ip_profile
=ip_profile
,
2229 self
.assertDictEqual(expected_result
, result
)
2231 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2232 def test__process_net_params_with_empty_params(
2243 "provider_network": "some-profile-here",
2245 target_record_id
= ""
2248 "net_name": "ns-name-vld-name",
2249 "net_type": "bridge",
2251 "some_ip_profile": "here",
2253 "provider_network_profile": "some-profile-here",
2257 ip_profile_to_ro
.return_value
= {
2258 "some_ip_profile": "here",
2261 result
= Ns
._process
_net
_params
(
2262 target_vld
=target_vld
,
2265 target_record_id
=target_record_id
,
2268 self
.assertDictEqual(expected_result
, result
)
2269 self
.assertTrue(ip_profile_to_ro
.called
)
2271 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2272 def test__process_net_params_with_vim_info_sdn(
2284 "sdn-ports": ["some", "ports", "here"],
2285 "vlds": ["some", "vlds", "here"],
2288 target_record_id
= "vld.sdn.something"
2291 "sdn-ports": ["some", "ports", "here"],
2292 "vlds": ["some", "vlds", "here"],
2297 result
= Ns
._process
_net
_params
(
2298 target_vld
=target_vld
,
2301 target_record_id
=target_record_id
,
2304 self
.assertDictEqual(expected_result
, result
)
2305 self
.assertFalse(ip_profile_to_ro
.called
)
2307 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2308 def test__process_net_params_with_vim_info_sdn_target_vim(
2320 "sdn-ports": ["some", "ports", "here"],
2321 "vlds": ["some", "vlds", "here"],
2322 "target_vim": "some-vim",
2325 target_record_id
= "vld.sdn.something"
2327 "depends_on": ["some-vim vld.sdn"],
2329 "sdn-ports": ["some", "ports", "here"],
2330 "vlds": ["some", "vlds", "here"],
2331 "target_vim": "some-vim",
2336 result
= Ns
._process
_net
_params
(
2337 target_vld
=target_vld
,
2340 target_record_id
=target_record_id
,
2343 self
.assertDictEqual(expected_result
, result
)
2344 self
.assertFalse(ip_profile_to_ro
.called
)
2346 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2347 def test__process_net_params_with_vim_network_name(
2358 "vim_network_name": "some-network-name",
2360 target_record_id
= "vld.sdn.something"
2364 "name": "some-network-name",
2369 result
= Ns
._process
_net
_params
(
2370 target_vld
=target_vld
,
2373 target_record_id
=target_record_id
,
2376 self
.assertDictEqual(expected_result
, result
)
2377 self
.assertFalse(ip_profile_to_ro
.called
)
2379 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2380 def test__process_net_params_with_vim_network_id(
2391 "vim_network_id": "some-network-id",
2393 target_record_id
= "vld.sdn.something"
2397 "id": "some-network-id",
2402 result
= Ns
._process
_net
_params
(
2403 target_vld
=target_vld
,
2406 target_record_id
=target_record_id
,
2409 self
.assertDictEqual(expected_result
, result
)
2410 self
.assertFalse(ip_profile_to_ro
.called
)
2412 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2413 def test__process_net_params_with_mgmt_network(
2420 "mgmt-network": "some-mgmt-network",
2426 target_record_id
= "vld.sdn.something"
2434 result
= Ns
._process
_net
_params
(
2435 target_vld
=target_vld
,
2438 target_record_id
=target_record_id
,
2441 self
.assertDictEqual(expected_result
, result
)
2442 self
.assertFalse(ip_profile_to_ro
.called
)
2444 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2445 def test__process_net_params_with_underlay_eline(
2451 "underlay": "some-underlay-here",
2458 "provider_network": "some-profile-here",
2460 target_record_id
= ""
2464 "some_ip_profile": "here",
2466 "net_name": "ns-name-vld-name",
2468 "provider_network_profile": "some-profile-here",
2472 ip_profile_to_ro
.return_value
= {
2473 "some_ip_profile": "here",
2476 result
= Ns
._process
_net
_params
(
2477 target_vld
=target_vld
,
2480 target_record_id
=target_record_id
,
2483 self
.assertDictEqual(expected_result
, result
)
2484 self
.assertTrue(ip_profile_to_ro
.called
)
2486 @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2487 def test__process_net_params_with_underlay_elan(
2493 "underlay": "some-underlay-here",
2500 "provider_network": "some-profile-here",
2502 target_record_id
= ""
2506 "some_ip_profile": "here",
2508 "net_name": "ns-name-vld-name",
2510 "provider_network_profile": "some-profile-here",
2514 ip_profile_to_ro
.return_value
= {
2515 "some_ip_profile": "here",
2518 result
= Ns
._process
_net
_params
(
2519 target_vld
=target_vld
,
2522 target_record_id
=target_record_id
,
2525 self
.assertDictEqual(expected_result
, result
)
2526 self
.assertTrue(ip_profile_to_ro
.called
)
2528 def test__get_cloud_init_exception(self
):
2529 db_mock
= MagicMock(name
="database mock")
2534 with self
.assertRaises(NsException
):
2535 Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2537 def test__get_cloud_init_file_fs_exception(self
):
2538 db_mock
= MagicMock(name
="database mock")
2541 location
= "vnfr_id_123456:file:test_file"
2542 db_mock
.get_one
.return_value
= {
2545 "folder": "/home/osm",
2546 "pkg-dir": "vnfr_test_dir",
2551 with self
.assertRaises(NsException
):
2552 Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2554 def test__get_cloud_init_file(self
):
2555 db_mock
= MagicMock(name
="database mock")
2556 fs_mock
= MagicMock(name
="filesystem mock")
2557 file_mock
= MagicMock(name
="file mock")
2559 location
= "vnfr_id_123456:file:test_file"
2560 cloud_init_content
= "this is a cloud init file content"
2562 db_mock
.get_one
.return_value
= {
2565 "folder": "/home/osm",
2566 "pkg-dir": "vnfr_test_dir",
2570 fs_mock
.file_open
.return_value
= file_mock
2571 file_mock
.__enter
__.return_value
.read
.return_value
= cloud_init_content
2573 result
= Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2575 self
.assertEqual(cloud_init_content
, result
)
2577 def test__get_cloud_init_vdu(self
):
2578 db_mock
= MagicMock(name
="database mock")
2581 location
= "vnfr_id_123456:vdu:0"
2582 cloud_init_content
= "this is a cloud init file content"
2584 db_mock
.get_one
.return_value
= {
2587 "cloud-init": cloud_init_content
,
2592 result
= Ns
._get
_cloud
_init
(db
=db_mock
, fs
=fs_mock
, location
=location
)
2594 self
.assertEqual(cloud_init_content
, result
)
2596 @patch("jinja2.Environment.__init__")
2597 def test__parse_jinja2_undefined_error(self
, env_mock
: Mock
):
2598 cloud_init_content
= None
2602 env_mock
.side_effect
= UndefinedError("UndefinedError occurred.")
2604 with self
.assertRaises(NsException
):
2606 cloud_init_content
=cloud_init_content
, params
=params
, context
=context
2609 @patch("jinja2.Environment.__init__")
2610 def test__parse_jinja2_template_error(self
, env_mock
: Mock
):
2611 cloud_init_content
= None
2615 env_mock
.side_effect
= TemplateError("TemplateError occurred.")
2617 with self
.assertRaises(NsException
):
2619 cloud_init_content
=cloud_init_content
, params
=params
, context
=context
2622 @patch("jinja2.Environment.__init__")
2623 def test__parse_jinja2_template_not_found(self
, env_mock
: Mock
):
2624 cloud_init_content
= None
2628 env_mock
.side_effect
= TemplateNotFound("TemplateNotFound occurred.")
2630 with self
.assertRaises(NsException
):
2632 cloud_init_content
=cloud_init_content
, params
=params
, context
=context
2635 def test__parse_jinja2(self
):
2638 def test__process_vdu_params_empty_kargs(self
):
2641 def test__process_vdu_params_interface_ns_vld_id(self
):
2644 def test__process_vdu_params_interface_vnf_vld_id(self
):
2647 def test__process_vdu_params_interface_unknown(self
):
2650 def test__process_vdu_params_interface_port_security_enabled(self
):
2653 def test__process_vdu_params_interface_port_security_disable_strategy(self
):
2656 def test__process_vdu_params_interface_sriov(self
):
2659 def test__process_vdu_params_interface_pci_passthrough(self
):
2662 def test__process_vdu_params_interface_om_mgmt(self
):
2665 def test__process_vdu_params_interface_mgmt_interface(self
):
2668 def test__process_vdu_params_interface_mgmt_vnf(self
):
2671 def test__process_vdu_params_interface_bridge(self
):
2674 def test__process_vdu_params_interface_ip_address(self
):
2677 def test__process_vdu_params_interface_mac_address(self
):
2680 def test__process_vdu_params_vdu_cloud_init_missing(self
):
2683 def test__process_vdu_params_vdu_cloud_init_present(self
):
2686 def test__process_vdu_params_vdu_boot_data_drive(self
):
2689 def test__process_vdu_params_vdu_ssh_keys(self
):
2692 def test__process_vdu_params_vdu_ssh_access_required(self
):
2695 @patch("osm_ng_ro.ns.Ns._get_cloud_init")
2696 @patch("osm_ng_ro.ns.Ns._parse_jinja2")
2697 def test__process_vdu_params_vdu_persistent_root_volume(
2698 self
, get_cloud_init
, parse_jinja2
2700 db
= MagicMock(name
="database mock")
2703 "vdu2cloud_init": {},
2705 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2706 "member-vnf-index-ref": "vnf-several-volumes",
2709 get_cloud_init
.return_value
= {}
2710 parse_jinja2
.return_value
= {}
2711 db
.get_one
.return_value
= {
2712 "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2717 {"id": "several_volumes-VM", "min-number-of-instances": 1}
2721 "id": "several_volumes-vnf",
2722 "product-name": "several_volumes-vnf",
2725 "id": "several_volumes-VM",
2726 "name": "several_volumes-VM",
2727 "sw-image-desc": "ubuntu20.04",
2728 "alternative-sw-image-desc": [
2730 "ubuntu20.04-azure",
2732 "virtual-storage-desc": [
2733 "persistent-root-volume",
2734 "persistent-volume2",
2740 "virtual-storage-desc": [
2742 "id": "persistent-volume2",
2743 "type-of-storage": "persistent-storage:persistent-storage",
2744 "size-of-storage": "10",
2747 "id": "persistent-root-volume",
2748 "type-of-storage": "persistent-storage:persistent-storage",
2749 "size-of-storage": "10",
2752 "id": "ephemeral-volume",
2753 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2754 "size-of-storage": "1",
2760 "path": "/app/storage/",
2767 "_id": "09a0baa7-b7cb-4924-bd63-9f04a1c23960",
2768 "ns-flavor-id": "0",
2770 "vdu-name": "several_volumes-VM",
2774 "ns-vld-id": "mgmtnet",
2777 "virtual-storages": [
2779 "id": "persistent-volume2",
2780 "size-of-storage": "10",
2781 "type-of-storage": "persistent-storage:persistent-storage",
2784 "id": "persistent-root-volume",
2785 "size-of-storage": "10",
2786 "type-of-storage": "persistent-storage:persistent-storage",
2789 "id": "ephemeral-volume",
2790 "size-of-storage": "1",
2791 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2796 "name": "sample_name",
2798 expected_result
= [{"image_id": "ubuntu20.04", "size": "10"}, {"size": "10"}]
2799 result
= Ns
._process
_vdu
_params
(
2800 target_vdu
, indata
, vim_info
=None, target_record_id
=None, **kwargs
2803 expected_result
, result
["params"]["disk_list"], "Wrong Disk List"
2806 @patch("osm_ng_ro.ns.Ns._get_cloud_init")
2807 @patch("osm_ng_ro.ns.Ns._parse_jinja2")
2808 def test__process_vdu_params_vdu_without_persistent_storage(
2809 self
, get_cloud_init
, parse_jinja2
2811 db
= MagicMock(name
="database mock")
2814 "vdu2cloud_init": {},
2816 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2817 "member-vnf-index-ref": "vnf-several-volumes",
2820 get_cloud_init
.return_value
= {}
2821 parse_jinja2
.return_value
= {}
2822 db
.get_one
.return_value
= {
2823 "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2828 {"id": "without_volumes-VM", "min-number-of-instances": 1}
2832 "id": "without_volumes-vnf",
2833 "product-name": "without_volumes-vnf",
2836 "id": "without_volumes-VM",
2837 "name": "without_volumes-VM",
2838 "sw-image-desc": "ubuntu20.04",
2839 "alternative-sw-image-desc": [
2841 "ubuntu20.04-azure",
2843 "virtual-storage-desc": ["root-volume", "ephemeral-volume"],
2847 "virtual-storage-desc": [
2848 {"id": "root-volume", "size-of-storage": "10"},
2850 "id": "ephemeral-volume",
2851 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2852 "size-of-storage": "1",
2858 "path": "/app/storage/",
2865 "_id": "09a0baa7-b7cb-4924-bd63-9f04a1c23960",
2866 "ns-flavor-id": "0",
2868 "vdu-name": "without_volumes-VM",
2872 "ns-vld-id": "mgmtnet",
2875 "virtual-storages": [
2877 "id": "root-volume",
2878 "size-of-storage": "10",
2881 "id": "ephemeral-volume",
2882 "size-of-storage": "1",
2883 "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2888 "name": "sample_name",
2890 expected_result
= []
2891 result
= Ns
._process
_vdu
_params
(
2892 target_vdu
, indata
, vim_info
=None, target_record_id
=None, **kwargs
2895 expected_result
, result
["params"]["disk_list"], "Wrong Disk List"
2898 def test__process_vdu_params(self
):
2901 @patch("osm_ng_ro.ns.Ns._assign_vim")
2902 def test__rebuild_start_stop_task(self
, assign_vim
):
2905 actions
= ["start", "stop", "rebuild"]
2906 vdu_id
= "bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
2907 vnf_id
= "665b4165-ce24-4320-bf19-b9a45bade49f"
2909 action_id
= "bb937f49-3870-4169-b758-9732e1ff40f3"
2910 nsr_id
= "993166fe-723e-4680-ac4b-b1af2541ae31"
2912 target_vim
= "vim:f9f370ac-0d44-41a7-9000-457f2332bc35"
2913 t
= "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
2914 for action
in actions
:
2916 "target_id": "vim:f9f370ac-0d44-41a7-9000-457f2332bc35",
2917 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
2918 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
2919 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:0",
2920 "status": "SCHEDULED",
2923 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
2924 "target_record_id": t
,
2926 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2930 extra_dict
["params"] = {
2931 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2934 task
= self
.ns
.rebuild_start_stop_task(
2944 self
.assertEqual(task
.get("action_id"), action_id
)
2945 self
.assertEqual(task
.get("nsr_id"), nsr_id
)
2946 self
.assertEqual(task
.get("target_id"), target_vim
)
2947 self
.assertDictEqual(task
, expected_result
)
2949 @patch("osm_ng_ro.ns.Ns._assign_vim")
2950 def test_verticalscale_task(self
, assign_vim
):
2954 action_id
= "bb937f49-3870-4169-b758-9732e1ff40f3"
2955 nsr_id
= "993166fe-723e-4680-ac4b-b1af2541ae31"
2957 target_record_id
= (
2958 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
2959 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
2963 "target_id": "vim:f9f370ac-0d44-41a7-9000-457f2332bc35",
2964 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
2965 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
2966 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:1",
2967 "status": "SCHEDULED",
2969 "item": "verticalscale",
2970 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.1",
2971 "target_record_id": target_record_id
,
2973 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2974 "flavor_dict": "flavor_dict",
2978 "id": "bb9c43f9-10a2-4569-a8a8-957c3528b6d1",
2980 "vim:f9f370ac-0d44-41a7-9000-457f2332bc35": {"interfaces": []}
2983 vnf
= {"_id": "665b4165-ce24-4320-bf19-b9a45bade49f"}
2984 extra_dict
["params"] = {
2985 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2986 "flavor_dict": "flavor_dict",
2988 task
= self
.ns
.verticalscale_task(
2989 vdu
, vnf
, vdu_index
, action_id
, nsr_id
, task_index
, extra_dict
2992 self
.assertDictEqual(task
, expected_result
)
2994 @patch("osm_ng_ro.ns.Ns._assign_vim")
2995 def test_migrate_task(self
, assign_vim
):
2999 action_id
= "bb937f49-3870-4169-b758-9732e1ff40f3"
3000 nsr_id
= "993166fe-723e-4680-ac4b-b1af2541ae31"
3002 target_record_id
= (
3003 "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:"
3004 "vdur.bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
3008 "target_id": "vim:f9f370ac-0d44-41a7-9000-457f2332bc35",
3009 "action_id": "bb937f49-3870-4169-b758-9732e1ff40f3",
3010 "nsr_id": "993166fe-723e-4680-ac4b-b1af2541ae31",
3011 "task_id": "bb937f49-3870-4169-b758-9732e1ff40f3:1",
3012 "status": "SCHEDULED",
3015 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.1",
3016 "target_record_id": target_record_id
,
3018 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
3019 "migrate_host": "migrateToHost",
3023 "id": "bb9c43f9-10a2-4569-a8a8-957c3528b6d1",
3025 "vim:f9f370ac-0d44-41a7-9000-457f2332bc35": {"interfaces": []}
3028 vnf
= {"_id": "665b4165-ce24-4320-bf19-b9a45bade49f"}
3029 extra_dict
["params"] = {
3030 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
3031 "migrate_host": "migrateToHost",
3033 task
= self
.ns
.migrate_task(
3034 vdu
, vnf
, vdu_index
, action_id
, nsr_id
, task_index
, extra_dict
3037 self
.assertDictEqual(task
, expected_result
)