common/python/test/utest_project.py

   1 #!/usr/bin/env python3
   2
   3 #
   4 #   Copyright 2017 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
  20 import argparse
  21 import asyncio
  22 import logging
  23 import os
  24 import sys
  25 import unittest
  26 import xmlrunner
  27
  28 from rift.mano.utils import project
  29
  30 NAME = 'test'
  31 XPATH = "/rw-project:project[rw-project:name='{}']".format(NAME)
  32
  33 class TestCase(unittest.TestCase):
  34     log = None
  35
  36     @classmethod
  37     def set_logger(cls, log):
  38         cls.log = log
  39
  40     def setUp(self):
  41         if not TestCase.log:
  42             log = logging.getLogger()
  43             log.setLevel( logging.ERROR)
  44
  45     def test_create_from_xpath(self):
  46         """
  47         Asserts:
  48             1. Instance of project from xpath
  49             2. project name in instance is correct
  50         """
  51         proj = project.ManoProject.create_from_xpath(XPATH, TestCase.log)
  52         assert proj
  53         assert NAME == proj.name
  54         assert XPATH == proj.prefix
  55
  56         obj = project.ManoProject.create_from_xpath(proj.prefix, TestCase.log)
  57         assert obj
  58         assert NAME == obj.name
  59         assert XPATH == obj.prefix
  60
  61     def test_create(self):
  62         """
  63         Asserts:
  64             1. Instance of project
  65             2. project name in instance is correct
  66         """
  67         proj = project.ManoProject(TestCase.log, name=NAME)
  68         assert proj
  69         assert NAME == proj.name
  70         assert XPATH == proj.prefix
  71
  72         obj = project.ManoProject.create_from_xpath(proj.prefix, TestCase.log)
  73         assert obj
  74         assert NAME == obj.name
  75         assert XPATH == obj.prefix
  76
  77     def test_create_update(self):
  78         """
  79         Asserts:
  80             1. Instance of project
  81             2. Set project name later
  82             3. project name in instance is correct
  83         """
  84         proj = project.ManoProject(TestCase.log)
  85         assert proj
  86         assert None == proj.name
  87
  88         proj.name = NAME
  89         assert NAME == proj.name
  90         assert XPATH == proj.prefix
  91
  92         try:
  93             proj.name = 'testing'
  94         except project.ManoProjNameSetErr as e:
  95             TestCase.log.debug("Expected exception: {}".format(e))
  96         else:
  97             assert False
  98
  99         obj = project.ManoProject.create_from_xpath(proj.prefix, TestCase.log)
 100         assert obj
 101         assert NAME == obj.name
 102         assert XPATH == obj.prefix
 103
 104     def test_update_from_xpath(self):
 105         """
 106         Asserts:
 107             1. Instance of project
 108             2. Update from XPATH
 109             2. project name in instance is correct
 110         """
 111         proj = project.ManoProject(TestCase.log)
 112         assert proj
 113         assert proj.name is None
 114
 115         proj.set_from_xpath(XPATH)
 116         assert NAME == proj.name
 117         assert XPATH == proj.prefix
 118
 119         try:
 120             proj.set_from_xpath(XPATH)
 121         except project.ManoProjNameSetErr as e:
 122             TestCase.log.debug("Expected exception: {}".format(e))
 123         else:
 124             assert False
 125
 126         obj = project.ManoProject.create_from_xpath(proj.prefix, TestCase.log)
 127         assert obj
 128         assert NAME == obj.name
 129         assert XPATH == obj.prefix
 130
 131     def test_create_from_xpath1(self):
 132         """
 133         Asserts:
 134             1. Instance of project from xpath
 135             2. project name in instance is correct
 136         """
 137         xpath = XPATH + '/rw:project/rw-project:project/rw-project:project/rw-project:project/rw-project:project/project-nsd:nsd-catalog/project-nsd:nsd[id=\'1232334\']'
 138         proj = project.ManoProject.create_from_xpath(xpath, TestCase.log)
 139         assert proj
 140         assert NAME == proj.name
 141         assert XPATH == proj.prefix
 142
 143     def test_create_from_xpath2(self):
 144         """
 145         Asserts:
 146             1. Instance of project from xpath
 147             2. project name in instance is correct
 148         """
 149         xpath = '/rw-project:project [ name = "{}" ]'.format(NAME)
 150         proj = project.ManoProject.create_from_xpath(xpath, TestCase.log)
 151         assert proj
 152         assert NAME == proj.name
 153         assert XPATH == proj.prefix
 154
 155     def test_create_from_xpath_invalid(self):
 156         """
 157         Asserts:
 158             1. Exception due to invalid XPATH format for extracting project
 159         """
 160         xpath = '/'
 161         try:
 162             proj = project.ManoProject.create_from_xpath(xpath, TestCase.log)
 163         except project.ManoProjXpathNoProjErr as e:
 164             TestCase.log.debug("Expected exception: {}".format(e))
 165         else:
 166             assert False
 167
 168     def test_create_from_xpath_invalid1(self):
 169         """
 170         Asserts:
 171             1. Exception due to invalid XPATH format for extracting project
 172         """
 173         xpath = '/rw-project:project/{}'.format(NAME)
 174         try:
 175             proj = project.ManoProject.create_from_xpath(xpath, TestCase.log)
 176         except project.ManoProjXpathKeyErr as e:
 177             TestCase.log.debug("Expected exception: {}".format(e))
 178         else:
 179             assert False
 180
 181     def test_create_from_xpath_invalid2(self):
 182         """
 183         Asserts:
 184             1. Exception due to invalid XPATH format for extracting project
 185         """
 186         xpath = '/rw-project:project[id=test]'
 187         try:
 188             proj = project.ManoProject.create_from_xpath(xpath, TestCase.log)
 189         except project.ManoProjXpathKeyErr as e:
 190             TestCase.log.debug("Expected exception: {}".format(e))
 191         else:
 192             assert False
 193
 194     def tearDown(self):
 195         pass
 196
 197
 198 def main(argv=sys.argv[1:]):
 199     logging.basicConfig(format='TEST %(message)s')
 200
 201     runner = xmlrunner.XMLTestRunner(output=os.environ["RIFT_MODULE_TEST"])
 202     parser = argparse.ArgumentParser()
 203     parser.add_argument('-v', '--verbose', action='store_true')
 204     parser.add_argument('-n', '--no-runner', action='store_true')
 205
 206     args, unknown = parser.parse_known_args(argv)
 207     if args.no_runner:
 208         runner = None
 209
 210     # Set the global logging level
 211     log = logging.getLogger()
 212     log.setLevel(logging.DEBUG if args.verbose else logging.ERROR)
 213     TestCase.set_logger(log)
 214
 215     # The unittest framework requires a program name, so use the name of this
 216     # file instead (we do not want to have to pass a fake program name to main
 217     # when this is called from the interpreter).
 218     unittest.main(argv=[__file__] + unknown + ["-v"], testRunner=runner)
 219
 220 if __name__ == '__main__':
 221     main()