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_SERVICE_IP, MSB_SERVICE_PORT
  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 = "https://%s:%s/%s" % (MSB_SERVICE_IP, MSB_SERVICE_PORT,
  96                                               os.path.join(const.VNFPKG_SUBSCRIPTION_ROOT_URI, temp_uuid))
  97         self.assertEqual(redirect_addr, response["Location"])
  98
  99     @mock.patch("requests.get")
 100     def test_callbackuri_same_subscriptions(self, mock_requests):
 101         mock_requests.return_value.status_code = 204
 102         mock_requests.get.status_code = 204
 103         response = self.client.post(
 104             "/api/vnfpkgm/v1/subscriptions",
 105             data=self.vnf_subscription_data,
 106             format='json'
 107         )
 108         self.assertEqual(201, response.status_code)
 109         self.assertEqual(
 110             self.vnf_subscription_data["callbackUri"],
 111             response.data["callbackUri"]
 112         )
 113         newsubs = self.vnf_subscription_data
 114         newsubs["filter"]["vnfdId"] = ["ssss"]
 115         response = self.client.post(
 116             "/api/vnfpkgm/v1/subscriptions",
 117             data=self.vnf_subscription_data,
 118             format='json'
 119         )
 120         self.assertEqual(201, response.status_code)
 121         self.assertEqual(
 122             newsubs["callbackUri"],
 123             response.data["callbackUri"]
 124         )
 125
 126     @mock.patch("requests.get")
 127     @mock.patch.object(uuid, 'uuid4')
 128     def test_get_subscriptions(self, mock_uuid4, mock_requests):
 129         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 130         mock_requests.return_value.status_code = 204
 131         mock_requests.get.status_code = 204
 132         mock_uuid4.return_value = temp_uuid
 133         self.client.post(
 134             "/api/vnfpkgm/v1/subscriptions",
 135             data=self.vnf_subscription_data,
 136             format='json'
 137         )
 138         response = self.client.get(
 139             "/api/vnfpkgm/v1/subscriptions?usageState=IN_USE",
 140             format='json'
 141         )
 142         self.assertEqual(200, response.status_code)
 143         self.assertEqual(1, len(response.data))
 144
 145     @mock.patch("requests.get")
 146     @mock.patch.object(uuid, 'uuid4')
 147     def test_get_subscriptions_with_invalid_params(self, mock_uuid4, mock_requests):
 148         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 149         mock_requests.return_value.status_code = 204
 150         mock_requests.get.status_code = 204
 151         mock_uuid4.return_value = temp_uuid
 152         self.client.post(
 153             "/api/vnfpkgm/v1/subscriptions",
 154             data=self.vnf_subscription_data,
 155             format='json'
 156         )
 157         response = self.client.get(
 158             "/api/vnfpkgm/v1/subscriptions?dummy=dummy",
 159             format='json'
 160         )
 161         self.assertEqual(400, response.status_code)
 162
 163     @mock.patch("requests.get")
 164     @mock.patch.object(uuid, 'uuid4')
 165     def test_get_subscription_with_id(self, mock_uuid4, mock_requests):
 166         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 167         mock_requests.return_value.status_code = 204
 168         mock_requests.get.status_code = 204
 169         mock_uuid4.return_value = temp_uuid
 170         self.client.post(
 171             "/api/vnfpkgm/v1/subscriptions",
 172             data=self.vnf_subscription_data,
 173             format='json'
 174         )
 175         response = self.client.get(
 176             "/api/vnfpkgm/v1/subscriptions/%s" % temp_uuid,
 177             format='json'
 178         )
 179         self.assertEqual(200, response.status_code)
 180         self.assertEqual(temp_uuid, response.data["id"])
 181
 182     @mock.patch("requests.get")
 183     def test_get_subscription_with_id_not_exists(self, mock_requests):
 184         mock_requests.return_value.status_code = 204
 185         mock_requests.get.status_code = 204
 186         self.client.post(
 187             "/api/vnfpkgm/v1/subscriptions",
 188             data=self.vnf_subscription_data,
 189             format='json'
 190         )
 191         response = self.client.get(
 192             "/api/vnfpkgm/v1/subscriptions/111",
 193             format='json'
 194         )
 195         self.assertEqual(404, response.status_code)
 196
 197     @mock.patch("requests.get")
 198     @mock.patch.object(uuid, 'uuid4')
 199     def test_delete_subscription_with_id(self, mock_uuid4, mock_requests):
 200         temp_uuid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 201         dummy_uuid = str(uuid.uuid4())
 202         mock_requests.return_value.status_code = 204
 203         mock_requests.get.status_code = 204
 204         mock_uuid4.return_value = temp_uuid
 205         self.client.post(
 206             "/api/vnfpkgm/v1/subscriptions",
 207             data=self.vnf_subscription_data,
 208             format='json'
 209         )
 210         self.client.get(
 211             "/api/vnfpkgm/v1/subscriptions/%s" % dummy_uuid,
 212             format='json'
 213         )
 214         response = self.client.delete("/api/vnfpkgm/v1/subscriptions/%s" % temp_uuid)
 215         self.assertEqual(204, response.status_code)
 216
 217     def test_delete_subscription_with_id_not_exists(self):
 218         dummy_uuid = str(uuid.uuid4())
 219         response = self.client.delete("/api/vnfpkgm/v1/subscriptions/%s" % dummy_uuid)
 220         self.assertEqual(404, response.status_code)
 221
 222     @mock.patch("requests.get")
 223     @mock.patch.object(toscaparser, 'parse_vnfd')
 224     @mock.patch("requests.post")
 225     @mock.patch("uuid.uuid4")
 226     @mock.patch.object(catalog.pub.utils.timeutil, "now_time")
 227     def test_vnfpkg_subscript_notify(self, mock_nowtime, mock_uuid, mock_requests_post, mock_parse_vnfd,
 228                                      mock_requests_get):
 229         mock_nowtime.return_value = "2019-02-16 14:41:16"
 230         uuid_subscriptid = "99442b18-a5c7-11e8-998c-bf1755941f13"
 231         uuid_vnfPackageId = "3fa85f64-5717-4562-b3fc-2c963f66afa6"
 232         uuid_vnfdid = "00342b18-a5c7-11e8-998c-bf1755941f12"
 233         mock_uuid.side_effect = [uuid_subscriptid, "1111"]
 234         mock_requests_get.return_value.status_code = 204
 235         mock_parse_vnfd.return_value = json.JSONEncoder().encode(vnfd_data)
 236
 237         response = self.client.post(
 238             "/api/vnfpkgm/v1/subscriptions",
 239             data=vnf_subscription_data,
 240             format='json')
 241         self.assertEqual(201, response.status_code)
 242
 243         data = {'file': open(os.path.join(CATALOG_ROOT_PATH, "empty.txt"), "rt")}
 244         VnfPackageModel.objects.create(
 245             vnfPackageId=uuid_vnfPackageId,
 246             onboardingState="CREATED"
 247         )
 248
 249         response = self.client.put("/api/vnfpkgm/v1/vnf_packages/%s/package_content" % uuid_vnfPackageId, data=data)
 250         vnf_pkg = VnfPackageModel.objects.filter(vnfPackageId=uuid_vnfPackageId)
 251         self.assertEqual(uuid_vnfdid, vnf_pkg[0].vnfdId)
 252         self.assertEqual(const.PKG_STATUS.ONBOARDED, vnf_pkg[0].onboardingState)
 253         self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
 254
 255         expect_notification = {
 256             'id': "1111",
 257             'notificationType': const.PKG_NOTIFICATION_TYPE.ONBOARDING,
 258             'timeStamp': "2019-02-16 14:41:16",
 259             'vnfPkgId': uuid_vnfPackageId,
 260             'vnfdId': uuid_vnfdid,
 261             "subscriptionId": uuid_subscriptid,
 262             '_links': {
 263                 'subscription': {
 264                     'href': 'http://%s:%s/%s%s' % (pub_config.MSB_SERVICE_IP,
 265                                                    pub_config.MSB_SERVICE_PORT,
 266                                                    const.VNFPKG_SUBSCRIPTION_ROOT_URI,
 267                                                    uuid_subscriptid)},
 268                 'vnfPackage': {
 269                     'href': 'http://%s:%s/%s/vnf_packages/%s' % (pub_config.MSB_SERVICE_IP,
 270                                                                  pub_config.MSB_SERVICE_PORT,
 271                                                                  const.PKG_URL_PREFIX,
 272                                                                  uuid_vnfPackageId)
 273                 }
 274             }
 275         }
 276         mock_requests_post.assert_called_with(vnf_subscription_data["callbackUri"], data=expect_notification,
 277                                               headers={'Connection': 'close',
 278                                                        'content-type': 'application/json',
 279                                                        'accept': 'application/json'},
 280                                               auth=HTTPBasicAuth("admin", "pwd1234"),
 281                                               verify=False)
 282
 283     def test_service_query_single_subscription_not_found(self):
 284         try:
 285             subscription_id = "test_not_found"
 286             QuerySubscription().query_single_subscription(subscription_id)
 287         except SubscriptionDoesNotExistsException as e:
 288             self.assertEqual("Subscription with ID: %s does not exist" % subscription_id, e.args[0])
 289
 290     def test_service_delete_single_subscription_not_found(self):
 291         try:
 292             subscription_id = "test_not_found"
 293             TerminateSubscription().terminate(subscription_id)
 294         except SubscriptionDoesNotExistsException as e:
 295             self.assertEqual("Subscription with ID: %s does not exist" % subscription_id, e.args[0])
 296
 297
 298 class NotificationTest(TestCase):
 299     def setUp(self):
 300         VnfPackageModel.objects.all().delete()
 301         VnfPkgSubscriptionModel.objects.all().delete()
 302
 303     def tearDown(self):
 304         VnfPackageModel.objects.all().delete()
 305         VnfPkgSubscriptionModel.objects.all().delete()
 306
 307     @mock.patch("requests.post")
 308     @mock.patch("uuid.uuid4")
 309     @mock.patch.object(catalog.pub.utils.timeutil, "now_time")
 310     def test_vnfpkg_manual_notify(self, mock_nowtime, mock_uuid, mock_requests_post):
 311         VnfPackageModel(vnfPackageId="vnfpkgid1",
 312                         vnfdId="vnfdid1"
 313                         ).save()
 314
 315         VnfPkgSubscriptionModel(subscription_id="1",
 316                                 callback_uri="http://127.0.0.1/self",
 317                                 notification_types=const.NOTIFICATION_TYPES,
 318                                 vnfd_id="vnfdid1",
 319                                 vnf_pkg_id="vnfpkgid1"
 320                                 ).save()
 321         mock_nowtime.return_value = "2019-12-16 14:41:16"
 322         mock_uuid.return_value = "1111"
 323         notify = PkgNotifications(const.PKG_NOTIFICATION_TYPE.CHANGE, "vnfpkgid1",
 324                                   const.PKG_CHANGE_TYPE.OP_STATE_CHANGE, operational_state=None)
 325
 326         notify.send_notification()
 327         expect_callbackuri = "http://127.0.0.1/self"
 328         expect_notification = {
 329             'id': "1111",
 330             'notificationType': const.PKG_NOTIFICATION_TYPE.CHANGE,
 331             'timeStamp': "2019-12-16 14:41:16",
 332             'vnfPkgId': "vnfpkgid1",
 333             'vnfdId': "vnfdid1",
 334             'changeType': const.PKG_CHANGE_TYPE.OP_STATE_CHANGE,
 335             'operationalState': None,
 336             "subscriptionId": "1",
 337             '_links': {
 338                 'subscription': {
 339                     'href': 'http://%s:%s/%s%s' % (pub_config.MSB_SERVICE_IP,
 340                                                    pub_config.MSB_SERVICE_PORT,
 341                                                    const.VNFPKG_SUBSCRIPTION_ROOT_URI,
 342                                                    "1")},
 343                 'vnfPackage': {
 344                     'href': 'http://%s:%s/%s/vnf_packages/%s' % (pub_config.MSB_SERVICE_IP,
 345                                                                  pub_config.MSB_SERVICE_PORT,
 346                                                                  const.PKG_URL_PREFIX,
 347                                                                  "vnfpkgid1")
 348                 }
 349             }
 350         }
 351         mock_requests_post.assert_called_with(expect_callbackuri, data=expect_notification,
 352                                               headers={'Connection': 'close',
 353                                                        'content-type': 'application/json',
 354                                                        'accept': 'application/json'},
 355                                               verify=False)