catalog/packages/tests/test_vnf_pkg_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 os
  17 import uuid
  18
  19 import mock
  20 from django.test import TestCase
  21 from rest_framework import status
  22 from rest_framework.test import APIClient
  23 from requests.auth import HTTPBasicAuth
  24
  25 import catalog.pub.utils.timeutil
  26 from catalog.packages import const
  27 from catalog.packages.biz.notificationsutil import PkgNotifications
  28 from catalog.packages.biz.vnf_pkg_subscription import QuerySubscription, TerminateSubscription
  29 from catalog.pub.config import config as pub_config
  30 from catalog.pub.config.config import CATALOG_ROOT_PATH, MSB_BASE_URL
  31 from catalog.pub.database.models import VnfPkgSubscriptionModel, VnfPackageModel
  32 from catalog.pub.exceptions import SubscriptionDoesNotExistsException
  33 from .const import vnf_subscription_data
  34 from catalog.pub.utils import toscaparser
  35 from catalog.packages.tests.const import vnfd_data
  36
  37
  38 class TestNfPackageSubscription(TestCase):
  39     def setUp(self):
  40         self.client = APIClient()
  41         VnfPkgSubscriptionModel.objects.filter().delete()
  42         self.vnf_subscription_data = vnf_subscription_data
  43
  44     def tearDown(self):
  45         pass
  46
  47     @mock.patch("requests.get")
  48     @mock.patch.object(uuid, 'uuid4')
  49     def test_create_vnf_subscription(self, mock_uuid4, mock_requests):
  50         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
  51         mock_requests.return_value.status_code = 204
  52         mock_requests.get.status_code = 204
  53         mock_uuid4.return_value = temp_uuid
  54         response = self.client.post(
  55             "/api/vnfpkgm/v1/subscriptions",
  56             data=self.vnf_subscription_data,
  57             format='json'
  58         )
  59         self.assertEqual(201, response.status_code)
  60         self.assertEqual(
  61             self.vnf_subscription_data["callbackUri"],
  62             response.data["callbackUri"]
  63         )
  64         self.assertEqual(temp_uuid, response.data["id"])
  65
  66     @mock.patch("requests.get")
  67     @mock.patch.object(uuid, 'uuid4')
  68     def test_duplicate_subscriptions(self, mock_uuid4, mock_requests):
  69         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
  70         temp1_uuid = "00342b18-a5c7-11e8-998c-bf1755941f12"
  71         mock_requests.return_value.status_code = 204
  72         mock_requests.get.status_code = 204
  73         mock_uuid4.side_effect = [temp_uuid, temp1_uuid]
  74         response = self.client.post(
  75             "/api/vnfpkgm/v1/subscriptions",
  76             data=self.vnf_subscription_data,
  77             format='json'
  78         )
  79         self.assertEqual(201, response.status_code)
  80         self.assertEqual(
  81             self.vnf_subscription_data["callbackUri"],
  82             response.data["callbackUri"]
  83         )
  84         self.assertEqual(temp_uuid, response.data["id"])
  85         temp2_uuid = "00442b18-a5c7-11e8-998c-bf1755941f12"
  86         mock_requests.return_value.status_code = 204
  87         mock_requests.get.status_code = 204
  88         mock_uuid4.return_value = temp2_uuid
  89         response = self.client.post(
  90             "/api/vnfpkgm/v1/subscriptions",
  91             data=self.vnf_subscription_data,
  92             format='json'
  93         )
  94         self.assertEqual(303, response.status_code)
  95         redirect_addr = "%s/%s" % (MSB_BASE_URL, os.path.join(const.VNFPKG_SUBSCRIPTION_ROOT_URI, temp_uuid))
  96         self.assertEqual(redirect_addr, response["Location"])
  97
  98     @mock.patch("requests.get")
  99     def test_callbackuri_same_subscriptions(self, mock_requests):
 100         mock_requests.return_value.status_code = 204
 101         mock_requests.get.status_code = 204
 102         response = self.client.post(
 103             "/api/vnfpkgm/v1/subscriptions",
 104             data=self.vnf_subscription_data,
 105             format='json'
 106         )
 107         self.assertEqual(201, response.status_code)
 108         self.assertEqual(
 109             self.vnf_subscription_data["callbackUri"],
 110             response.data["callbackUri"]
 111         )
 112         newsubs = self.vnf_subscription_data
 113         newsubs["filter"]["vnfdId"] = ["ssss"]
 114         response = self.client.post(
 115             "/api/vnfpkgm/v1/subscriptions",
 116             data=self.vnf_subscription_data,
 117             format='json'
 118         )
 119         self.assertEqual(201, response.status_code)
 120         self.assertEqual(
 121             newsubs["callbackUri"],
 122             response.data["callbackUri"]
 123         )
 124
 125     @mock.patch("requests.get")
 126     @mock.patch.object(uuid, 'uuid4')
 127     def test_get_subscriptions(self, mock_uuid4, mock_requests):
 128         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 129         mock_requests.return_value.status_code = 204
 130         mock_requests.get.status_code = 204
 131         mock_uuid4.return_value = temp_uuid
 132         self.client.post(
 133             "/api/vnfpkgm/v1/subscriptions",
 134             data=self.vnf_subscription_data,
 135             format='json'
 136         )
 137         response = self.client.get(
 138             "/api/vnfpkgm/v1/subscriptions?usageState=IN_USE",
 139             format='json'
 140         )
 141         self.assertEqual(200, response.status_code)
 142         self.assertEqual(1, len(response.data))
 143
 144     @mock.patch("requests.get")
 145     @mock.patch.object(uuid, 'uuid4')
 146     def test_get_subscriptions_with_invalid_params(self, mock_uuid4, mock_requests):
 147         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 148         mock_requests.return_value.status_code = 204
 149         mock_requests.get.status_code = 204
 150         mock_uuid4.return_value = temp_uuid
 151         self.client.post(
 152             "/api/vnfpkgm/v1/subscriptions",
 153             data=self.vnf_subscription_data,
 154             format='json'
 155         )
 156         response = self.client.get(
 157             "/api/vnfpkgm/v1/subscriptions?dummy=dummy",
 158             format='json'
 159         )
 160         self.assertEqual(400, response.status_code)
 161
 162     @mock.patch("requests.get")
 163     @mock.patch.object(uuid, 'uuid4')
 164     def test_get_subscription_with_id(self, mock_uuid4, mock_requests):
 165         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 166         mock_requests.return_value.status_code = 204
 167         mock_requests.get.status_code = 204
 168         mock_uuid4.return_value = temp_uuid
 169         self.client.post(
 170             "/api/vnfpkgm/v1/subscriptions",
 171             data=self.vnf_subscription_data,
 172             format='json'
 173         )
 174         response = self.client.get(
 175             "/api/vnfpkgm/v1/subscriptions/%s" % temp_uuid,
 176             format='json'
 177         )
 178         self.assertEqual(200, response.status_code)
 179         self.assertEqual(temp_uuid, response.data["id"])
 180
 181     @mock.patch("requests.get")
 182     def test_get_subscription_with_id_not_exists(self, mock_requests):
 183         mock_requests.return_value.status_code = 204
 184         mock_requests.get.status_code = 204
 185         self.client.post(
 186             "/api/vnfpkgm/v1/subscriptions",
 187             data=self.vnf_subscription_data,
 188             format='json'
 189         )
 190         response = self.client.get(
 191             "/api/vnfpkgm/v1/subscriptions/111",
 192             format='json'
 193         )
 194         self.assertEqual(404, response.status_code)
 195
 196     @mock.patch("requests.get")
 197     @mock.patch.object(uuid, 'uuid4')
 198     def test_delete_subscription_with_id(self, mock_uuid4, mock_requests):
 199         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 200         dummy_uuid = str(uuid.uuid4())
 201         mock_requests.return_value.status_code = 204
 202         mock_requests.get.status_code = 204
 203         mock_uuid4.return_value = temp_uuid
 204         self.client.post(
 205             "/api/vnfpkgm/v1/subscriptions",
 206             data=self.vnf_subscription_data,
 207             format='json'
 208         )
 209         self.client.get(
 210             "/api/vnfpkgm/v1/subscriptions/%s" % dummy_uuid,
 211             format='json'
 212         )
 213         response = self.client.delete("/api/vnfpkgm/v1/subscriptions/%s" % temp_uuid)
 214         self.assertEqual(204, response.status_code)
 215
 216     def test_delete_subscription_with_id_not_exists(self):
 217         dummy_uuid = str(uuid.uuid4())
 218         response = self.client.delete("/api/vnfpkgm/v1/subscriptions/%s" % dummy_uuid)
 219         self.assertEqual(404, response.status_code)
 220
 221     @mock.patch("requests.get")
 222     @mock.patch.object(toscaparser, 'parse_vnfd')
 223     @mock.patch("requests.post")
 224     @mock.patch("uuid.uuid4")
 225     @mock.patch.object(catalog.pub.utils.timeutil, "now_time")
 226     def test_vnfpkg_subscript_notify(self, mock_nowtime, mock_uuid, mock_requests_post, mock_parse_vnfd,
 227                                      mock_requests_get):
 228         mock_nowtime.return_value = "2019-02-16 14:41:16"
 229         uuid_subscriptid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 230         uuid_vnfPackageId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
 231         uuid_vnfdid = "00342b18-a5c7-11e8-998c-bf1755941f12"
 232         mock_uuid.side_effect = [uuid_subscriptid, "1111"]
 233         mock_requests_get.return_value.status_code = 204
 234         mock_parse_vnfd.return_value = json.JSONEncoder().encode(vnfd_data)
 235
 236         response = self.client.post(
 237             "/api/vnfpkgm/v1/subscriptions",
 238             data=vnf_subscription_data,
 239             format='json')
 240         self.assertEqual(201, response.status_code)
 241
 242         data = {'file': open(os.path.join(CATALOG_ROOT_PATH, "empty.txt"), "rt")}
 243         VnfPackageModel.objects.create(
 244             vnfPackageId=uuid_vnfPackageId,
 245             onboardingState="CREATED"
 246         )
 247
 248         response = self.client.put("/api/vnfpkgm/v1/vnf_packages/%s/package_content" % uuid_vnfPackageId, data=data)
 249         vnf_pkg = VnfPackageModel.objects.filter(vnfPackageId=uuid_vnfPackageId)
 250         self.assertEqual(uuid_vnfdid, vnf_pkg[0].vnfdId)
 251         self.assertEqual(const.PKG_STATUS.ONBOARDED, vnf_pkg[0].onboardingState)
 252         self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
 253
 254         expect_notification = {
 255             'id': "1111",
 256             'notificationType': const.PKG_NOTIFICATION_TYPE.ONBOARDING,
 257             'timeStamp': "2019-02-16 14:41:16",
 258             'vnfPkgId': uuid_vnfPackageId,
 259             'vnfdId': uuid_vnfdid,
 260             '_links': {
 261                 'vnfPackage': {
 262                     'href': '%s/%s/vnf_packages/%s' % (pub_config.MSB_BASE_URL, const.PKG_URL_PREFIX, uuid_vnfPackageId)
 263                 },
 264                 'subscription': {
 265                     'href': '%s/%s%s' % (pub_config.MSB_BASE_URL, const.VNFPKG_SUBSCRIPTION_ROOT_URI, uuid_subscriptid)}
 266             },
 267             "subscriptionId": uuid_subscriptid
 268         }
 269         mock_requests_post.assert_called_with(vnf_subscription_data["callbackUri"], data=json.dumps(expect_notification),
 270                                               headers={'Connection': 'close',
 271                                                        'content-type': 'application/json',
 272                                                        'accept': 'application/json'},
 273                                               auth=HTTPBasicAuth("admin", "pwd1234"),
 274                                               verify=False)
 275
 276     def test_service_query_single_subscription_not_found(self):
 277         try:
 278             subscription_id = "test_not_found"
 279             QuerySubscription().query_single_subscription(subscription_id)
 280         except SubscriptionDoesNotExistsException as e:
 281             self.assertEqual("Subscription with ID: %s does not exist" % subscription_id, e.args[0])
 282
 283     def test_service_delete_single_subscription_not_found(self):
 284         try:
 285             subscription_id = "test_not_found"
 286             TerminateSubscription().terminate(subscription_id)
 287         except SubscriptionDoesNotExistsException as e:
 288             self.assertEqual("Subscription with ID: %s does not exist" % subscription_id, e.args[0])
 289
 290
 291 class NotificationTest(TestCase):
 292     def setUp(self):
 293         VnfPackageModel.objects.all().delete()
 294         VnfPkgSubscriptionModel.objects.all().delete()
 295
 296     def tearDown(self):
 297         VnfPackageModel.objects.all().delete()
 298         VnfPkgSubscriptionModel.objects.all().delete()
 299
 300     @mock.patch("requests.post")
 301     @mock.patch("uuid.uuid4")
 302     @mock.patch.object(catalog.pub.utils.timeutil, "now_time")
 303     def test_vnfpkg_manual_notify(self, mock_nowtime, mock_uuid, mock_requests_post):
 304         VnfPackageModel(vnfPackageId="vnfpkgid1",
 305                         vnfdId="vnfdid1"
 306                         ).save()
 307
 308         VnfPkgSubscriptionModel(subscription_id="1",
 309                                 callback_uri="http://127.0.0.1/self",
 310                                 notification_types=const.NOTIFICATION_TYPES,
 311                                 vnfd_id="vnfdid1",
 312                                 vnf_pkg_id="vnfpkgid1"
 313                                 ).save()
 314         mock_nowtime.return_value = "2019-12-16 14:41:16"
 315         mock_uuid.return_value = "1111"
 316         notify = PkgNotifications(const.PKG_NOTIFICATION_TYPE.CHANGE, "vnfpkgid1",
 317                                   const.PKG_CHANGE_TYPE.OP_STATE_CHANGE, operational_state=None)
 318
 319         notify.send_notification()
 320         expect_callbackuri = "http://127.0.0.1/self"
 321         expect_notification = {
 322             'id': "1111",
 323             'notificationType': const.PKG_NOTIFICATION_TYPE.CHANGE,
 324             'timeStamp': "2019-12-16 14:41:16",
 325             'vnfPkgId': "vnfpkgid1",
 326             'vnfdId': "vnfdid1",
 327             '_links': {
 328                 'vnfPackage': {
 329                     'href': '%s/%s/vnf_packages/%s' % (pub_config.MSB_BASE_URL, const.PKG_URL_PREFIX, "vnfpkgid1")
 330                 },
 331                 'subscription': {
 332                     'href': '%s/%s%s' % (pub_config.MSB_BASE_URL, const.VNFPKG_SUBSCRIPTION_ROOT_URI, "1")}
 333             },
 334             'changeType': const.PKG_CHANGE_TYPE.OP_STATE_CHANGE,
 335             'operationalState': None,
 336             "subscriptionId": "1"
 337         }
 338         mock_requests_post.assert_called_with(expect_callbackuri, data=json.dumps(expect_notification),
 339                                               headers={'Connection': 'close',
 340                                                        'content-type': 'application/json',
 341                                                        'accept': 'application/json'},
 342                                               verify=False)