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 import requests
  37 from tornado.platform.asyncio import AsyncIOMainLoop
  38 from tornado.ioloop import IOLoop
  39 from concurrent.futures.thread import ThreadPoolExecutor
  40 from concurrent.futures.process import ProcessPoolExecutor
  41
  42 import gi
  43 gi.require_version('RwDts', '1.0')
  44 gi.require_version('RwPkgMgmtYang', '1.0')
  45 gi.require_version('RwProjectVnfdYang', '1.0')
  46 from gi.repository import (
  47         RwDts as rwdts,
  48         RwPkgMgmtYang,
  49         RwProjectVnfdYang as RwVnfdYang,
  50         )
  51
  52 import rift.tasklets.rwlaunchpad.uploader as uploader
  53 import rift.tasklets.rwlaunchpad.message as message
  54 import rift.tasklets.rwlaunchpad.export as export
  55 import rift.test.dts
  56 import mock
  57
  58 TEST_STRING = "foobar"
  59
  60 class TestCase(rift.test.dts.AbstractDTSTest):
  61     @classmethod
  62     def configure_schema(cls):
  63         return RwPkgMgmtYang.get_schema()
  64
  65     @classmethod
  66     def configure_timeout(cls):
  67         return 240
  68
  69     def configure_test(self, loop, test_id):
  70         self.log.debug("STARTING - %s", test_id)
  71         self.tinfo = self.new_tinfo(str(test_id))
  72         self.dts = rift.tasklets.DTS(self.tinfo, self.schema, self.loop)
  73
  74
  75         mock_vnfd_catalog = mock.MagicMock()
  76         self.uid, path = self.create_mock_package()
  77
  78         mock_vnfd = RwVnfdYang.YangData_RwProject_Project_VnfdCatalog_Vnfd.from_dict({
  79               "id": self.uid
  80             })
  81         mock_vnfd_catalog = {self.uid: mock_vnfd}
  82
  83         self.app = uploader.UploaderApplication(
  84                 self.log,
  85                 self.dts,
  86                 self.loop,
  87                 vnfd_catalog=mock_vnfd_catalog)
  88
  89         AsyncIOMainLoop().install()
  90         self.server = tornado.httpserver.HTTPServer(
  91             self.app,
  92             io_loop=IOLoop.current(),
  93         )
  94
  95     def tearDown(self):
  96         super().tearDown()
  97
  98     def create_mock_package(self):
  99         uid = str(uuid.uuid4())
 100         path = os.path.join(
 101                 os.getenv('RIFT_ARTIFACTS'),
 102                 "launchpad/packages/vnfd",
 103                 uid)
 104
 105         package_path = os.path.join(path, "pong_vnfd")
 106
 107         os.makedirs(package_path)
 108         open(os.path.join(path, "pong_vnfd.xml"), "wb").close()
 109         open(os.path.join(path, "logo.png"), "wb").close()
 110
 111         return uid, path
 112
 113     @rift.test.dts.async_test
 114     def test_package_create_rpc(self):
 115         """
 116             1. Verify the package-create RPC handler
 117             2. Check if the log messages are updated which will be used by UI
 118                 for polling
 119             3. Verify the package-update RPC handler
 120             4. Check if the log messages are updated which will be used by UI
 121                 for polling
 122         """
 123         yield from self.app.register()
 124         ip = RwPkgMgmtYang.YangInput_RwPkgMgmt_PackageCreate.from_dict({
 125                 "package_type": "VNFD",
 126                 "external_url":  "http://repo.riftio.com/releases/open.riftio.com/4.2.1/VNFS/ping_vnfd.tar.gz"
 127                 })
 128
 129         rpc_out = yield from self.dts.query_rpc(
 130                     "I,/rw-pkg-mgmt:package-create",
 131                     rwdts.XactFlag.TRACE,
 132                     ip)
 133
 134         trans_id = None
 135         for itr in rpc_out:
 136             result = yield from itr
 137             trans_id = result.result.transaction_id
 138
 139         assert trans_id is not None
 140
 141         yield from asyncio.sleep(5, loop=self.loop)
 142         # Verify the message logs
 143         data = self.app.messages[trans_id]
 144         assert data is not None
 145         data = data[1]
 146         assert type(data) is message.DownloadSuccess
 147
 148         # Update
 149         ip = RwPkgMgmtYang.YangInput_RwPkgMgmt_PackageUpdate.from_dict({
 150                 "package_type": "VNFD",
 151                 "external_url":  "http://repo.riftio.com/releases/open.riftio.com/4.2.1/VNFS/ping_vnfd.tar.gz"
 152                 })
 153         rpc_out = yield from self.dts.query_rpc(
 154                     "I,/rw-pkg-mgmt:package-update",
 155                     rwdts.XactFlag.TRACE,
 156                     ip)
 157
 158         trans_id = None
 159         for itr in rpc_out:
 160             result = yield from itr
 161             trans_id = result.result.transaction_id
 162
 163         assert trans_id is not None
 164         yield from asyncio.sleep(5, loop=self.loop)
 165         # Verify the message logs
 166         data = self.app.messages[trans_id]
 167         assert data is not None
 168         data = data[1]
 169         assert type(data) is message.DownloadSuccess
 170
 171
 172     @rift.test.dts.async_test
 173     def test_package_export(self):
 174         """
 175             1. Verify if the package export RPC handler work
 176             2. A file is actually generated in the exports dir.
 177         """
 178         yield from self.app.register()
 179         ip = RwPkgMgmtYang.YangInput_RwPkgMgmt_PackageExport.from_dict({
 180                 "package_type": "VNFD",
 181                 "package_id": self.uid
 182                 })
 183
 184         rpc_out = yield from self.dts.query_rpc(
 185                     "I,/rw-pkg-mgmt:package-export",
 186                     rwdts.XactFlag.TRACE,
 187                     ip)
 188
 189         trans_id = None
 190         filename = None
 191         for itr in rpc_out:
 192             result = yield from itr
 193             trans_id = result.result.transaction_id
 194             filename = result.result.filename
 195
 196         assert trans_id is not None
 197
 198         # Verify the message logs
 199         data = self.app.messages[trans_id]
 200         assert data is not None
 201         data = data[-1]
 202         assert type(data) is export.ExportSuccess
 203         path = os.path.join(
 204                 os.getenv("RIFT_ARTIFACTS"),
 205                 "launchpad/exports",
 206                 filename)
 207
 208
 209         print (path)
 210         assert os.path.isfile(path)
 211
 212
 213 def main():
 214     runner = xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"])
 215
 216     parser = argparse.ArgumentParser()
 217     parser.add_argument('-v', '--verbose', action='store_true')
 218     parser.add_argument('-n', '--no-runner', action='store_true')
 219     args, unittest_args = parser.parse_known_args()
 220     if args.no_runner:
 221         runner = None
 222     logging.basicConfig(format='TEST %(message)s')
 223     logging.getLogger().setLevel(logging.DEBUG)
 224
 225
 226     unittest.main(testRunner=runner, argv=[sys.argv[0]] + unittest_args)
 227
 228 if __name__ == '__main__':
 229     main()