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