NG-RO/osm_ng_ro/tests/test_ns.py

   1 #######################################################################################
   2 # Copyright ETSI Contributors and Others.
   3 #
   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
   7 #
   8 #    http://www.apache.org/licenses/LICENSE-2.0
   9 #
  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
  13 # implied.
  14 # See the License for the specific language governing permissions and
  15 # limitations under the License.
  16 #######################################################################################
  17
  18 import unittest
  19 from unittest.mock import MagicMock, Mock, patch
  20
  21 from jinja2 import TemplateError, TemplateNotFound, UndefinedError
  22 from osm_ng_ro.ns import Ns, NsException
  23
  24
  25 __author__ = "Eduardo Sousa"
  26 __date__ = "$19-NOV-2021 00:00:00$"
  27
  28
  29 class TestNs(unittest.TestCase):
  30     def setUp(self):
  31         pass
  32
  33     def test__create_task_without_extra_dict(self):
  34         expected_result = {
  35             "target_id": "vim_openstack_1",
  36             "action_id": "123456",
  37             "nsr_id": "654321",
  38             "task_id": "123456:1",
  39             "status": "SCHEDULED",
  40             "action": "CREATE",
  41             "item": "test_item",
  42             "target_record": "test_target_record",
  43             "target_record_id": "test_target_record_id",
  44         }
  45         deployment_info = {
  46             "action_id": "123456",
  47             "nsr_id": "654321",
  48             "task_index": 1,
  49         }
  50
  51         task = Ns._create_task(
  52             deployment_info=deployment_info,
  53             target_id="vim_openstack_1",
  54             item="test_item",
  55             action="CREATE",
  56             target_record="test_target_record",
  57             target_record_id="test_target_record_id",
  58         )
  59
  60         self.assertEqual(deployment_info.get("task_index"), 2)
  61         self.assertDictEqual(task, expected_result)
  62
  63     def test__create_task(self):
  64         expected_result = {
  65             "target_id": "vim_openstack_1",
  66             "action_id": "123456",
  67             "nsr_id": "654321",
  68             "task_id": "123456:1",
  69             "status": "SCHEDULED",
  70             "action": "CREATE",
  71             "item": "test_item",
  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",
  78         }
  79         deployment_info = {
  80             "action_id": "123456",
  81             "nsr_id": "654321",
  82             "task_index": 1,
  83         }
  84
  85         task = Ns._create_task(
  86             deployment_info=deployment_info,
  87             target_id="vim_openstack_1",
  88             item="test_item",
  89             action="CREATE",
  90             target_record="test_target_record",
  91             target_record_id="test_target_record_id",
  92             extra_dict={
  93                 "params": "test_params",
  94                 "find_params": "test_find_params",
  95                 "depends_on": "test_depends_on",
  96             },
  97         )
  98
  99         self.assertEqual(deployment_info.get("task_index"), 2)
 100         self.assertDictEqual(task, expected_result)
 101
 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
 106         task = {
 107             "target_id": "vim_openstack_1",
 108             "action_id": "123456",
 109             "nsr_id": "654321",
 110             "task_id": "123456:1",
 111             "status": "SCHEDULED",
 112             "action": "CREATE",
 113             "item": "test_item",
 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",
 120         }
 121         expected_result = {
 122             "_id": "123456:1",
 123             "locked_by": None,
 124             "locked_at": 0.0,
 125             "target_id": "vim_openstack_1",
 126             "vim_info": {
 127                 "created": False,
 128                 "created_items": None,
 129                 "vim_id": None,
 130                 "vim_name": None,
 131                 "vim_status": None,
 132                 "vim_details": None,
 133                 "vim_message": None,
 134                 "refresh_at": None,
 135             },
 136             "modified_at": now,
 137             "created_at": now,
 138             "to_check_at": now,
 139             "tasks": [task],
 140         }
 141
 142         ro_task = Ns._create_ro_task(
 143             target_id="vim_openstack_1",
 144             task=task,
 145         )
 146
 147         self.assertDictEqual(ro_task, expected_result)
 148
 149     def test__process_image_params_with_empty_target_image(self):
 150         expected_result = {
 151             "find_params": {},
 152         }
 153         target_image = {}
 154
 155         result = Ns._process_image_params(
 156             target_image=target_image,
 157             indata=None,
 158             vim_info=None,
 159             target_record_id=None,
 160         )
 161
 162         self.assertDictEqual(expected_result, result)
 163
 164     def test__process_image_params_with_wrong_target_image(self):
 165         expected_result = {
 166             "find_params": {},
 167         }
 168         target_image = {
 169             "no_image": "to_see_here",
 170         }
 171
 172         result = Ns._process_image_params(
 173             target_image=target_image,
 174             indata=None,
 175             vim_info=None,
 176             target_record_id=None,
 177         )
 178
 179         self.assertDictEqual(expected_result, result)
 180
 181     def test__process_image_params_with_image(self):
 182         expected_result = {
 183             "find_params": {
 184                 "filter_dict": {
 185                     "name": "cirros",
 186                 },
 187             },
 188         }
 189         target_image = {
 190             "image": "cirros",
 191         }
 192
 193         result = Ns._process_image_params(
 194             target_image=target_image,
 195             indata=None,
 196             vim_info=None,
 197             target_record_id=None,
 198         )
 199
 200         self.assertDictEqual(expected_result, result)
 201
 202     def test__process_image_params_with_vim_image_id(self):
 203         expected_result = {
 204             "find_params": {
 205                 "filter_dict": {
 206                     "id": "123456",
 207                 },
 208             },
 209         }
 210         target_image = {
 211             "vim_image_id": "123456",
 212         }
 213
 214         result = Ns._process_image_params(
 215             target_image=target_image,
 216             indata=None,
 217             vim_info=None,
 218             target_record_id=None,
 219         )
 220
 221         self.assertDictEqual(expected_result, result)
 222
 223     def test__process_image_params_with_image_checksum(self):
 224         expected_result = {
 225             "find_params": {
 226                 "filter_dict": {
 227                     "checksum": "e3fc50a88d0a364313df4b21ef20c29e",
 228                 },
 229             },
 230         }
 231         target_image = {
 232             "image_checksum": "e3fc50a88d0a364313df4b21ef20c29e",
 233         }
 234
 235         result = Ns._process_image_params(
 236             target_image=target_image,
 237             indata=None,
 238             vim_info=None,
 239             target_record_id=None,
 240         )
 241
 242         self.assertDictEqual(expected_result, result)
 243
 244     def test__get_resource_allocation_params_with_empty_target_image(self):
 245         expected_result = {}
 246         quota_descriptor = {}
 247
 248         result = Ns._get_resource_allocation_params(
 249             quota_descriptor=quota_descriptor,
 250         )
 251
 252         self.assertDictEqual(expected_result, result)
 253
 254     def test__get_resource_allocation_params_with_wrong_target_image(self):
 255         expected_result = {}
 256         quota_descriptor = {
 257             "no_quota": "present_here",
 258         }
 259
 260         result = Ns._get_resource_allocation_params(
 261             quota_descriptor=quota_descriptor,
 262         )
 263
 264         self.assertDictEqual(expected_result, result)
 265
 266     def test__get_resource_allocation_params_with_limit(self):
 267         expected_result = {
 268             "limit": 10,
 269         }
 270         quota_descriptor = {
 271             "limit": "10",
 272         }
 273
 274         result = Ns._get_resource_allocation_params(
 275             quota_descriptor=quota_descriptor,
 276         )
 277
 278         self.assertDictEqual(expected_result, result)
 279
 280     def test__get_resource_allocation_params_with_reserve(self):
 281         expected_result = {
 282             "reserve": 20,
 283         }
 284         quota_descriptor = {
 285             "reserve": "20",
 286         }
 287
 288         result = Ns._get_resource_allocation_params(
 289             quota_descriptor=quota_descriptor,
 290         )
 291
 292         self.assertDictEqual(expected_result, result)
 293
 294     def test__get_resource_allocation_params_with_shares(self):
 295         expected_result = {
 296             "shares": 30,
 297         }
 298         quota_descriptor = {
 299             "shares": "30",
 300         }
 301
 302         result = Ns._get_resource_allocation_params(
 303             quota_descriptor=quota_descriptor,
 304         )
 305
 306         self.assertDictEqual(expected_result, result)
 307
 308     def test__get_resource_allocation_params(self):
 309         expected_result = {
 310             "limit": 10,
 311             "reserve": 20,
 312             "shares": 30,
 313         }
 314         quota_descriptor = {
 315             "limit": "10",
 316             "reserve": "20",
 317             "shares": "30",
 318         }
 319
 320         result = Ns._get_resource_allocation_params(
 321             quota_descriptor=quota_descriptor,
 322         )
 323
 324         self.assertDictEqual(expected_result, result)
 325
 326     @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
 327     def test__process_guest_epa_quota_params_with_empty_quota_epa_cpu(
 328         self,
 329         resource_allocation,
 330     ):
 331         expected_result = {}
 332         guest_epa_quota = {}
 333         epa_vcpu_set = True
 334
 335         result = Ns._process_guest_epa_quota_params(
 336             guest_epa_quota=guest_epa_quota,
 337             epa_vcpu_set=epa_vcpu_set,
 338         )
 339
 340         self.assertDictEqual(expected_result, result)
 341         self.assertFalse(resource_allocation.called)
 342
 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(
 345         self,
 346         resource_allocation,
 347     ):
 348         expected_result = {}
 349         guest_epa_quota = {}
 350         epa_vcpu_set = False
 351
 352         result = Ns._process_guest_epa_quota_params(
 353             guest_epa_quota=guest_epa_quota,
 354             epa_vcpu_set=epa_vcpu_set,
 355         )
 356
 357         self.assertDictEqual(expected_result, result)
 358         self.assertFalse(resource_allocation.called)
 359
 360     @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
 361     def test__process_guest_epa_quota_params_with_wrong_quota_epa_cpu(
 362         self,
 363         resource_allocation,
 364     ):
 365         expected_result = {}
 366         guest_epa_quota = {
 367             "no-quota": "nothing",
 368         }
 369         epa_vcpu_set = True
 370
 371         result = Ns._process_guest_epa_quota_params(
 372             guest_epa_quota=guest_epa_quota,
 373             epa_vcpu_set=epa_vcpu_set,
 374         )
 375
 376         self.assertDictEqual(expected_result, result)
 377         self.assertFalse(resource_allocation.called)
 378
 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(
 381         self,
 382         resource_allocation,
 383     ):
 384         expected_result = {}
 385         guest_epa_quota = {
 386             "no-quota": "nothing",
 387         }
 388         epa_vcpu_set = False
 389
 390         result = Ns._process_guest_epa_quota_params(
 391             guest_epa_quota=guest_epa_quota,
 392             epa_vcpu_set=epa_vcpu_set,
 393         )
 394
 395         self.assertDictEqual(expected_result, result)
 396         self.assertFalse(resource_allocation.called)
 397
 398     @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
 399     def test__process_guest_epa_quota_params_with_cpu_quota_epa_cpu(
 400         self,
 401         resource_allocation,
 402     ):
 403         expected_result = {}
 404         guest_epa_quota = {
 405             "cpu-quota": {
 406                 "limit": "10",
 407                 "reserve": "20",
 408                 "shares": "30",
 409             },
 410         }
 411         epa_vcpu_set = True
 412
 413         result = Ns._process_guest_epa_quota_params(
 414             guest_epa_quota=guest_epa_quota,
 415             epa_vcpu_set=epa_vcpu_set,
 416         )
 417
 418         self.assertDictEqual(expected_result, result)
 419         self.assertFalse(resource_allocation.called)
 420
 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(
 423         self,
 424         resource_allocation,
 425     ):
 426         expected_result = {
 427             "cpu-quota": {
 428                 "limit": 10,
 429                 "reserve": 20,
 430                 "shares": 30,
 431             },
 432         }
 433         guest_epa_quota = {
 434             "cpu-quota": {
 435                 "limit": "10",
 436                 "reserve": "20",
 437                 "shares": "30",
 438             },
 439         }
 440         epa_vcpu_set = False
 441
 442         resource_allocation_param = {
 443             "limit": "10",
 444             "reserve": "20",
 445             "shares": "30",
 446         }
 447         resource_allocation.return_value = {
 448             "limit": 10,
 449             "reserve": 20,
 450             "shares": 30,
 451         }
 452
 453         result = Ns._process_guest_epa_quota_params(
 454             guest_epa_quota=guest_epa_quota,
 455             epa_vcpu_set=epa_vcpu_set,
 456         )
 457
 458         resource_allocation.assert_called_once_with(resource_allocation_param)
 459         self.assertDictEqual(expected_result, result)
 460
 461     @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
 462     def test__process_guest_epa_quota_params_with_mem_quota_epa_cpu(
 463         self,
 464         resource_allocation,
 465     ):
 466         expected_result = {
 467             "mem-quota": {
 468                 "limit": 10,
 469                 "reserve": 20,
 470                 "shares": 30,
 471             },
 472         }
 473         guest_epa_quota = {
 474             "mem-quota": {
 475                 "limit": "10",
 476                 "reserve": "20",
 477                 "shares": "30",
 478             },
 479         }
 480         epa_vcpu_set = True
 481
 482         resource_allocation_param = {
 483             "limit": "10",
 484             "reserve": "20",
 485             "shares": "30",
 486         }
 487         resource_allocation.return_value = {
 488             "limit": 10,
 489             "reserve": 20,
 490             "shares": 30,
 491         }
 492
 493         result = Ns._process_guest_epa_quota_params(
 494             guest_epa_quota=guest_epa_quota,
 495             epa_vcpu_set=epa_vcpu_set,
 496         )
 497
 498         resource_allocation.assert_called_once_with(resource_allocation_param)
 499         self.assertDictEqual(expected_result, result)
 500
 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(
 503         self,
 504         resource_allocation,
 505     ):
 506         expected_result = {
 507             "mem-quota": {
 508                 "limit": 10,
 509                 "reserve": 20,
 510                 "shares": 30,
 511             },
 512         }
 513         guest_epa_quota = {
 514             "mem-quota": {
 515                 "limit": "10",
 516                 "reserve": "20",
 517                 "shares": "30",
 518             },
 519         }
 520         epa_vcpu_set = False
 521
 522         resource_allocation_param = {
 523             "limit": "10",
 524             "reserve": "20",
 525             "shares": "30",
 526         }
 527         resource_allocation.return_value = {
 528             "limit": 10,
 529             "reserve": 20,
 530             "shares": 30,
 531         }
 532
 533         result = Ns._process_guest_epa_quota_params(
 534             guest_epa_quota=guest_epa_quota,
 535             epa_vcpu_set=epa_vcpu_set,
 536         )
 537
 538         resource_allocation.assert_called_once_with(resource_allocation_param)
 539         self.assertDictEqual(expected_result, result)
 540
 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(
 543         self,
 544         resource_allocation,
 545     ):
 546         expected_result = {
 547             "disk-io-quota": {
 548                 "limit": 10,
 549                 "reserve": 20,
 550                 "shares": 30,
 551             },
 552         }
 553         guest_epa_quota = {
 554             "disk-io-quota": {
 555                 "limit": "10",
 556                 "reserve": "20",
 557                 "shares": "30",
 558             },
 559         }
 560         epa_vcpu_set = True
 561
 562         resource_allocation_param = {
 563             "limit": "10",
 564             "reserve": "20",
 565             "shares": "30",
 566         }
 567         resource_allocation.return_value = {
 568             "limit": 10,
 569             "reserve": 20,
 570             "shares": 30,
 571         }
 572
 573         result = Ns._process_guest_epa_quota_params(
 574             guest_epa_quota=guest_epa_quota,
 575             epa_vcpu_set=epa_vcpu_set,
 576         )
 577
 578         resource_allocation.assert_called_once_with(resource_allocation_param)
 579         self.assertDictEqual(expected_result, result)
 580
 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(
 583         self,
 584         resource_allocation,
 585     ):
 586         expected_result = {
 587             "disk-io-quota": {
 588                 "limit": 10,
 589                 "reserve": 20,
 590                 "shares": 30,
 591             },
 592         }
 593         guest_epa_quota = {
 594             "disk-io-quota": {
 595                 "limit": "10",
 596                 "reserve": "20",
 597                 "shares": "30",
 598             },
 599         }
 600         epa_vcpu_set = False
 601
 602         resource_allocation_param = {
 603             "limit": "10",
 604             "reserve": "20",
 605             "shares": "30",
 606         }
 607         resource_allocation.return_value = {
 608             "limit": 10,
 609             "reserve": 20,
 610             "shares": 30,
 611         }
 612
 613         result = Ns._process_guest_epa_quota_params(
 614             guest_epa_quota=guest_epa_quota,
 615             epa_vcpu_set=epa_vcpu_set,
 616         )
 617
 618         resource_allocation.assert_called_once_with(resource_allocation_param)
 619         self.assertDictEqual(expected_result, result)
 620
 621     @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
 622     def test__process_guest_epa_quota_params_with_vif_quota_epa_cpu(
 623         self,
 624         resource_allocation,
 625     ):
 626         expected_result = {
 627             "vif-quota": {
 628                 "limit": 10,
 629                 "reserve": 20,
 630                 "shares": 30,
 631             },
 632         }
 633         guest_epa_quota = {
 634             "vif-quota": {
 635                 "limit": "10",
 636                 "reserve": "20",
 637                 "shares": "30",
 638             },
 639         }
 640         epa_vcpu_set = True
 641
 642         resource_allocation_param = {
 643             "limit": "10",
 644             "reserve": "20",
 645             "shares": "30",
 646         }
 647         resource_allocation.return_value = {
 648             "limit": 10,
 649             "reserve": 20,
 650             "shares": 30,
 651         }
 652
 653         result = Ns._process_guest_epa_quota_params(
 654             guest_epa_quota=guest_epa_quota,
 655             epa_vcpu_set=epa_vcpu_set,
 656         )
 657
 658         resource_allocation.assert_called_once_with(resource_allocation_param)
 659         self.assertDictEqual(expected_result, result)
 660
 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(
 663         self,
 664         resource_allocation,
 665     ):
 666         expected_result = {
 667             "vif-quota": {
 668                 "limit": 10,
 669                 "reserve": 20,
 670                 "shares": 30,
 671             },
 672         }
 673         guest_epa_quota = {
 674             "vif-quota": {
 675                 "limit": "10",
 676                 "reserve": "20",
 677                 "shares": "30",
 678             },
 679         }
 680         epa_vcpu_set = False
 681
 682         resource_allocation_param = {
 683             "limit": "10",
 684             "reserve": "20",
 685             "shares": "30",
 686         }
 687         resource_allocation.return_value = {
 688             "limit": 10,
 689             "reserve": 20,
 690             "shares": 30,
 691         }
 692
 693         result = Ns._process_guest_epa_quota_params(
 694             guest_epa_quota=guest_epa_quota,
 695             epa_vcpu_set=epa_vcpu_set,
 696         )
 697
 698         resource_allocation.assert_called_once_with(resource_allocation_param)
 699         self.assertDictEqual(expected_result, result)
 700
 701     @patch("osm_ng_ro.ns.Ns._get_resource_allocation_params")
 702     def test__process_guest_epa_quota_params_with_quota_epa_cpu(
 703         self,
 704         resource_allocation,
 705     ):
 706         expected_result = {
 707             "mem-quota": {
 708                 "limit": 10,
 709                 "reserve": 20,
 710                 "shares": 30,
 711             },
 712             "disk-io-quota": {
 713                 "limit": 10,
 714                 "reserve": 20,
 715                 "shares": 30,
 716             },
 717             "vif-quota": {
 718                 "limit": 10,
 719                 "reserve": 20,
 720                 "shares": 30,
 721             },
 722         }
 723         guest_epa_quota = {
 724             "cpu-quota": {
 725                 "limit": "10",
 726                 "reserve": "20",
 727                 "shares": "30",
 728             },
 729             "mem-quota": {
 730                 "limit": "10",
 731                 "reserve": "20",
 732                 "shares": "30",
 733             },
 734             "disk-io-quota": {
 735                 "limit": "10",
 736                 "reserve": "20",
 737                 "shares": "30",
 738             },
 739             "vif-quota": {
 740                 "limit": "10",
 741                 "reserve": "20",
 742                 "shares": "30",
 743             },
 744         }
 745         epa_vcpu_set = True
 746
 747         resource_allocation.return_value = {
 748             "limit": 10,
 749             "reserve": 20,
 750             "shares": 30,
 751         }
 752
 753         result = Ns._process_guest_epa_quota_params(
 754             guest_epa_quota=guest_epa_quota,
 755             epa_vcpu_set=epa_vcpu_set,
 756         )
 757
 758         self.assertTrue(resource_allocation.called)
 759         self.assertDictEqual(expected_result, result)
 760
 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(
 763         self,
 764         resource_allocation,
 765     ):
 766         expected_result = {
 767             "cpu-quota": {
 768                 "limit": 10,
 769                 "reserve": 20,
 770                 "shares": 30,
 771             },
 772             "mem-quota": {
 773                 "limit": 10,
 774                 "reserve": 20,
 775                 "shares": 30,
 776             },
 777             "disk-io-quota": {
 778                 "limit": 10,
 779                 "reserve": 20,
 780                 "shares": 30,
 781             },
 782             "vif-quota": {
 783                 "limit": 10,
 784                 "reserve": 20,
 785                 "shares": 30,
 786             },
 787         }
 788         guest_epa_quota = {
 789             "cpu-quota": {
 790                 "limit": "10",
 791                 "reserve": "20",
 792                 "shares": "30",
 793             },
 794             "mem-quota": {
 795                 "limit": "10",
 796                 "reserve": "20",
 797                 "shares": "30",
 798             },
 799             "disk-io-quota": {
 800                 "limit": "10",
 801                 "reserve": "20",
 802                 "shares": "30",
 803             },
 804             "vif-quota": {
 805                 "limit": "10",
 806                 "reserve": "20",
 807                 "shares": "30",
 808             },
 809         }
 810         epa_vcpu_set = False
 811
 812         resource_allocation.return_value = {
 813             "limit": 10,
 814             "reserve": 20,
 815             "shares": 30,
 816         }
 817
 818         result = Ns._process_guest_epa_quota_params(
 819             guest_epa_quota=guest_epa_quota,
 820             epa_vcpu_set=epa_vcpu_set,
 821         )
 822
 823         self.assertTrue(resource_allocation.called)
 824         self.assertDictEqual(expected_result, result)
 825
 826     def test__process_guest_epa_numa_params_with_empty_numa_params(self):
 827         expected_numa_result = {}
 828         expected_epa_vcpu_set_result = False
 829         guest_epa_quota = {}
 830
 831         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 832             guest_epa_quota=guest_epa_quota,
 833         )
 834
 835         self.assertDictEqual(expected_numa_result, numa_result)
 836         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 837
 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"}
 842
 843         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 844             guest_epa_quota=guest_epa_quota,
 845         )
 846
 847         self.assertDictEqual(expected_numa_result, numa_result)
 848         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 849
 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": {}}
 854
 855         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 856             guest_epa_quota=guest_epa_quota,
 857         )
 858
 859         self.assertDictEqual(expected_numa_result, numa_result)
 860         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 861
 862     def test__process_guest_epa_numa_params_with_no_node(self):
 863         expected_numa_result = {}
 864         expected_epa_vcpu_set_result = False
 865         guest_epa_quota = {
 866             "numa-node-policy": {
 867                 "node": [],
 868             },
 869         }
 870
 871         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 872             guest_epa_quota=guest_epa_quota,
 873         )
 874
 875         self.assertDictEqual(expected_numa_result, numa_result)
 876         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 877
 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
 881         guest_epa_quota = {
 882             "numa-node-policy": {
 883                 "node": [
 884                     {
 885                         "num-cores": 3,
 886                     },
 887                 ],
 888             },
 889         }
 890
 891         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 892             guest_epa_quota=guest_epa_quota,
 893         )
 894
 895         self.assertDictEqual(expected_numa_result, numa_result)
 896         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 897
 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
 901         guest_epa_quota = {
 902             "numa-node-policy": {
 903                 "node": [
 904                     {
 905                         "paired-threads": {"num-paired-threads": "3"},
 906                     },
 907                 ],
 908             },
 909         }
 910
 911         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 912             guest_epa_quota=guest_epa_quota,
 913         )
 914
 915         self.assertDictEqual(expected_numa_result, numa_result)
 916         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 917
 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")],
 921         }
 922         expected_epa_vcpu_set_result = False
 923         guest_epa_quota = {
 924             "numa-node-policy": {
 925                 "node": [
 926                     {
 927                         "paired-threads": {
 928                             "paired-thread-ids": [
 929                                 {
 930                                     "thread-a": 0,
 931                                     "thread-b": 1,
 932                                 },
 933                                 {
 934                                     "thread-a": 4,
 935                                     "thread-b": 5,
 936                                 },
 937                             ],
 938                         },
 939                     },
 940                 ],
 941             },
 942         }
 943
 944         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 945             guest_epa_quota=guest_epa_quota,
 946         )
 947
 948         self.assertDictEqual(expected_numa_result, numa_result)
 949         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 950
 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
 954         guest_epa_quota = {
 955             "numa-node-policy": {
 956                 "node": [
 957                     {
 958                         "num-threads": "3",
 959                     },
 960                 ],
 961             },
 962         }
 963
 964         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 965             guest_epa_quota=guest_epa_quota,
 966         )
 967
 968         self.assertDictEqual(expected_numa_result, numa_result)
 969         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 970
 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
 974         guest_epa_quota = {
 975             "numa-node-policy": {
 976                 "node": [
 977                     {
 978                         "memory-mb": 2048,
 979                     },
 980                 ],
 981             },
 982         }
 983
 984         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
 985             guest_epa_quota=guest_epa_quota,
 986         )
 987
 988         self.assertDictEqual(expected_numa_result, numa_result)
 989         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
 990
 991     def test__process_guest_epa_numa_params_with_1_node(self):
 992         expected_numa_result = {
 993             "cores": 3,
 994             "paired-threads": 3,
 995             "paired-threads-id": [("0", "1"), ("4", "5")],
 996             "threads": 3,
 997             "memory": 2,
 998         }
 999         expected_epa_vcpu_set_result = True
1000         guest_epa_quota = {
1001             "numa-node-policy": {
1002                 "node": [
1003                     {
1004                         "num-cores": 3,
1005                         "paired-threads": {
1006                             "num-paired-threads": "3",
1007                             "paired-thread-ids": [
1008                                 {
1009                                     "thread-a": 0,
1010                                     "thread-b": 1,
1011                                 },
1012                                 {
1013                                     "thread-a": 4,
1014                                     "thread-b": 5,
1015                                 },
1016                             ],
1017                         },
1018                         "num-threads": "3",
1019                         "memory-mb": 2048,
1020                     },
1021                 ],
1022             },
1023         }
1024
1025         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
1026             guest_epa_quota=guest_epa_quota,
1027         )
1028
1029         self.assertDictEqual(expected_numa_result, numa_result)
1030         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
1031
1032     def test__process_guest_epa_numa_params_with_2_nodes(self):
1033         expected_numa_result = {
1034             "cores": 3,
1035             "paired-threads": 3,
1036             "paired-threads-id": [("0", "1"), ("4", "5")],
1037             "threads": 3,
1038             "memory": 2,
1039         }
1040         expected_epa_vcpu_set_result = True
1041         guest_epa_quota = {
1042             "numa-node-policy": {
1043                 "node": [
1044                     {
1045                         "num-cores": 3,
1046                         "paired-threads": {
1047                             "num-paired-threads": "3",
1048                             "paired-thread-ids": [
1049                                 {
1050                                     "thread-a": 0,
1051                                     "thread-b": 1,
1052                                 },
1053                                 {
1054                                     "thread-a": 4,
1055                                     "thread-b": 5,
1056                                 },
1057                             ],
1058                         },
1059                         "num-threads": "3",
1060                         "memory-mb": 2048,
1061                     },
1062                     {
1063                         "num-cores": 7,
1064                         "paired-threads": {
1065                             "num-paired-threads": "7",
1066                             "paired-thread-ids": [
1067                                 {
1068                                     "thread-a": 2,
1069                                     "thread-b": 3,
1070                                 },
1071                                 {
1072                                     "thread-a": 5,
1073                                     "thread-b": 6,
1074                                 },
1075                             ],
1076                         },
1077                         "num-threads": "4",
1078                         "memory-mb": 4096,
1079                     },
1080                 ],
1081             },
1082         }
1083
1084         numa_result, epa_vcpu_set_result = Ns._process_guest_epa_numa_params(
1085             guest_epa_quota=guest_epa_quota,
1086         )
1087
1088         self.assertDictEqual(expected_numa_result, numa_result)
1089         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
1090
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 = {}
1095         vcpu_count = 0
1096         epa_vcpu_set = False
1097
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,
1102         )
1103
1104         self.assertDictEqual(expected_numa_result, numa_result)
1105         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
1106
1107     def test__process_guest_epa_cpu_pinning_params_with_wrong_params(self):
1108         expected_numa_result = {}
1109         expected_epa_vcpu_set_result = False
1110         guest_epa_quota = {
1111             "no-cpu-pinning-policy": "here",
1112         }
1113         vcpu_count = 0
1114         epa_vcpu_set = False
1115
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,
1120         )
1121
1122         self.assertDictEqual(expected_numa_result, numa_result)
1123         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
1124
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
1128         guest_epa_quota = {
1129             "cpu-pinning-policy": "DEDICATED",
1130         }
1131         vcpu_count = 0
1132         epa_vcpu_set = True
1133
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,
1138         )
1139
1140         self.assertDictEqual(expected_numa_result, numa_result)
1141         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
1142
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
1146         guest_epa_quota = {
1147             "cpu-pinning-policy": "DEDICATED",
1148             "cpu-thread-pinning-policy": "PREFER",
1149         }
1150         vcpu_count = 3
1151         epa_vcpu_set = False
1152
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,
1157         )
1158
1159         self.assertDictEqual(expected_numa_result, numa_result)
1160         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
1161
1162     def test__process_guest_epa_cpu_pinning_params(self):
1163         expected_numa_result = {"cores": 3}
1164         expected_epa_vcpu_set_result = True
1165         guest_epa_quota = {
1166             "cpu-pinning-policy": "DEDICATED",
1167         }
1168         vcpu_count = 3
1169         epa_vcpu_set = False
1170
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,
1175         )
1176
1177         self.assertDictEqual(expected_numa_result, numa_result)
1178         self.assertEqual(expected_epa_vcpu_set_result, epa_vcpu_set_result)
1179
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(
1184         self,
1185         guest_epa_numa_params,
1186         guest_epa_cpu_pinning_params,
1187         guest_epa_quota_params,
1188     ):
1189         expected_result = {}
1190         target_flavor = {}
1191
1192         result = Ns._process_epa_params(
1193             target_flavor=target_flavor,
1194         )
1195
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)
1200
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(
1205         self,
1206         guest_epa_numa_params,
1207         guest_epa_cpu_pinning_params,
1208         guest_epa_quota_params,
1209     ):
1210         expected_result = {}
1211         target_flavor = {
1212             "no-guest-epa": "here",
1213         }
1214
1215         result = Ns._process_epa_params(
1216             target_flavor=target_flavor,
1217         )
1218
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)
1223
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(
1228         self,
1229         guest_epa_numa_params,
1230         guest_epa_cpu_pinning_params,
1231         guest_epa_quota_params,
1232     ):
1233         expected_result = {}
1234         target_flavor = {
1235             "guest-epa": {
1236                 "vcpu-count": 1,
1237             },
1238         }
1239
1240         guest_epa_numa_params.return_value = ({}, False)
1241         guest_epa_cpu_pinning_params.return_value = ({}, False)
1242         guest_epa_quota_params.return_value = {}
1243
1244         result = Ns._process_epa_params(
1245             target_flavor=target_flavor,
1246         )
1247
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)
1252
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(
1257         self,
1258         guest_epa_numa_params,
1259         guest_epa_cpu_pinning_params,
1260         guest_epa_quota_params,
1261     ):
1262         expected_result = {
1263             "mempage-size": "1G",
1264         }
1265         target_flavor = {
1266             "guest-epa": {"vcpu-count": 1, "mempage-size": "1G"},
1267         }
1268
1269         guest_epa_numa_params.return_value = ({}, False)
1270         guest_epa_cpu_pinning_params.return_value = ({}, False)
1271         guest_epa_quota_params.return_value = {}
1272
1273         result = Ns._process_epa_params(
1274             target_flavor=target_flavor,
1275         )
1276
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)
1281
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(
1286         self,
1287         guest_epa_numa_params,
1288         guest_epa_cpu_pinning_params,
1289         guest_epa_quota_params,
1290     ):
1291         expected_result = {
1292             "mempage-size": "1G",
1293             "numas": [
1294                 {
1295                     "cores": 3,
1296                     "memory": 2,
1297                     "paired-threads": 3,
1298                     "paired-threads-id": [("0", "1"), ("4", "5")],
1299                     "threads": 3,
1300                 }
1301             ],
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},
1306         }
1307         target_flavor = {
1308             "guest-epa": {
1309                 "vcpu-count": 1,
1310                 "mempage-size": "1G",
1311                 "cpu-pinning-policy": "DEDICATED",
1312                 "cpu-thread-pinning-policy": "PREFER",
1313                 "numa-node-policy": {
1314                     "node": [
1315                         {
1316                             "num-cores": 3,
1317                             "paired-threads": {
1318                                 "num-paired-threads": "3",
1319                                 "paired-thread-ids": [
1320                                     {
1321                                         "thread-a": 0,
1322                                         "thread-b": 1,
1323                                     },
1324                                     {
1325                                         "thread-a": 4,
1326                                         "thread-b": 5,
1327                                     },
1328                                 ],
1329                             },
1330                             "num-threads": "3",
1331                             "memory-mb": 2048,
1332                         },
1333                     ],
1334                 },
1335                 "cpu-quota": {
1336                     "limit": "10",
1337                     "reserve": "20",
1338                     "shares": "30",
1339                 },
1340                 "mem-quota": {
1341                     "limit": "10",
1342                     "reserve": "20",
1343                     "shares": "30",
1344                 },
1345                 "disk-io-quota": {
1346                     "limit": "10",
1347                     "reserve": "20",
1348                     "shares": "30",
1349                 },
1350                 "vif-quota": {
1351                     "limit": "10",
1352                     "reserve": "20",
1353                     "shares": "30",
1354                 },
1355             },
1356         }
1357
1358         guest_epa_numa_params.return_value = (
1359             {
1360                 "cores": 3,
1361                 "paired-threads": 3,
1362                 "paired-threads-id": [("0", "1"), ("4", "5")],
1363                 "threads": 3,
1364                 "memory": 2,
1365             },
1366             True,
1367         )
1368         guest_epa_cpu_pinning_params.return_value = (
1369             {
1370                 "threads": 3,
1371             },
1372             True,
1373         )
1374         guest_epa_quota_params.return_value = {
1375             "cpu-quota": {
1376                 "limit": 10,
1377                 "reserve": 20,
1378                 "shares": 30,
1379             },
1380             "mem-quota": {
1381                 "limit": 10,
1382                 "reserve": 20,
1383                 "shares": 30,
1384             },
1385             "disk-io-quota": {
1386                 "limit": 10,
1387                 "reserve": 20,
1388                 "shares": 30,
1389             },
1390             "vif-quota": {
1391                 "limit": 10,
1392                 "reserve": 20,
1393                 "shares": 30,
1394             },
1395         }
1396
1397         result = Ns._process_epa_params(
1398             target_flavor=target_flavor,
1399         )
1400
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)
1405
1406     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1407     def test__process_flavor_params_with_empty_target_flavor(
1408         self,
1409         epa_params,
1410     ):
1411         target_flavor = {}
1412         indata = {}
1413         vim_info = {}
1414         target_record_id = ""
1415
1416         with self.assertRaises(KeyError):
1417             Ns._process_flavor_params(
1418                 target_flavor=target_flavor,
1419                 indata=indata,
1420                 vim_info=vim_info,
1421                 target_record_id=target_record_id,
1422             )
1423
1424         self.assertFalse(epa_params.called)
1425
1426     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1427     def test__process_flavor_params_with_wrong_target_flavor(
1428         self,
1429         epa_params,
1430     ):
1431         target_flavor = {
1432             "no-target-flavor": "here",
1433         }
1434         indata = {}
1435         vim_info = {}
1436         target_record_id = ""
1437
1438         with self.assertRaises(KeyError):
1439             Ns._process_flavor_params(
1440                 target_flavor=target_flavor,
1441                 indata=indata,
1442                 vim_info=vim_info,
1443                 target_record_id=target_record_id,
1444             )
1445
1446         self.assertFalse(epa_params.called)
1447
1448     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1449     def test__process_flavor_params_with_empty_indata(
1450         self,
1451         epa_params,
1452     ):
1453         expected_result = {
1454             "find_params": {
1455                 "flavor_data": {
1456                     "disk": 10,
1457                     "ram": 1024,
1458                     "vcpus": 2,
1459                 },
1460             },
1461             "params": {
1462                 "flavor_data": {
1463                     "disk": 10,
1464                     "name": "test",
1465                     "ram": 1024,
1466                     "vcpus": 2,
1467                 },
1468             },
1469         }
1470         target_flavor = {
1471             "name": "test",
1472             "storage-gb": "10",
1473             "memory-mb": "1024",
1474             "vcpu-count": "2",
1475         }
1476         indata = {}
1477         vim_info = {}
1478         target_record_id = ""
1479
1480         epa_params.return_value = {}
1481
1482         result = Ns._process_flavor_params(
1483             target_flavor=target_flavor,
1484             indata=indata,
1485             vim_info=vim_info,
1486             target_record_id=target_record_id,
1487         )
1488
1489         self.assertTrue(epa_params.called)
1490         self.assertDictEqual(result, expected_result)
1491
1492     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1493     def test__process_flavor_params_with_wrong_indata(
1494         self,
1495         epa_params,
1496     ):
1497         expected_result = {
1498             "find_params": {
1499                 "flavor_data": {
1500                     "disk": 10,
1501                     "ram": 1024,
1502                     "vcpus": 2,
1503                 },
1504             },
1505             "params": {
1506                 "flavor_data": {
1507                     "disk": 10,
1508                     "name": "test",
1509                     "ram": 1024,
1510                     "vcpus": 2,
1511                 },
1512             },
1513         }
1514         target_flavor = {
1515             "name": "test",
1516             "storage-gb": "10",
1517             "memory-mb": "1024",
1518             "vcpu-count": "2",
1519         }
1520         indata = {
1521             "no-vnf": "here",
1522         }
1523         vim_info = {}
1524         target_record_id = ""
1525
1526         epa_params.return_value = {}
1527
1528         result = Ns._process_flavor_params(
1529             target_flavor=target_flavor,
1530             indata=indata,
1531             vim_info=vim_info,
1532             target_record_id=target_record_id,
1533         )
1534
1535         self.assertTrue(epa_params.called)
1536         self.assertDictEqual(result, expected_result)
1537
1538     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1539     def test__process_flavor_params_with_ephemeral_disk(
1540         self,
1541         epa_params,
1542     ):
1543         expected_result = {
1544             "find_params": {
1545                 "flavor_data": {
1546                     "disk": 10,
1547                     "ram": 1024,
1548                     "vcpus": 2,
1549                     "ephemeral": 10,
1550                 },
1551             },
1552             "params": {
1553                 "flavor_data": {
1554                     "disk": 10,
1555                     "name": "test",
1556                     "ram": 1024,
1557                     "vcpus": 2,
1558                     "ephemeral": 10,
1559                 },
1560             },
1561         }
1562         target_flavor = {
1563             "id": "test_id",
1564             "name": "test",
1565             "storage-gb": "10",
1566             "memory-mb": "1024",
1567             "vcpu-count": "2",
1568         }
1569         indata = {
1570             "vnf": [
1571                 {
1572                     "vdur": [
1573                         {
1574                             "ns-flavor-id": "test_id",
1575                             "virtual-storages": [
1576                                 {
1577                                     "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1578                                     "size-of-storage": "10",
1579                                 },
1580                             ],
1581                         },
1582                     ],
1583                 },
1584             ],
1585         }
1586         vim_info = {}
1587         target_record_id = ""
1588
1589         epa_params.return_value = {}
1590
1591         result = Ns._process_flavor_params(
1592             target_flavor=target_flavor,
1593             indata=indata,
1594             vim_info=vim_info,
1595             target_record_id=target_record_id,
1596         )
1597
1598         self.assertTrue(epa_params.called)
1599         self.assertDictEqual(result, expected_result)
1600
1601     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1602     def test__process_flavor_params_with_swap_disk(
1603         self,
1604         epa_params,
1605     ):
1606         expected_result = {
1607             "find_params": {
1608                 "flavor_data": {
1609                     "disk": 10,
1610                     "ram": 1024,
1611                     "vcpus": 2,
1612                     "swap": 20,
1613                 },
1614             },
1615             "params": {
1616                 "flavor_data": {
1617                     "disk": 10,
1618                     "name": "test",
1619                     "ram": 1024,
1620                     "vcpus": 2,
1621                     "swap": 20,
1622                 },
1623             },
1624         }
1625         target_flavor = {
1626             "id": "test_id",
1627             "name": "test",
1628             "storage-gb": "10",
1629             "memory-mb": "1024",
1630             "vcpu-count": "2",
1631         }
1632         indata = {
1633             "vnf": [
1634                 {
1635                     "vdur": [
1636                         {
1637                             "ns-flavor-id": "test_id",
1638                             "virtual-storages": [
1639                                 {
1640                                     "type-of-storage": "etsi-nfv-descriptors:swap-storage",
1641                                     "size-of-storage": "20",
1642                                 },
1643                             ],
1644                         },
1645                     ],
1646                 },
1647             ],
1648         }
1649         vim_info = {}
1650         target_record_id = ""
1651
1652         epa_params.return_value = {}
1653
1654         result = Ns._process_flavor_params(
1655             target_flavor=target_flavor,
1656             indata=indata,
1657             vim_info=vim_info,
1658             target_record_id=target_record_id,
1659         )
1660
1661         self.assertTrue(epa_params.called)
1662         self.assertDictEqual(result, expected_result)
1663
1664     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1665     def test__process_flavor_params_with_epa_params(
1666         self,
1667         epa_params,
1668     ):
1669         expected_result = {
1670             "find_params": {
1671                 "flavor_data": {
1672                     "disk": 10,
1673                     "ram": 1024,
1674                     "vcpus": 2,
1675                     "extended": {
1676                         "numa": "there-is-numa-here",
1677                     },
1678                 },
1679             },
1680             "params": {
1681                 "flavor_data": {
1682                     "disk": 10,
1683                     "name": "test",
1684                     "ram": 1024,
1685                     "vcpus": 2,
1686                     "extended": {
1687                         "numa": "there-is-numa-here",
1688                     },
1689                 },
1690             },
1691         }
1692         target_flavor = {
1693             "id": "test_id",
1694             "name": "test",
1695             "storage-gb": "10",
1696             "memory-mb": "1024",
1697             "vcpu-count": "2",
1698         }
1699         indata = {}
1700         vim_info = {}
1701         target_record_id = ""
1702
1703         epa_params.return_value = {
1704             "numa": "there-is-numa-here",
1705         }
1706
1707         result = Ns._process_flavor_params(
1708             target_flavor=target_flavor,
1709             indata=indata,
1710             vim_info=vim_info,
1711             target_record_id=target_record_id,
1712         )
1713
1714         self.assertTrue(epa_params.called)
1715         self.assertDictEqual(result, expected_result)
1716
1717     @patch("osm_ng_ro.ns.Ns._process_epa_params")
1718     def test__process_flavor_params(
1719         self,
1720         epa_params,
1721     ):
1722         expected_result = {
1723             "find_params": {
1724                 "flavor_data": {
1725                     "disk": 10,
1726                     "ram": 1024,
1727                     "vcpus": 2,
1728                     "ephemeral": 10,
1729                     "swap": 20,
1730                     "extended": {
1731                         "numa": "there-is-numa-here",
1732                     },
1733                 },
1734             },
1735             "params": {
1736                 "flavor_data": {
1737                     "disk": 10,
1738                     "name": "test",
1739                     "ram": 1024,
1740                     "vcpus": 2,
1741                     "ephemeral": 10,
1742                     "swap": 20,
1743                     "extended": {
1744                         "numa": "there-is-numa-here",
1745                     },
1746                 },
1747             },
1748         }
1749         target_flavor = {
1750             "id": "test_id",
1751             "name": "test",
1752             "storage-gb": "10",
1753             "memory-mb": "1024",
1754             "vcpu-count": "2",
1755         }
1756         indata = {
1757             "vnf": [
1758                 {
1759                     "vdur": [
1760                         {
1761                             "ns-flavor-id": "test_id",
1762                             "virtual-storages": [
1763                                 {
1764                                     "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
1765                                     "size-of-storage": "10",
1766                                 },
1767                                 {
1768                                     "type-of-storage": "etsi-nfv-descriptors:swap-storage",
1769                                     "size-of-storage": "20",
1770                                 },
1771                             ],
1772                         },
1773                     ],
1774                 },
1775             ],
1776         }
1777         vim_info = {}
1778         target_record_id = ""
1779
1780         epa_params.return_value = {
1781             "numa": "there-is-numa-here",
1782         }
1783
1784         result = Ns._process_flavor_params(
1785             target_flavor=target_flavor,
1786             indata=indata,
1787             vim_info=vim_info,
1788             target_record_id=target_record_id,
1789         )
1790
1791         self.assertTrue(epa_params.called)
1792         self.assertDictEqual(result, expected_result)
1793
1794     def test__ip_profile_to_ro_with_none(self):
1795         ip_profile = None
1796
1797         result = Ns._ip_profile_to_ro(
1798             ip_profile=ip_profile,
1799         )
1800
1801         self.assertIsNone(result)
1802
1803     def test__ip_profile_to_ro_with_empty_profile(self):
1804         ip_profile = {}
1805
1806         result = Ns._ip_profile_to_ro(
1807             ip_profile=ip_profile,
1808         )
1809
1810         self.assertIsNone(result)
1811
1812     def test__ip_profile_to_ro_with_wrong_profile(self):
1813         ip_profile = {
1814             "no-profile": "here",
1815         }
1816         expected_result = {
1817             "ip_version": "IPv4",
1818             "subnet_address": None,
1819             "gateway_address": None,
1820             "dhcp_enabled": False,
1821             "dhcp_start_address": None,
1822             "dhcp_count": None,
1823         }
1824
1825         result = Ns._ip_profile_to_ro(
1826             ip_profile=ip_profile,
1827         )
1828
1829         self.assertDictEqual(expected_result, result)
1830
1831     def test__ip_profile_to_ro_with_ipv4_profile(self):
1832         ip_profile = {
1833             "ip-version": "ipv4",
1834             "subnet-address": "192.168.0.0/24",
1835             "gateway-address": "192.168.0.254",
1836             "dhcp-params": {
1837                 "enabled": True,
1838                 "start-address": "192.168.0.10",
1839                 "count": 25,
1840             },
1841         }
1842         expected_result = {
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",
1848             "dhcp_count": 25,
1849         }
1850
1851         result = Ns._ip_profile_to_ro(
1852             ip_profile=ip_profile,
1853         )
1854
1855         self.assertDictEqual(expected_result, result)
1856
1857     def test__ip_profile_to_ro_with_ipv6_profile(self):
1858         ip_profile = {
1859             "ip-version": "ipv6",
1860             "subnet-address": "2001:0200:0001::/48",
1861             "gateway-address": "2001:0200:0001:ffff:ffff:ffff:ffff:fffe",
1862             "dhcp-params": {
1863                 "enabled": True,
1864                 "start-address": "2001:0200:0001::0010",
1865                 "count": 25,
1866             },
1867         }
1868         expected_result = {
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",
1874             "dhcp_count": 25,
1875         }
1876
1877         result = Ns._ip_profile_to_ro(
1878             ip_profile=ip_profile,
1879         )
1880
1881         self.assertDictEqual(expected_result, result)
1882
1883     def test__ip_profile_to_ro_with_dns_server(self):
1884         ip_profile = {
1885             "ip-version": "ipv4",
1886             "subnet-address": "192.168.0.0/24",
1887             "gateway-address": "192.168.0.254",
1888             "dhcp-params": {
1889                 "enabled": True,
1890                 "start-address": "192.168.0.10",
1891                 "count": 25,
1892             },
1893             "dns-server": [
1894                 {
1895                     "address": "8.8.8.8",
1896                 },
1897                 {
1898                     "address": "1.1.1.1",
1899                 },
1900                 {
1901                     "address": "1.0.0.1",
1902                 },
1903             ],
1904         }
1905         expected_result = {
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",
1911             "dhcp_count": 25,
1912             "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
1913         }
1914
1915         result = Ns._ip_profile_to_ro(
1916             ip_profile=ip_profile,
1917         )
1918
1919         self.assertDictEqual(expected_result, result)
1920
1921     def test__ip_profile_to_ro_with_security_group(self):
1922         ip_profile = {
1923             "ip-version": "ipv4",
1924             "subnet-address": "192.168.0.0/24",
1925             "gateway-address": "192.168.0.254",
1926             "dhcp-params": {
1927                 "enabled": True,
1928                 "start-address": "192.168.0.10",
1929                 "count": 25,
1930             },
1931             "security-group": {
1932                 "some-security-group": "here",
1933             },
1934         }
1935         expected_result = {
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",
1941             "dhcp_count": 25,
1942             "security_group": {
1943                 "some-security-group": "here",
1944             },
1945         }
1946
1947         result = Ns._ip_profile_to_ro(
1948             ip_profile=ip_profile,
1949         )
1950
1951         self.assertDictEqual(expected_result, result)
1952
1953     def test__ip_profile_to_ro(self):
1954         ip_profile = {
1955             "ip-version": "ipv4",
1956             "subnet-address": "192.168.0.0/24",
1957             "gateway-address": "192.168.0.254",
1958             "dhcp-params": {
1959                 "enabled": True,
1960                 "start-address": "192.168.0.10",
1961                 "count": 25,
1962             },
1963             "dns-server": [
1964                 {
1965                     "address": "8.8.8.8",
1966                 },
1967                 {
1968                     "address": "1.1.1.1",
1969                 },
1970                 {
1971                     "address": "1.0.0.1",
1972                 },
1973             ],
1974             "security-group": {
1975                 "some-security-group": "here",
1976             },
1977         }
1978         expected_result = {
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",
1984             "dhcp_count": 25,
1985             "dns_address": "8.8.8.8;1.1.1.1;1.0.0.1",
1986             "security_group": {
1987                 "some-security-group": "here",
1988             },
1989         }
1990
1991         result = Ns._ip_profile_to_ro(
1992             ip_profile=ip_profile,
1993         )
1994
1995         self.assertDictEqual(expected_result, result)
1996
1997     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
1998     def test__process_net_params_with_empty_params(
1999         self,
2000         ip_profile_to_ro,
2001     ):
2002         target_vld = {
2003             "name": "vld-name",
2004         }
2005         indata = {
2006             "name": "ns-name",
2007         }
2008         vim_info = {
2009             "provider_network": "some-profile-here",
2010         }
2011         target_record_id = ""
2012         expected_result = {
2013             "params": {
2014                 "net_name": "ns-name-vld-name",
2015                 "net_type": "bridge",
2016                 "ip_profile": {
2017                     "some_ip_profile": "here",
2018                 },
2019                 "provider_network_profile": "some-profile-here",
2020             }
2021         }
2022
2023         ip_profile_to_ro.return_value = {
2024             "some_ip_profile": "here",
2025         }
2026
2027         result = Ns._process_net_params(
2028             target_vld=target_vld,
2029             indata=indata,
2030             vim_info=vim_info,
2031             target_record_id=target_record_id,
2032         )
2033
2034         self.assertDictEqual(expected_result, result)
2035         self.assertTrue(ip_profile_to_ro.called)
2036
2037     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2038     def test__process_net_params_with_vim_info_sdn(
2039         self,
2040         ip_profile_to_ro,
2041     ):
2042         target_vld = {
2043             "name": "vld-name",
2044         }
2045         indata = {
2046             "name": "ns-name",
2047         }
2048         vim_info = {
2049             "sdn": "some-sdn",
2050             "sdn-ports": ["some", "ports", "here"],
2051             "vlds": ["some", "vlds", "here"],
2052             "type": "sdn-type",
2053         }
2054         target_record_id = "vld.sdn.something"
2055         expected_result = {
2056             "params": {
2057                 "sdn-ports": ["some", "ports", "here"],
2058                 "vlds": ["some", "vlds", "here"],
2059                 "type": "sdn-type",
2060             }
2061         }
2062
2063         result = Ns._process_net_params(
2064             target_vld=target_vld,
2065             indata=indata,
2066             vim_info=vim_info,
2067             target_record_id=target_record_id,
2068         )
2069
2070         self.assertDictEqual(expected_result, result)
2071         self.assertFalse(ip_profile_to_ro.called)
2072
2073     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2074     def test__process_net_params_with_vim_info_sdn_target_vim(
2075         self,
2076         ip_profile_to_ro,
2077     ):
2078         target_vld = {
2079             "name": "vld-name",
2080         }
2081         indata = {
2082             "name": "ns-name",
2083         }
2084         vim_info = {
2085             "sdn": "some-sdn",
2086             "sdn-ports": ["some", "ports", "here"],
2087             "vlds": ["some", "vlds", "here"],
2088             "target_vim": "some-vim",
2089             "type": "sdn-type",
2090         }
2091         target_record_id = "vld.sdn.something"
2092         expected_result = {
2093             "depends_on": ["some-vim vld.sdn"],
2094             "params": {
2095                 "sdn-ports": ["some", "ports", "here"],
2096                 "vlds": ["some", "vlds", "here"],
2097                 "target_vim": "some-vim",
2098                 "type": "sdn-type",
2099             },
2100         }
2101
2102         result = Ns._process_net_params(
2103             target_vld=target_vld,
2104             indata=indata,
2105             vim_info=vim_info,
2106             target_record_id=target_record_id,
2107         )
2108
2109         self.assertDictEqual(expected_result, result)
2110         self.assertFalse(ip_profile_to_ro.called)
2111
2112     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2113     def test__process_net_params_with_vim_network_name(
2114         self,
2115         ip_profile_to_ro,
2116     ):
2117         target_vld = {
2118             "name": "vld-name",
2119         }
2120         indata = {
2121             "name": "ns-name",
2122         }
2123         vim_info = {
2124             "vim_network_name": "some-network-name",
2125         }
2126         target_record_id = "vld.sdn.something"
2127         expected_result = {
2128             "find_params": {
2129                 "filter_dict": {
2130                     "name": "some-network-name",
2131                 },
2132             },
2133         }
2134
2135         result = Ns._process_net_params(
2136             target_vld=target_vld,
2137             indata=indata,
2138             vim_info=vim_info,
2139             target_record_id=target_record_id,
2140         )
2141
2142         self.assertDictEqual(expected_result, result)
2143         self.assertFalse(ip_profile_to_ro.called)
2144
2145     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2146     def test__process_net_params_with_vim_network_id(
2147         self,
2148         ip_profile_to_ro,
2149     ):
2150         target_vld = {
2151             "name": "vld-name",
2152         }
2153         indata = {
2154             "name": "ns-name",
2155         }
2156         vim_info = {
2157             "vim_network_id": "some-network-id",
2158         }
2159         target_record_id = "vld.sdn.something"
2160         expected_result = {
2161             "find_params": {
2162                 "filter_dict": {
2163                     "id": "some-network-id",
2164                 },
2165             },
2166         }
2167
2168         result = Ns._process_net_params(
2169             target_vld=target_vld,
2170             indata=indata,
2171             vim_info=vim_info,
2172             target_record_id=target_record_id,
2173         )
2174
2175         self.assertDictEqual(expected_result, result)
2176         self.assertFalse(ip_profile_to_ro.called)
2177
2178     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2179     def test__process_net_params_with_mgmt_network(
2180         self,
2181         ip_profile_to_ro,
2182     ):
2183         target_vld = {
2184             "id": "vld-id",
2185             "name": "vld-name",
2186             "mgmt-network": "some-mgmt-network",
2187         }
2188         indata = {
2189             "name": "ns-name",
2190         }
2191         vim_info = {}
2192         target_record_id = "vld.sdn.something"
2193         expected_result = {
2194             "find_params": {
2195                 "mgmt": True,
2196                 "name": "vld-id",
2197             },
2198         }
2199
2200         result = Ns._process_net_params(
2201             target_vld=target_vld,
2202             indata=indata,
2203             vim_info=vim_info,
2204             target_record_id=target_record_id,
2205         )
2206
2207         self.assertDictEqual(expected_result, result)
2208         self.assertFalse(ip_profile_to_ro.called)
2209
2210     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2211     def test__process_net_params_with_underlay_eline(
2212         self,
2213         ip_profile_to_ro,
2214     ):
2215         target_vld = {
2216             "name": "vld-name",
2217             "underlay": "some-underlay-here",
2218             "type": "ELINE",
2219         }
2220         indata = {
2221             "name": "ns-name",
2222         }
2223         vim_info = {
2224             "provider_network": "some-profile-here",
2225         }
2226         target_record_id = ""
2227         expected_result = {
2228             "params": {
2229                 "ip_profile": {
2230                     "some_ip_profile": "here",
2231                 },
2232                 "net_name": "ns-name-vld-name",
2233                 "net_type": "ptp",
2234                 "provider_network_profile": "some-profile-here",
2235             }
2236         }
2237
2238         ip_profile_to_ro.return_value = {
2239             "some_ip_profile": "here",
2240         }
2241
2242         result = Ns._process_net_params(
2243             target_vld=target_vld,
2244             indata=indata,
2245             vim_info=vim_info,
2246             target_record_id=target_record_id,
2247         )
2248
2249         self.assertDictEqual(expected_result, result)
2250         self.assertTrue(ip_profile_to_ro.called)
2251
2252     @patch("osm_ng_ro.ns.Ns._ip_profile_to_ro")
2253     def test__process_net_params_with_underlay_elan(
2254         self,
2255         ip_profile_to_ro,
2256     ):
2257         target_vld = {
2258             "name": "vld-name",
2259             "underlay": "some-underlay-here",
2260             "type": "ELAN",
2261         }
2262         indata = {
2263             "name": "ns-name",
2264         }
2265         vim_info = {
2266             "provider_network": "some-profile-here",
2267         }
2268         target_record_id = ""
2269         expected_result = {
2270             "params": {
2271                 "ip_profile": {
2272                     "some_ip_profile": "here",
2273                 },
2274                 "net_name": "ns-name-vld-name",
2275                 "net_type": "data",
2276                 "provider_network_profile": "some-profile-here",
2277             }
2278         }
2279
2280         ip_profile_to_ro.return_value = {
2281             "some_ip_profile": "here",
2282         }
2283
2284         result = Ns._process_net_params(
2285             target_vld=target_vld,
2286             indata=indata,
2287             vim_info=vim_info,
2288             target_record_id=target_record_id,
2289         )
2290
2291         self.assertDictEqual(expected_result, result)
2292         self.assertTrue(ip_profile_to_ro.called)
2293
2294     def test__get_cloud_init_exception(self):
2295         db_mock = MagicMock(name="database mock")
2296         fs_mock = None
2297
2298         location = ""
2299
2300         with self.assertRaises(NsException):
2301             Ns._get_cloud_init(db=db_mock, fs=fs_mock, location=location)
2302
2303     def test__get_cloud_init_file_fs_exception(self):
2304         db_mock = MagicMock(name="database mock")
2305         fs_mock = None
2306
2307         location = "vnfr_id_123456:file:test_file"
2308         db_mock.get_one.return_value = {
2309             "_admin": {
2310                 "storage": {
2311                     "folder": "/home/osm",
2312                     "pkg-dir": "vnfr_test_dir",
2313                 },
2314             },
2315         }
2316
2317         with self.assertRaises(NsException):
2318             Ns._get_cloud_init(db=db_mock, fs=fs_mock, location=location)
2319
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")
2324
2325         location = "vnfr_id_123456:file:test_file"
2326         cloud_init_content = "this is a cloud init file content"
2327
2328         db_mock.get_one.return_value = {
2329             "_admin": {
2330                 "storage": {
2331                     "folder": "/home/osm",
2332                     "pkg-dir": "vnfr_test_dir",
2333                 },
2334             },
2335         }
2336         fs_mock.file_open.return_value = file_mock
2337         file_mock.__enter__.return_value.read.return_value = cloud_init_content
2338
2339         result = Ns._get_cloud_init(db=db_mock, fs=fs_mock, location=location)
2340
2341         self.assertEqual(cloud_init_content, result)
2342
2343     def test__get_cloud_init_vdu(self):
2344         db_mock = MagicMock(name="database mock")
2345         fs_mock = None
2346
2347         location = "vnfr_id_123456:vdu:0"
2348         cloud_init_content = "this is a cloud init file content"
2349
2350         db_mock.get_one.return_value = {
2351             "vdu": {
2352                 0: {
2353                     "cloud-init": cloud_init_content,
2354                 },
2355             },
2356         }
2357
2358         result = Ns._get_cloud_init(db=db_mock, fs=fs_mock, location=location)
2359
2360         self.assertEqual(cloud_init_content, result)
2361
2362     @patch("jinja2.Environment.__init__")
2363     def test__parse_jinja2_undefined_error(self, env_mock: Mock):
2364         cloud_init_content = None
2365         params = None
2366         context = None
2367
2368         env_mock.side_effect = UndefinedError("UndefinedError occurred.")
2369
2370         with self.assertRaises(NsException):
2371             Ns._parse_jinja2(
2372                 cloud_init_content=cloud_init_content, params=params, context=context
2373             )
2374
2375     @patch("jinja2.Environment.__init__")
2376     def test__parse_jinja2_template_error(self, env_mock: Mock):
2377         cloud_init_content = None
2378         params = None
2379         context = None
2380
2381         env_mock.side_effect = TemplateError("TemplateError occurred.")
2382
2383         with self.assertRaises(NsException):
2384             Ns._parse_jinja2(
2385                 cloud_init_content=cloud_init_content, params=params, context=context
2386             )
2387
2388     @patch("jinja2.Environment.__init__")
2389     def test__parse_jinja2_template_not_found(self, env_mock: Mock):
2390         cloud_init_content = None
2391         params = None
2392         context = None
2393
2394         env_mock.side_effect = TemplateNotFound("TemplateNotFound occurred.")
2395
2396         with self.assertRaises(NsException):
2397             Ns._parse_jinja2(
2398                 cloud_init_content=cloud_init_content, params=params, context=context
2399             )
2400
2401     def test__parse_jinja2(self):
2402         pass
2403
2404     def test__process_vdu_params_empty_kargs(self):
2405         pass
2406
2407     def test__process_vdu_params_interface_ns_vld_id(self):
2408         pass
2409
2410     def test__process_vdu_params_interface_vnf_vld_id(self):
2411         pass
2412
2413     def test__process_vdu_params_interface_unknown(self):
2414         pass
2415
2416     def test__process_vdu_params_interface_port_security_enabled(self):
2417         pass
2418
2419     def test__process_vdu_params_interface_port_security_disable_strategy(self):
2420         pass
2421
2422     def test__process_vdu_params_interface_sriov(self):
2423         pass
2424
2425     def test__process_vdu_params_interface_pci_passthrough(self):
2426         pass
2427
2428     def test__process_vdu_params_interface_om_mgmt(self):
2429         pass
2430
2431     def test__process_vdu_params_interface_mgmt_interface(self):
2432         pass
2433
2434     def test__process_vdu_params_interface_mgmt_vnf(self):
2435         pass
2436
2437     def test__process_vdu_params_interface_bridge(self):
2438         pass
2439
2440     def test__process_vdu_params_interface_ip_address(self):
2441         pass
2442
2443     def test__process_vdu_params_interface_mac_address(self):
2444         pass
2445
2446     def test__process_vdu_params_vdu_cloud_init_missing(self):
2447         pass
2448
2449     def test__process_vdu_params_vdu_cloud_init_present(self):
2450         pass
2451
2452     def test__process_vdu_params_vdu_boot_data_drive(self):
2453         pass
2454
2455     def test__process_vdu_params_vdu_ssh_keys(self):
2456         pass
2457
2458     def test__process_vdu_params_vdu_ssh_access_required(self):
2459         pass
2460
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
2465     ):
2466         db = MagicMock(name="database mock")
2467         kwargs = {
2468             "db": db,
2469             "vdu2cloud_init": {},
2470             "vnfr": {
2471                 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2472                 "member-vnf-index-ref": "vnf-several-volumes",
2473             },
2474         }
2475         get_cloud_init.return_value = {}
2476         parse_jinja2.return_value = {}
2477         db.get_one.return_value = {
2478             "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2479             "df": [
2480                 {
2481                     "id": "default-df",
2482                     "vdu-profile": [
2483                         {"id": "several_volumes-VM", "min-number-of-instances": 1}
2484                     ],
2485                 }
2486             ],
2487             "id": "several_volumes-vnf",
2488             "product-name": "several_volumes-vnf",
2489             "vdu": [
2490                 {
2491                     "id": "several_volumes-VM",
2492                     "name": "several_volumes-VM",
2493                     "sw-image-desc": "ubuntu20.04",
2494                     "alternative-sw-image-desc": [
2495                         "ubuntu20.04-aws",
2496                         "ubuntu20.04-azure",
2497                     ],
2498                     "virtual-storage-desc": [
2499                         "persistent-root-volume",
2500                         "persistent-volume2",
2501                         "ephemeral-volume",
2502                     ],
2503                 }
2504             ],
2505             "version": "1.0",
2506             "virtual-storage-desc": [
2507                 {
2508                     "id": "persistent-volume2",
2509                     "type-of-storage": "persistent-storage:persistent-storage",
2510                     "size-of-storage": "10",
2511                 },
2512                 {
2513                     "id": "persistent-root-volume",
2514                     "type-of-storage": "persistent-storage:persistent-storage",
2515                     "size-of-storage": "10",
2516                 },
2517                 {
2518                     "id": "ephemeral-volume",
2519                     "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2520                     "size-of-storage": "1",
2521                 },
2522             ],
2523             "_admin": {
2524                 "storage": {
2525                     "fs": "mongo",
2526                     "path": "/app/storage/",
2527                 },
2528                 "type": "vnfd",
2529             },
2530         }
2531
2532         target_vdu = {
2533             "_id": "09a0baa7-b7cb-4924-bd63-9f04a1c23960",
2534             "ns-flavor-id": "0",
2535             "ns-image-id": "0",
2536             "vdu-name": "several_volumes-VM",
2537             "interfaces": [
2538                 {
2539                     "name": "vdu-eth0",
2540                     "ns-vld-id": "mgmtnet",
2541                 }
2542             ],
2543             "virtual-storages": [
2544                 {
2545                     "id": "persistent-volume2",
2546                     "size-of-storage": "10",
2547                     "type-of-storage": "persistent-storage:persistent-storage",
2548                 },
2549                 {
2550                     "id": "persistent-root-volume",
2551                     "size-of-storage": "10",
2552                     "type-of-storage": "persistent-storage:persistent-storage",
2553                 },
2554                 {
2555                     "id": "ephemeral-volume",
2556                     "size-of-storage": "1",
2557                     "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2558                 },
2559             ],
2560         }
2561         indata = {
2562             "name": "sample_name",
2563         }
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
2567         )
2568         self.assertEqual(
2569             expected_result, result["params"]["disk_list"], "Wrong Disk List"
2570         )
2571
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
2576     ):
2577         db = MagicMock(name="database mock")
2578         kwargs = {
2579             "db": db,
2580             "vdu2cloud_init": {},
2581             "vnfr": {
2582                 "vnfd-id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2583                 "member-vnf-index-ref": "vnf-several-volumes",
2584             },
2585         }
2586         get_cloud_init.return_value = {}
2587         parse_jinja2.return_value = {}
2588         db.get_one.return_value = {
2589             "_id": "ad6356e3-698c-43bf-9901-3aae9e9b9d18",
2590             "df": [
2591                 {
2592                     "id": "default-df",
2593                     "vdu-profile": [
2594                         {"id": "without_volumes-VM", "min-number-of-instances": 1}
2595                     ],
2596                 }
2597             ],
2598             "id": "without_volumes-vnf",
2599             "product-name": "without_volumes-vnf",
2600             "vdu": [
2601                 {
2602                     "id": "without_volumes-VM",
2603                     "name": "without_volumes-VM",
2604                     "sw-image-desc": "ubuntu20.04",
2605                     "alternative-sw-image-desc": [
2606                         "ubuntu20.04-aws",
2607                         "ubuntu20.04-azure",
2608                     ],
2609                     "virtual-storage-desc": ["root-volume", "ephemeral-volume"],
2610                 }
2611             ],
2612             "version": "1.0",
2613             "virtual-storage-desc": [
2614                 {"id": "root-volume", "size-of-storage": "10"},
2615                 {
2616                     "id": "ephemeral-volume",
2617                     "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2618                     "size-of-storage": "1",
2619                 },
2620             ],
2621             "_admin": {
2622                 "storage": {
2623                     "fs": "mongo",
2624                     "path": "/app/storage/",
2625                 },
2626                 "type": "vnfd",
2627             },
2628         }
2629
2630         target_vdu = {
2631             "_id": "09a0baa7-b7cb-4924-bd63-9f04a1c23960",
2632             "ns-flavor-id": "0",
2633             "ns-image-id": "0",
2634             "vdu-name": "without_volumes-VM",
2635             "interfaces": [
2636                 {
2637                     "name": "vdu-eth0",
2638                     "ns-vld-id": "mgmtnet",
2639                 }
2640             ],
2641             "virtual-storages": [
2642                 {
2643                     "id": "root-volume",
2644                     "size-of-storage": "10",
2645                 },
2646                 {
2647                     "id": "ephemeral-volume",
2648                     "size-of-storage": "1",
2649                     "type-of-storage": "etsi-nfv-descriptors:ephemeral-storage",
2650                 },
2651             ],
2652         }
2653         indata = {
2654             "name": "sample_name",
2655         }
2656         expected_result = []
2657         result = Ns._process_vdu_params(
2658             target_vdu, indata, vim_info=None, target_record_id=None, **kwargs
2659         )
2660         self.assertEqual(
2661             expected_result, result["params"]["disk_list"], "Wrong Disk List"
2662         )
2663
2664     def test__process_vdu_params(self):
2665         pass
2666
2667     @patch("osm_ng_ro.ns.Ns._assign_vim")
2668     def test__rebuild_start_stop_task(self, assign_vim):
2669         self.ns = Ns()
2670         extra_dict = {}
2671         actions = ["start", "stop", "rebuild"]
2672         vdu_id = "bb9c43f9-10a2-4569-a8a8-957c3528b6d1"
2673         vnf_id = "665b4165-ce24-4320-bf19-b9a45bade49f"
2674         vdu_index = "0"
2675         action_id = "bb937f49-3870-4169-b758-9732e1ff40f3"
2676         nsr_id = "993166fe-723e-4680-ac4b-b1af2541ae31"
2677         task_index = 0
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:
2681             expected_result = {
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",
2687                 "action": "EXEC",
2688                 "item": "update",
2689                 "target_record": "vnfrs:665b4165-ce24-4320-bf19-b9a45bade49f:vdur.0",
2690                 "target_record_id": t,
2691                 "params": {
2692                     "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2693                     "action": action,
2694                 },
2695             }
2696             extra_dict["params"] = {
2697                 "vim_vm_id": "f37b18ef-3caa-4dc9-ab91-15c669b16396",
2698                 "action": action,
2699             }
2700             task = self.ns.rebuild_start_stop_task(
2701                 vdu_id,
2702                 vnf_id,
2703                 vdu_index,
2704                 action_id,
2705                 nsr_id,
2706                 task_index,
2707                 target_vim,
2708                 extra_dict,
2709             )
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)