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