catalog/packages/tests/test_nsdm_subscription.py

   1 # Copyright (C) 2019 Verizon. All Rights Reserved
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import json
  16 import mock
  17 import uuid
  18 import os
  19 from django.test import TestCase
  20 from rest_framework.test import APIClient
  21 from rest_framework import status
  22
  23 from catalog.packages.biz.nsdm_subscription import NsdmSubscription
  24 from catalog.pub.database.models import NsdmSubscriptionModel
  25 from catalog.packages.biz.notificationsutil import NsdNotifications, PnfNotifications
  26 from catalog.packages import const
  27 from catalog.pub.config import config as pub_config
  28 import catalog.pub.utils.timeutil
  29 from catalog.packages.tests.const import nsd_data
  30 from catalog.pub.database.models import NSPackageModel, VnfPackageModel, PnfPackageModel
  31 from catalog.pub.config.config import CATALOG_ROOT_PATH
  32 from catalog.pub.utils import toscaparser
  33
  34
  35 class TestNsdmSubscription(TestCase):
  36
  37     def setUp(self):
  38         self.client = APIClient()
  39         NsdmSubscriptionModel.objects.all().delete()
  40         self.subscription_id = str(uuid.uuid4())
  41         self.subscription = {
  42             "callbackUri": "http://callbackuri.com",
  43             "authentication": {
  44                 "authType": ["BASIC"],
  45                 "paramsBasic": {
  46                     "userName": "username",
  47                     "password": "password"
  48                 }
  49             },
  50             "filter": {
  51                 "nsdId": ["b632bddc-abcd-4180-bd8d-4e8a9578eff7"],
  52             }
  53         }
  54         self.links = {
  55             "self": {
  56                 "href": "/api/v1/subscriptions/" + self.subscription_id
  57             }
  58         }
  59         self.test_subscription = {
  60             "callbackUri": "http://callbackuri.com",
  61             "id": self.subscription_id,
  62             "filter": {
  63                 "notificationTypes": [
  64                     "NsdOnBoardingNotification"
  65                 ],
  66                 "nsdInfoId": [],
  67                 "nsdId": [],
  68                 "nsdName": [],
  69                 "nsdVersion": [],
  70                 "nsdInvariantId": [],
  71                 "vnfPkgIds": [],
  72                 "nestedNsdInfoIds": [],
  73                 "nsdOnboardingState": [],
  74                 "nsdOperationalState": [],
  75                 "nsdUsageState": [],
  76                 "pnfdInfoIds": [],
  77                 "pnfdId": [],
  78                 "pnfdName": [],
  79                 "pnfdVersion": [],
  80                 "pnfdProvider": [],
  81                 "pnfdInvariantId": [],
  82                 "pnfdOnboardingState": [],
  83                 "pnfdUsageState": []
  84             },
  85             "_links": self.links,
  86         }
  87
  88     def tearDown(self):
  89         pass
  90
  91     @mock.patch("requests.get")
  92     @mock.patch.object(uuid, 'uuid4')
  93     def test_nsdm_subscribe_notification(self, mock_uuid4, mock_requests):
  94         temp_uuid = str(uuid.uuid4())
  95         mock_requests.return_value.status_code = 204
  96         mock_requests.get.return_value.status_code = 204
  97         mock_uuid4.return_value = temp_uuid
  98         response = self.client.post("/api/nsd/v1/subscriptions",
  99                                     data=self.subscription, format='json')
 100         self.assertEqual(201, response.status_code)
 101         self.assertEqual(self.subscription["callbackUri"],
 102                          response.data["callbackUri"])
 103         self.assertEqual(temp_uuid, response.data["id"])
 104
 105     @mock.patch("requests.get")
 106     @mock.patch.object(uuid, 'uuid4')
 107     def test_nsdm_subscribe_callbackFailure(self, mock_uuid4, mock_requests):
 108         temp_uuid = str(uuid.uuid4())
 109         mock_requests.return_value.status_code = 500
 110         mock_requests.get.return_value.status_code = 500
 111         mock_uuid4.return_value = temp_uuid
 112         expected_data = {
 113             'status': 500,
 114             'detail': "callbackUri http://callbackuri.com didn't"
 115                       " return 204 statuscode."
 116         }
 117         response = self.client.post("/api/nsd/v1/subscriptions",
 118                                     data=self.subscription, format='json')
 119         self.assertEqual(500, response.status_code)
 120         self.assertEqual(expected_data, response.data)
 121
 122     @mock.patch("requests.get")
 123     def test_nsdm_second_subscription(self, mock_requests):
 124         mock_requests.return_value.status_code = 204
 125         mock_requests.get.return_value.status_code = 204
 126         response = self.client.post("/api/nsd/v1/subscriptions",
 127                                     data=self.subscription, format='json')
 128         self.assertEqual(201, response.status_code)
 129         self.assertEqual(self.subscription["callbackUri"],
 130                          response.data["callbackUri"])
 131         dummy_subscription = {
 132             "callbackUri": "http://callbackuri.com",
 133             "authentication": {
 134                 "authType": ["BASIC"],
 135                 "paramsBasic": {
 136                     "userName": "username",
 137                     "password": "password"
 138                 }
 139             },
 140             "filter": {
 141                 "nsdId": ["b632bddc-bccd-4180-bd8d-4e8a9578eff7"],
 142             }
 143         }
 144         response = self.client.post("/api/nsd/v1/subscriptions",
 145                                     data=dummy_subscription, format='json')
 146         self.assertEqual(201, response.status_code)
 147         self.assertEqual(dummy_subscription["callbackUri"],
 148                          response.data["callbackUri"])
 149
 150     @mock.patch("requests.get")
 151     def test_nsdm_duplicate_subscription(self, mock_requests):
 152         mock_requests.return_value.status_code = 204
 153         mock_requests.get.return_value.status_code = 204
 154         response = self.client.post("/api/nsd/v1/subscriptions",
 155                                     data=self.subscription, format='json')
 156         self.assertEqual(201, response.status_code)
 157         self.assertEqual(self.subscription["callbackUri"],
 158                          response.data["callbackUri"])
 159         expected_data = {
 160             'status': 303,
 161             'detail': 'Subscription has already existed with'
 162                       ' the same callbackUri and filter'
 163         }
 164         response = self.client.post("/api/nsd/v1/subscriptions",
 165                                     data=self.subscription, format='json')
 166         self.assertEqual(303, response.status_code)
 167         self.assertEqual(expected_data, response.data)
 168
 169     @mock.patch("requests.get")
 170     def test_nsdm_bad_request(self, mock_requests):
 171         dummy_subscription = {
 172             "callbackUri": "http://callbackuri.com",
 173             "authentication": {
 174                 "authType": ["BASIC"],
 175                 "paramsBasic": {
 176                     "userName": "username",
 177                     "password": "password"
 178                 }
 179             },
 180             "filter": {
 181                 "nsdId": "b632bddc-bccd-4180-bd8d-4e8a9578eff7",
 182             }
 183         }
 184         response = self.client.post("/api/nsd/v1/subscriptions",
 185                                     data=dummy_subscription, format='json')
 186         self.assertEqual(400, response.status_code)
 187
 188     @mock.patch("requests.get")
 189     def test_nsdm_invalid_authtype_subscription(self, mock_requests):
 190         dummy_subscription = {
 191             "callbackUri": "http://callbackuri.com",
 192             "authentication": {
 193                 "authType": ["OAUTH2_CLIENT_CREDENTIALS"],
 194                 "paramsBasic": {
 195                     "userName": "username",
 196                     "password": "password"
 197                 }
 198             }
 199         }
 200         mock_requests.return_value.status_code = 204
 201         mock_requests.get.return_value.status_code = 204
 202         expected_data = {
 203             'status': 400,
 204             'detail': 'Auth type should be BASIC'
 205         }
 206         response = self.client.post("/api/nsd/v1/subscriptions",
 207                                     data=dummy_subscription, format='json')
 208         self.assertEqual(400, response.status_code)
 209         self.assertEqual(expected_data, response.data)
 210
 211     @mock.patch("requests.get")
 212     def test_nsdm_invalid_authtype_oauthclient_subscription(
 213             self, mock_requests):
 214         dummy_subscription = {
 215             "callbackUri": "http://callbackuri.com",
 216             "authentication": {
 217                 "authType": ["BASIC"],
 218                 "paramsOauth2ClientCredentials": {
 219                     "clientId": "clientId",
 220                     "clientPassword": "password",
 221                     "tokenEndpoint": "http://tokenEndpoint"
 222                 }
 223             }
 224         }
 225         mock_requests.return_value.status_code = 204
 226         mock_requests.get.return_value.status_code = 204
 227         expected_data = {
 228             'status': 400,
 229             'detail': 'Auth type should be OAUTH2_CLIENT_CREDENTIALS'
 230         }
 231         response = self.client.post("/api/nsd/v1/subscriptions",
 232                                     data=dummy_subscription, format='json')
 233         self.assertEqual(400, response.status_code)
 234         self.assertEqual(expected_data, response.data)
 235
 236     @mock.patch("requests.get")
 237     def test_nsdm_invalid_authparams_subscription(self, mock_requests):
 238         dummy_subscription = {
 239             "callbackUri": "http://callbackuri.com",
 240             "authentication": {
 241                 "authType": ["BASIC"],
 242                 "paramsBasic": {
 243                     "userName": "username"
 244                 }
 245             }
 246         }
 247         mock_requests.return_value.status_code = 204
 248         mock_requests.get.return_value.status_code = 204
 249         expected_data = {
 250             'status': 400,
 251             'detail': 'userName and password needed for BASIC'
 252         }
 253         response = self.client.post("/api/nsd/v1/subscriptions",
 254                                     data=dummy_subscription, format='json')
 255         self.assertEqual(400, response.status_code)
 256         self.assertEqual(expected_data, response.data)
 257
 258     @mock.patch("requests.get")
 259     def test_nsdm_invalid_authparams_oauthclient_subscription(
 260             self, mock_requests):
 261         dummy_subscription = {
 262             "callbackUri": "http://callbackuri.com",
 263             "authentication": {
 264                 "authType": ["OAUTH2_CLIENT_CREDENTIALS"],
 265                 "paramsOauth2ClientCredentials": {
 266                     "clientPassword": "password",
 267                     "tokenEndpoint": "http://tokenEndpoint"
 268                 }
 269             }
 270         }
 271         mock_requests.return_value.status_code = 204
 272         mock_requests.get.return_value.status_code = 204
 273         expected_data = {
 274             'status': 400,
 275             'detail': 'clientId, clientPassword and tokenEndpoint'
 276                       ' required for OAUTH2_CLIENT_CREDENTIALS'
 277         }
 278         response = self.client.post("/api/nsd/v1/subscriptions",
 279                                     data=dummy_subscription, format='json')
 280         self.assertEqual(400, response.status_code)
 281         self.assertEqual(expected_data, response.data)
 282
 283     @mock.patch("requests.get")
 284     def test_nsdm_invalid_filter_subscription(self, mock_requests):
 285         dummy_subscription = {
 286             "callbackUri": "http://callbackuri.com",
 287             "authentication": {
 288                 "authType": ["BASIC"],
 289                 "paramsBasic": {
 290                     "userName": "username",
 291                     "password": "password"
 292                 }
 293             },
 294             "filter": {
 295                 "nsdId": ["b632bddc-bccd-4180-bd8d-4e8a9578eff7"],
 296                 "nsdInfoId": ["d0ea5ec3-0b98-438a-9bea-488230cff174"]
 297             }
 298         }
 299         mock_requests.return_value.status_code = 204
 300         mock_requests.get.return_value.status_code = 204
 301         expected_data = {
 302             'status': 400,
 303             'detail': 'Notification Filter should contain'
 304                       ' either nsdId or nsdInfoId'
 305         }
 306         response = self.client.post("/api/nsd/v1/subscriptions",
 307                                     data=dummy_subscription, format='json')
 308         self.assertEqual(400, response.status_code)
 309         self.assertEqual(expected_data, response.data)
 310
 311     @mock.patch("requests.get")
 312     def test_nsdm_invalid_filter_pnfd_subscription(self, mock_requests):
 313         dummy_subscription = {
 314             "callbackUri": "http://callbackuri.com",
 315             "authentication": {
 316                 "authType": ["BASIC"],
 317                 "paramsBasic": {
 318                     "userName": "username",
 319                     "password": "password"
 320                 }
 321             },
 322             "filter": {
 323                 "pnfdId": ["b632bddc-bccd-4180-bd8d-4e8a9578eff7"],
 324                 "pnfdInfoIds": ["d0ea5ec3-0b98-438a-9bea-488230cff174"]
 325             }
 326         }
 327         mock_requests.return_value.status_code = 204
 328         mock_requests.get.return_value.status_code = 204
 329         expected_data = {
 330             'status': 400,
 331             'detail': 'Notification Filter should contain'
 332                       ' either pnfdId or pnfdInfoIds'
 333         }
 334         response = self.client.post("/api/nsd/v1/subscriptions",
 335                                     data=dummy_subscription, format='json')
 336         self.assertEqual(400, response.status_code)
 337         self.assertEqual(expected_data, response.data)
 338
 339     @mock.patch.object(NsdmSubscription, 'create')
 340     def test_nsdmsubscription_create_when_catch_exception(self, mock_create):
 341         mock_create.side_effect = TypeError("Unicode type")
 342         response = self.client.post('/api/nsd/v1/subscriptions',
 343                                     data=self.subscription, format='json')
 344         self.assertEqual(response.status_code,
 345                          status.HTTP_500_INTERNAL_SERVER_ERROR)
 346
 347     def test_nsdm_get_subscriptions(self):
 348         NsdmSubscriptionModel(subscriptionid=self.subscription_id,
 349                               callback_uri="http://callbackuri.com",
 350                               auth_info={},
 351                               notificationTypes=json.dumps(
 352                                   ["NsdOnBoardingNotification"]),
 353                               nsdId=[], nsdVersion=[],
 354                               nsdInfoId=[], nsdDesigner=[],
 355                               nsdName=[], nsdInvariantId=[],
 356                               vnfPkgIds=[], pnfdInfoIds=[],
 357                               nestedNsdInfoIds=[], nsdOnboardingState=[],
 358                               nsdOperationalState=[], nsdUsageState=[],
 359                               pnfdId=[], pnfdVersion=[], pnfdProvider=[],
 360                               pnfdName=[], pnfdInvariantId=[],
 361                               pnfdOnboardingState=[], pnfdUsageState=[],
 362                               links=json.dumps(self.links)).save()
 363         response = self.client.get("/api/nsd/v1/subscriptions",
 364                                    format='json')
 365         self.assertEqual(status.HTTP_200_OK, response.status_code)
 366         self.assertEqual([self.test_subscription], response.data)
 367
 368     def test_nsdm_get_subscriptions_filter(self):
 369         NsdmSubscriptionModel(subscriptionid=self.subscription_id,
 370                               callback_uri="http://callbackuri.com",
 371                               auth_info={},
 372                               notificationTypes=json.dumps(
 373                                   ["NsdOnBoardingNotification"]),
 374                               nsdId=[], nsdVersion=[],
 375                               nsdInfoId=[], nsdDesigner=[],
 376                               nsdName=[], nsdInvariantId=[],
 377                               vnfPkgIds=[], pnfdInfoIds=[],
 378                               nestedNsdInfoIds=[], nsdOnboardingState=[],
 379                               nsdOperationalState=[], nsdUsageState=[],
 380                               pnfdId=[], pnfdVersion=[], pnfdProvider=[],
 381                               pnfdName=[], pnfdInvariantId=[],
 382                               pnfdOnboardingState=[], pnfdUsageState=[],
 383                               links=json.dumps(self.links)).save()
 384         response = self.client.get("/api/nsd/v1/subscriptions"
 385                                    "?notificationTypes"
 386                                    "=NsdOnBoardingNotification",
 387                                    format='json')
 388         self.assertEqual(status.HTTP_200_OK, response.status_code)
 389         self.assertEqual([self.test_subscription], response.data)
 390
 391     def test_nsdm_get_subscriptions_filter_failure(self):
 392         NsdmSubscriptionModel(subscriptionid=self.subscription_id,
 393                               callback_uri="http://callbackuri.com",
 394                               auth_info={},
 395                               notificationTypes=json.dumps(
 396                                   ["NsdOnBoardingNotification"]),
 397                               nsdId=[], nsdVersion=[],
 398                               nsdInfoId=[], nsdDesigner=[],
 399                               nsdName=[], nsdInvariantId=[],
 400                               vnfPkgIds=[], pnfdInfoIds=[],
 401                               nestedNsdInfoIds=[], nsdOnboardingState=[],
 402                               nsdOperationalState=[], nsdUsageState=[],
 403                               pnfdId=[], pnfdVersion=[], pnfdProvider=[],
 404                               pnfdName=[], pnfdInvariantId=[],
 405                               pnfdOnboardingState=[], pnfdUsageState=[],
 406                               links=json.dumps(self.links)).save()
 407         response = self.client.get("/api/nsd/v1/subscriptions"
 408                                    "?notificationTypes="
 409                                    "PnfdOnBoardingFailureNotification",
 410                                    format='json')
 411         self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
 412
 413     def test_nsdm_get_subscriptions_invalid_filter(self):
 414         NsdmSubscriptionModel(subscriptionid=self.subscription_id,
 415                               callback_uri="http://callbackuri.com",
 416                               auth_info={},
 417                               notificationTypes=json.dumps(
 418                                   ["NsdOnBoardingNotification"]),
 419                               nsdId=[], nsdVersion=[],
 420                               nsdInfoId=[], nsdDesigner=[],
 421                               nsdName=[], nsdInvariantId=[],
 422                               vnfPkgIds=[], pnfdInfoIds=[],
 423                               nestedNsdInfoIds=[], nsdOnboardingState=[],
 424                               nsdOperationalState=[], nsdUsageState=[],
 425                               pnfdId=[], pnfdVersion=[], pnfdProvider=[],
 426                               pnfdName=[], pnfdInvariantId=[],
 427                               pnfdOnboardingState=[], pnfdUsageState=[],
 428                               links=json.dumps(self.links)).save()
 429         response = self.client.get("/api/nsd/v1/subscriptions"
 430                                    "?notificationTypes="
 431                                    "PnfdOnBoardingFailureNotificati",
 432                                    format='json')
 433         self.assertEqual(status.HTTP_400_BAD_REQUEST, response.status_code)
 434
 435     @mock.patch.object(NsdmSubscription, 'query_multi_subscriptions')
 436     def test_nsdmsubscription_get_when_catch_exception(self, mock_create):
 437         mock_create.side_effect = TypeError("Unicode type")
 438         response = self.client.get('/api/nsd/v1/subscriptions', format='json')
 439         self.assertEqual(response.status_code,
 440                          status.HTTP_500_INTERNAL_SERVER_ERROR)
 441
 442     def test_nsdm_get_subscription(self):
 443         NsdmSubscriptionModel(subscriptionid=self.subscription_id,
 444                               callback_uri="http://callbackuri.com",
 445                               auth_info={},
 446                               notificationTypes=json.dumps(
 447                                   ["NsdOnBoardingNotification"]),
 448                               nsdId=[], nsdVersion=[],
 449                               nsdInfoId=[], nsdDesigner=[],
 450                               nsdName=[], nsdInvariantId=[],
 451                               vnfPkgIds=[], pnfdInfoIds=[],
 452                               nestedNsdInfoIds=[], nsdOnboardingState=[],
 453                               nsdOperationalState=[], nsdUsageState=[],
 454                               pnfdId=[], pnfdVersion=[], pnfdProvider=[],
 455                               pnfdName=[], pnfdInvariantId=[],
 456                               pnfdOnboardingState=[], pnfdUsageState=[],
 457                               links=json.dumps(self.links)).save()
 458         response = self.client.get('/api/nsd/v1/'
 459                                    'subscriptions/' + self.subscription_id,
 460                                    format='json')
 461         self.assertEqual(status.HTTP_200_OK, response.status_code)
 462         self.assertEqual(self.test_subscription, response.data)
 463
 464     def test_nsdm_get_subscription_failure(self):
 465         expected_data = {
 466             "status": 404,
 467             "detail": "Subscription(" + self.subscription_id + ") "
 468             "doesn't exist"
 469         }
 470         response = self.client.get('/api/nsd/v1/'
 471                                    'subscriptions/' + self.subscription_id,
 472                                    format='json')
 473         self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
 474         self.assertEqual(expected_data, response.data)
 475
 476     def test_nsdm_get_subscription_failure_bad_request(self):
 477         response = self.client.get("/api/nsd/v1/subscriptions/123",
 478                                    format='json')
 479         self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
 480
 481     @mock.patch.object(NsdmSubscription, 'query_single_subscription')
 482     def test_nsdmsubscription_getsingle_when_catch_exception(
 483             self, mock_create):
 484         mock_create.side_effect = TypeError("Unicode type")
 485         response = self.client.get('/api/nsd/v1/'
 486                                    'subscriptions/' + self.subscription_id,
 487                                    format='json')
 488         self.assertEqual(response.status_code,
 489                          status.HTTP_500_INTERNAL_SERVER_ERROR)
 490
 491     def test_ndsm_delete_subscription(self):
 492         NsdmSubscriptionModel(subscriptionid=self.subscription_id,
 493                               callback_uri="http://callbackuri.com",
 494                               auth_info={},
 495                               notificationTypes=json.dumps(
 496                                   ["NsdOnBoardingNotification"]),
 497                               nsdId=[], nsdVersion=[],
 498                               nsdInfoId=[], nsdDesigner=[],
 499                               nsdName=[], nsdInvariantId=[],
 500                               vnfPkgIds=[], pnfdInfoIds=[],
 501                               nestedNsdInfoIds=[], nsdOnboardingState=[],
 502                               nsdOperationalState=[], nsdUsageState=[],
 503                               pnfdId=[], pnfdVersion=[], pnfdProvider=[],
 504                               pnfdName=[], pnfdInvariantId=[],
 505                               pnfdOnboardingState=[], pnfdUsageState=[],
 506                               links=json.dumps(self.links)).save()
 507         response = self.client.delete('/api/nsd/v1/'
 508                                       'subscriptions/' + self.subscription_id,
 509                                       format='json')
 510         self.assertEqual(status.HTTP_204_NO_CONTENT, response.status_code)
 511
 512     def test_ndsm_delete_subscription_failure(self):
 513         response = self.client.delete('/api/nsd/v1/'
 514                                       'subscriptions/' + self.subscription_id,
 515                                       format='json')
 516         self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
 517
 518     def test_nsdm_delete_subscription_failure_bad_request(self):
 519         response = self.client.delete("/api/nsd/v1/subscriptions/123",
 520                                       format='json')
 521         self.assertEqual(status.HTTP_404_NOT_FOUND, response.status_code)
 522
 523     @mock.patch.object(NsdmSubscription, 'delete_single_subscription')
 524     def test_nsdmsubscription_delete_when_catch_exception(self, mock_create):
 525         mock_create.side_effect = TypeError("Unicode type")
 526         response = self.client.delete('/api/nsd/v1/'
 527                                       'subscriptions/' + self.subscription_id,
 528                                       format='json')
 529         self.assertEqual(response.status_code,
 530                          status.HTTP_500_INTERNAL_SERVER_ERROR)
 531
 532     @mock.patch("requests.post")
 533     @mock.patch.object(toscaparser, 'parse_nsd')
 534     @mock.patch.object(catalog.pub.utils.timeutil, "now_time")
 535     @mock.patch("requests.get")
 536     @mock.patch.object(uuid, 'uuid4')
 537     def test_nsdm_subscribe_trigger_notification(self, mock_uuid4, mock_requests, mock_nowtime, mock_parse_nsd,
 538                                                  mock_requests_post):
 539         mock_requests.return_value.status_code = 204
 540         mock_requests.get.return_value.status_code = 204
 541         mock_uuid4.return_value = "1111"
 542         mock_nowtime.return_value = "nowtime()"
 543
 544         subscription_req = {
 545             "callbackUri": "http://callbackuri.com",
 546             "authentication": {
 547                 "authType": ["BASIC"],
 548                 "paramsBasic": {
 549                     "userName": "username",
 550                     "password": "password"
 551                 }
 552             },
 553             "filter": {
 554                 "nsdId": ["b632bddc-bccd-4180-bd8d-4e8a9578eff7"]
 555             }
 556         }
 557         response = self.client.post("/api/nsd/v1/subscriptions",
 558                                     data=subscription_req, format='json')
 559         self.assertEqual(201, response.status_code)
 560
 561         self.user_defined_data = {
 562             'key1': 'value1',
 563             'key2': 'value2',
 564             'key3': 'value3',
 565         }
 566         user_defined_data_json = json.JSONEncoder().encode(self.user_defined_data)
 567         mock_parse_nsd.return_value = json.JSONEncoder().encode(nsd_data)
 568         VnfPackageModel(
 569             vnfPackageId="111",
 570             vnfdId="vcpe_vfw_zte_1_0"
 571         ).save()
 572
 573         PnfPackageModel(
 574             pnfPackageId="112",
 575             pnfdId="m6000_s"
 576         ).save()
 577
 578         NSPackageModel(
 579             nsPackageId='d0ea5ec3-0b98-438a-9bea-488230cff174',
 580             operationalState='DISABLED',
 581             usageState='NOT_IN_USE',
 582             userDefinedData=user_defined_data_json,
 583         ).save()
 584
 585         with open('nsd_content.txt', 'wt') as fp:
 586             fp.write('test')
 587         with open('nsd_content.txt', 'rt') as fp:
 588             resp = self.client.put(
 589                 "/api/nsd/v1/ns_descriptors/d0ea5ec3-0b98-438a-9bea-488230cff174/nsd_content",
 590                 {'file': fp},
 591             )
 592         file_content = ''
 593         with open(os.path.join(CATALOG_ROOT_PATH, 'd0ea5ec3-0b98-438a-9bea-488230cff174/nsd_content.txt')) as fp:
 594             data = fp.read()
 595             file_content = '%s%s' % (file_content, data)
 596         ns_pkg = NSPackageModel.objects.filter(nsPackageId="d0ea5ec3-0b98-438a-9bea-488230cff174")
 597         self.assertEqual("b632bddc-bccd-4180-bd8d-4e8a9578eff7", ns_pkg[0].nsdId)
 598         self.assertEqual(const.PKG_STATUS.ONBOARDED, ns_pkg[0].onboardingState)
 599         self.assertEqual(resp.status_code, status.HTTP_204_NO_CONTENT)
 600         self.assertEqual(None, resp.data)
 601         self.assertEqual(file_content, 'test')
 602         os.remove('nsd_content.txt')
 603         expect_callbackuri = "http://callbackuri.com"
 604         expect_notification = {
 605             'id': "1111",
 606             'notificationType': const.NSD_NOTIFICATION_TYPE.NSD_ONBOARDING,
 607             'timeStamp': "nowtime()",
 608             'nsdInfoId': "d0ea5ec3-0b98-438a-9bea-488230cff174",
 609             'nsdId': "b632bddc-bccd-4180-bd8d-4e8a9578eff7",
 610             "subscriptionId": "1111",
 611             '_links': {
 612                 'subscription': {
 613                     'href': 'http://%s:%s/%s%s' % (pub_config.MSB_SERVICE_IP,
 614                                                    pub_config.MSB_SERVICE_PORT,
 615                                                    const.NSDM_SUBSCRIPTION_ROOT_URI,
 616                                                    "1111")},
 617                 'nsdInfo': {
 618                     'href': 'http://%s:%s/%s/ns_descriptors/%s' % (pub_config.MSB_SERVICE_IP,
 619                                                                    pub_config.MSB_SERVICE_PORT,
 620                                                                    const.NSD_URL_PREFIX,
 621                                                                    "d0ea5ec3-0b98-438a-9bea-488230cff174")
 622                 }
 623             }
 624         }
 625         mock_requests_post.assert_called_with(expect_callbackuri, data=expect_notification, headers={'Connection': 'close'})
 626
 627
 628 class NotificationTest(TestCase):
 629     def setUp(self):
 630         NsdmSubscriptionModel(subscriptionid="1",
 631                               callback_uri="http://127.0.0.1/self",
 632                               notificationTypes=const.NOTIFICATION_TYPES,
 633                               nsdId="nsdid1",
 634                               nsdInfoId="nsdinfoid1",
 635                               pnfdInfoIds="pnfdInfoIds1",
 636                               pnfdId="pnfdId1"
 637                               ).save()
 638
 639     def tearDown(self):
 640         NsdmSubscriptionModel.objects.all().delete()
 641
 642     @mock.patch("requests.post")
 643     @mock.patch("uuid.uuid4")
 644     @mock.patch.object(catalog.pub.utils.timeutil, "now_time")
 645     def test_nsdpkg_notify(self, mock_nowtime, mock_uuid, mock_requests_post):
 646         mock_nowtime.return_value = "nowtime()"
 647         mock_uuid.return_value = "1111"
 648         notify = NsdNotifications(const.NSD_NOTIFICATION_TYPE.NSD_ONBOARDING_FAILURE,
 649                                   nsd_info_id="nsdinfoid1",
 650                                   nsd_id="nsdid1",
 651                                   failure_details="NSD(nsdid1) already exists.", operational_state=None)
 652         notify.send_notification()
 653         expect_callbackuri = "http://127.0.0.1/self"
 654         expect_notification = {
 655             'id': "1111",
 656             'notificationType': const.NSD_NOTIFICATION_TYPE.NSD_ONBOARDING_FAILURE,
 657             'timeStamp': "nowtime()",
 658             'nsdInfoId': "nsdinfoid1",
 659             'nsdId': "nsdid1",
 660             'onboardingFailureDetails': "NSD(nsdid1) already exists.",
 661             "subscriptionId": "1",
 662             '_links': {
 663                 'subscription': {
 664                     'href': 'http://%s:%s/%s%s' % (pub_config.MSB_SERVICE_IP,
 665                                                    pub_config.MSB_SERVICE_PORT,
 666                                                    const.NSDM_SUBSCRIPTION_ROOT_URI,
 667                                                    "1")},
 668                 'nsdInfo': {
 669                     'href': 'http://%s:%s/%s/ns_descriptors/%s' % (pub_config.MSB_SERVICE_IP,
 670                                                                    pub_config.MSB_SERVICE_PORT,
 671                                                                    const.NSD_URL_PREFIX,
 672                                                                    "nsdinfoid1")
 673                 }
 674             }
 675         }
 676         mock_requests_post.assert_called_with(expect_callbackuri, data=expect_notification, headers={'Connection': 'close'})
 677
 678     @mock.patch("requests.post")
 679     @mock.patch("uuid.uuid4")
 680     @mock.patch.object(catalog.pub.utils.timeutil, "now_time")
 681     def test_pnfpkg_notify(self, mock_nowtime, mock_uuid, mock_requests_post):
 682         mock_nowtime.return_value = "nowtime()"
 683         mock_uuid.return_value = "1111"
 684         notify = PnfNotifications(const.NSD_NOTIFICATION_TYPE.PNFD_ONBOARDING,
 685                                   pnfd_info_id="pnfdInfoIds1",
 686                                   pnfd_id='pnfdId1',
 687                                   failure_details=None)
 688         notify.send_notification()
 689         expect_callbackuri = "http://127.0.0.1/self"
 690         expect_notification = {
 691             'id': "1111",
 692             'notificationType': const.NSD_NOTIFICATION_TYPE.PNFD_ONBOARDING,
 693             'timeStamp': "nowtime()",
 694             'pnfdInfoIds': "pnfdInfoIds1",
 695             'pnfdId': "pnfdId1",
 696             "subscriptionId": "1",
 697             '_links': {
 698                 'subscription': {
 699                     'href': 'http://%s:%s/%s%s' % (pub_config.MSB_SERVICE_IP,
 700                                                    pub_config.MSB_SERVICE_PORT,
 701                                                    const.NSDM_SUBSCRIPTION_ROOT_URI,
 702                                                    "1")},
 703                 'pnfdInfo': {
 704                     'href': 'http://%s:%s/%s/pnf_descriptors/%s' % (pub_config.MSB_SERVICE_IP,
 705                                                                     pub_config.MSB_SERVICE_PORT,
 706                                                                     const.NSD_URL_PREFIX,
 707                                                                     "pnfdInfoIds1")
 708                 }
 709             }
 710         }
 711         mock_requests_post.assert_called_with(expect_callbackuri, data=expect_notification,
 712                                               headers={'Connection': 'close'})