utils/test/testapi/opnfv_testapi/tests/unit/resources/test_scenario.py

   1 import httplib
   2 import json
   3 import os
   4
   5 import opnfv_testapi.resources.scenario_models as models
   6 from opnfv_testapi.common import message
   7 from opnfv_testapi.tests.unit.resources import test_base as base
   8
   9
  10 class TestScenarioBase(base.TestBase):
  11     def setUp(self):
  12         super(TestScenarioBase, self).setUp()
  13         self.get_res = models.Scenario
  14         self.list_res = models.Scenarios
  15         self.basePath = '/api/v1/scenarios'
  16         self.req_d = self._load_request('scenario-c1.json')
  17         self.req_2 = self._load_request('scenario-c2.json')
  18
  19     def tearDown(self):
  20         pass
  21
  22     def assert_body(self, project, req=None):
  23         pass
  24
  25     @staticmethod
  26     def _load_request(f_req):
  27         abs_file = os.path.join(os.path.dirname(__file__), f_req)
  28         with open(abs_file, 'r') as f:
  29             loader = json.load(f)
  30             f.close()
  31         return loader
  32
  33     def create_return_name(self, req):
  34         _, res = self.create(req)
  35         return res.href.split('/')[-1]
  36
  37     def assert_res(self, code, scenario, req=None):
  38         self.assertEqual(code, httplib.OK)
  39         if req is None:
  40             req = self.req_d
  41         self.assertIsNotNone(scenario._id)
  42         self.assertIsNotNone(scenario.creation_date)
  43
  44         scenario == models.Scenario.from_dict(req)
  45
  46     @staticmethod
  47     def _set_query(*args):
  48         uri = ''
  49         for arg in args:
  50             uri += arg + '&'
  51         return uri[0: -1]
  52
  53     def _get_and_assert(self, name, req=None):
  54         code, body = self.get(name)
  55         self.assert_res(code, body, req)
  56
  57
  58 class TestScenarioCreate(TestScenarioBase):
  59     def test_withoutBody(self):
  60         (code, body) = self.create()
  61         self.assertEqual(code, httplib.BAD_REQUEST)
  62
  63     def test_emptyName(self):
  64         req_empty = models.ScenarioCreateRequest('')
  65         (code, body) = self.create(req_empty)
  66         self.assertEqual(code, httplib.BAD_REQUEST)
  67         self.assertIn(message.missing('name'), body)
  68
  69     def test_noneName(self):
  70         req_none = models.ScenarioCreateRequest(None)
  71         (code, body) = self.create(req_none)
  72         self.assertEqual(code, httplib.BAD_REQUEST)
  73         self.assertIn(message.missing('name'), body)
  74
  75     def test_success(self):
  76         (code, body) = self.create_d()
  77         self.assertEqual(code, httplib.OK)
  78         self.assert_create_body(body)
  79
  80     def test_alreadyExist(self):
  81         self.create_d()
  82         (code, body) = self.create_d()
  83         self.assertEqual(code, httplib.FORBIDDEN)
  84         self.assertIn(message.exist_base, body)
  85
  86
  87 class TestScenarioGet(TestScenarioBase):
  88     def setUp(self):
  89         super(TestScenarioGet, self).setUp()
  90         self.scenario_1 = self.create_return_name(self.req_d)
  91         self.scenario_2 = self.create_return_name(self.req_2)
  92
  93     def test_getByName(self):
  94         self._get_and_assert(self.scenario_1, self.req_d)
  95
  96     def test_getAll(self):
  97         self._query_and_assert(query=None, reqs=[self.req_d, self.req_2])
  98
  99     def test_queryName(self):
 100         query = self._set_query('name=nosdn-nofeature-ha')
 101         self._query_and_assert(query, reqs=[self.req_d])
 102
 103     def test_queryInstaller(self):
 104         query = self._set_query('installer=apex')
 105         self._query_and_assert(query, reqs=[self.req_d])
 106
 107     def test_queryVersion(self):
 108         query = self._set_query('version=master')
 109         self._query_and_assert(query, reqs=[self.req_d])
 110
 111     def test_queryProject(self):
 112         query = self._set_query('project=functest')
 113         self._query_and_assert(query, reqs=[self.req_d, self.req_2])
 114
 115     # close due to random fail, open again after solve it in another patch
 116     # def test_queryCombination(self):
 117     #     query = self._set_query('name=nosdn-nofeature-ha',
 118     #                             'installer=apex',
 119     #                             'version=master',
 120     #                             'project=functest')
 121     #
 122     #     self._query_and_assert(query, reqs=[self.req_d])
 123
 124     def _query_and_assert(self, query, found=True, reqs=None):
 125         code, body = self.query(query)
 126         if not found:
 127             self.assertEqual(code, httplib.OK)
 128             self.assertEqual(0, len(body.scenarios))
 129         else:
 130             self.assertEqual(len(reqs), len(body.scenarios))
 131             for req in reqs:
 132                 for scenario in body.scenarios:
 133                     if req['name'] == scenario.name:
 134                         self.assert_res(code, scenario, req)
 135
 136
 137 class TestScenarioDelete(TestScenarioBase):
 138     def test_notFound(self):
 139         code, body = self.delete('notFound')
 140         self.assertEqual(code, httplib.NOT_FOUND)
 141
 142     def test_success(self):
 143         scenario = self.create_return_name(self.req_d)
 144         code, _ = self.delete(scenario)
 145         self.assertEqual(code, httplib.OK)
 146         code, _ = self.get(scenario)
 147         self.assertEqual(code, httplib.NOT_FOUND)
 148
 149
 150 def _none_default(check, default):
 151     return check if check else default