rwlaunchpad/plugins/rwlaunchpadtasklet/test/utest_uploader_app_dts.py

   1 #!/usr/bin/env python3
   2
   3 #
   4 #   Copyright 2016 RIFT.IO Inc
   5 #
   6 #   Licensed under the Apache License, Version 2.0 (the "License");
   7 #   you may not use this file except in compliance with the License.
   8 #   You may obtain a copy of the License at
   9 #
  10 #       http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 #   Unless required by applicable law or agreed to in writing, software
  13 #   distributed under the License is distributed on an "AS IS" BASIS,
  14 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 #   See the License for the specific language governing permissions and
  16 #   limitations under the License.
  17 #
  18
  19 import asyncio
  20 import argparse
  21 import os
  22 import logging
  23
  24 import shutil
  25 import stat
  26 import sys
  27 import unittest
  28 import uuid
  29 import xmlrunner
  30 import tornado
  31 import tornado.escape
  32 import tornado.ioloop
  33 import tornado.web
  34 import tornado.httputil
  35
  36 #Setting RIFT_VAR_ROOT if not already set for unit test execution
  37 if "RIFT_VAR_ROOT" not in os.environ:
  38     os.environ['RIFT_VAR_ROOT'] = os.path.join(os.environ['RIFT_INSTALL'], 'var/rift/unittest')
  39
  40 import requests
  41 from tornado.platform.asyncio import AsyncIOMainLoop
  42 from tornado.ioloop import IOLoop
  43 from concurrent.futures.thread import ThreadPoolExecutor
  44 from concurrent.futures.process import ProcessPoolExecutor
  45
  46 import gi
  47 gi.require_version('RwDts', '1.0')
  48 gi.require_version('RwPkgMgmtYang', '1.0')
  49 gi.require_version('RwProjectVnfdYang', '1.0')
  50 from gi.repository import (
  51         RwDts as rwdts,
  52         RwPkgMgmtYang,
  53         RwProjectVnfdYang as RwVnfdYang,
  54         )
  55
  56 import rift.tasklets.rwlaunchpad.uploader as uploader
  57 import rift.tasklets.rwlaunchpad.message as message
  58 import rift.tasklets.rwlaunchpad.export as export
  59 from rift.mano.utils.project import ManoProject, DEFAULT_PROJECT
  60 import rift.test.dts
  61 import rift.package.store
  62
  63 import mock
  64
  65 TEST_STRING = "foobar"
  66
  67 class TestCase(rift.test.dts.AbstractDTSTest):
  68     @classmethod
  69     def configure_schema(cls):
  70         return RwPkgMgmtYang.get_schema()
  71
  72     @classmethod
  73     def configure_timeout(cls):
  74         return 240
  75
  76     def configure_test(self, loop, test_id):
  77         self.log.debug("STARTING - %s", test_id)
  78         self.tinfo = self.new_tinfo(str(test_id))
  79         self.dts = rift.tasklets.DTS(self.tinfo, self.schema, self.loop)
  80
  81
  82         mock_vnfd_catalog = mock.MagicMock()
  83         self.uid, path = self.create_mock_package(DEFAULT_PROJECT)
  84
  85         mock_vnfd = RwVnfdYang.YangData_RwProject_Project_VnfdCatalog_Vnfd.from_dict({
  86               "id": self.uid
  87             })
  88         mock_vnfd_catalog = {self.uid: mock_vnfd}
  89
  90         class MockTasklet:
  91             def __init__(cls):
  92                 def get_vnfd_catalog(project=DEFAULT_PROJECT):
  93                     return mock_vnfd_catalog
  94
  95                 cls.log = self.log
  96                 cls.loop = self.loop
  97                 cls.dts = self.dts
  98                 cls.get_vnfd_catalog = get_vnfd_catalog
  99                 cls.get_nsd_catalog = None
 100                 cls.project = None
 101             def _get_project(cls, project_name):
 102                 if cls.project is None:
 103                     cls.project = ManoProject(cls.log, project_name)
 104                 return cls.project
 105
 106         vnfd_store = rift.package.store.VnfdPackageFilesystemStore(self.log, project=DEFAULT_PROJECT)
 107         nsd_store = rift.package.store.NsdPackageFilesystemStore(self.log, project=DEFAULT_PROJECT)
 108
 109         self.app = uploader.UploaderApplication(MockTasklet(), vnfd_store=vnfd_store, nsd_store=nsd_store)
 110         self.app.onboarder.get_updated_descriptor = mock.MagicMock(return_value={'vnfd:vnfd':{'name':'mock', 'version':'mock'}})
 111         self.app.onboarder.onboard = mock.MagicMock()
 112         self.app.onboarder.update = mock.MagicMock()
 113
 114         AsyncIOMainLoop().install()
 115         self.server = tornado.httpserver.HTTPServer(
 116             self.app,
 117             io_loop=IOLoop.current(),
 118         )
 119
 120     def tearDown(self):
 121         super().tearDown()
 122
 123     def create_mock_package(self, project):
 124         uid = str(uuid.uuid4())
 125         path = os.path.join(
 126                 os.getenv('RIFT_VAR_ROOT'),
 127                 "launchpad/packages/vnfd",
 128                 project,
 129                 uid)
 130
 131         package_path = os.path.join(path, "pong_vnfd")
 132
 133         os.makedirs(package_path)
 134         open(os.path.join(path, "pong_vnfd.xml"), "wb").close()
 135         open(os.path.join(path, "logo.png"), "wb").close()
 136
 137         return uid, path
 138
 139     @rift.test.dts.async_test
 140     def test_package_create_rpc(self):
 141         """
 142             1. Verify the package-create RPC handler
 143             2. Check if the log messages are updated which will be used by UI
 144                 for polling
 145             3. Verify the package-update RPC handler
 146             4. Check if the log messages are updated which will be used by UI
 147                 for polling
 148         """
 149         yield from self.app.register()
 150         ip = RwPkgMgmtYang.YangInput_RwPkgMgmt_PackageCreate.from_dict({
 151                 "package_type": "VNFD",
 152                 "external_url":  "http://repo.riftio.com/releases/open.riftio.com/4.4.2/ping_vnfd.tar.gz",
 153                 "project_name": DEFAULT_PROJECT
 154                 })
 155
 156         rpc_out = yield from self.dts.query_rpc(
 157                     "I,/rw-pkg-mgmt:package-create",
 158                     rwdts.XactFlag.TRACE,
 159                     ip)
 160
 161         trans_id = None
 162         for itr in rpc_out:
 163             result = yield from itr
 164             trans_id = result.result.transaction_id
 165
 166         assert trans_id is not None
 167
 168         yield from asyncio.sleep(5, loop=self.loop)
 169         # Verify the message logs
 170         data = self.app.messages[trans_id]
 171         assert data is not None
 172         data = data[1]
 173         assert type(data) is message.DownloadSuccess
 174
 175         # Update
 176         ip = RwPkgMgmtYang.YangInput_RwPkgMgmt_PackageUpdate.from_dict({
 177                 "package_type": "VNFD",
 178                 "external_url":  "http://repo.riftio.com/releases/open.riftio.com/4.4.2/ping_vnfd.tar.gz",
 179                 "project_name": DEFAULT_PROJECT
 180                 })
 181         rpc_out = yield from self.dts.query_rpc(
 182                     "I,/rw-pkg-mgmt:package-update",
 183                     rwdts.XactFlag.TRACE,
 184                     ip)
 185
 186         trans_id = None
 187         for itr in rpc_out:
 188             result = yield from itr
 189             trans_id = result.result.transaction_id
 190
 191         assert trans_id is not None
 192         yield from asyncio.sleep(5, loop=self.loop)
 193         # Verify the message logs
 194         data = self.app.messages[trans_id]
 195         assert data is not None
 196         data = data[1]
 197         assert type(data) is message.DownloadSuccess
 198
 199     @rift.test.dts.async_test
 200     def test_package_export(self):
 201         """
 202             1. Verify if the package export RPC handler work
 203             2. A file is actually generated in the exports dir.
 204         """
 205         yield from self.app.register()
 206         ip = RwPkgMgmtYang.YangInput_RwPkgMgmt_PackageExport.from_dict({
 207                 "package_type": "VNFD",
 208                 "package_id": self.uid
 209                 })
 210
 211         rpc_out = yield from self.dts.query_rpc(
 212                     "I,/rw-pkg-mgmt:package-export",
 213                     rwdts.XactFlag.TRACE,
 214                     ip)
 215
 216         trans_id = None
 217         filename = None
 218         for itr in rpc_out:
 219             result = yield from itr
 220             trans_id = result.result.transaction_id
 221             filename = result.result.filename
 222
 223         assert trans_id is not None
 224
 225         # Verify the message logs
 226         data = self.app.messages[trans_id]
 227         assert data is not None
 228         data = data[-1]
 229         assert type(data) is export.ExportSuccess
 230         path = os.path.join(
 231                 os.getenv("RIFT_VAR_ROOT"),
 232                 "launchpad/exports",
 233                 filename)
 234
 235
 236         print (path)
 237         assert os.path.isfile(path)
 238
 239
 240 def main():
 241     runner = xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"])
 242
 243     parser = argparse.ArgumentParser()
 244     parser.add_argument('-v', '--verbose', action='store_true')
 245     parser.add_argument('-n', '--no-runner', action='store_true')
 246     args, unittest_args = parser.parse_known_args()
 247     if args.no_runner:
 248         runner = None
 249     logging.basicConfig(format='TEST %(message)s')
 250     logging.getLogger().setLevel(logging.DEBUG)
 251
 252
 253     unittest.main(testRunner=runner, argv=[sys.argv[0]] + unittest_args)
 254
 255 if __name__ == '__main__':
 256     main()