Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 1 | # Copyright (c) 2016 Hewlett-Packard Enterprise Development Company, L.P. |
| 2 | # |
| 3 | # Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| 4 | # use this file except in compliance with the License. You may obtain a copy of |
| 5 | # 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, WITHOUT |
| 11 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 12 | # License for the specific language governing permissions and limitations under |
| 13 | # the License. |
| 14 | |
Masayuki Igawa | 134d9f7 | 2017-02-10 18:05:26 +0900 | [diff] [blame] | 15 | import types |
| 16 | |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 17 | import fixtures |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 18 | import mock |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 19 | import testtools |
| 20 | |
| 21 | from tempest.lib import auth |
| 22 | from tempest.lib import exceptions |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 23 | from tempest.lib.services import clients |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 24 | from tempest.tests import base |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 25 | from tempest.tests.lib import fake_auth_provider |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 26 | from tempest.tests.lib import fake_credentials |
| 27 | |
| 28 | |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 29 | has_attribute = testtools.matchers.MatchesPredicateWithParams( |
| 30 | lambda x, y: hasattr(x, y), '{0} does not have an attribute {1}') |
| 31 | |
| 32 | |
| 33 | class TestClientsFactory(base.TestCase): |
| 34 | |
| 35 | def setUp(self): |
| 36 | super(TestClientsFactory, self).setUp() |
| 37 | self.classes = [] |
| 38 | |
| 39 | def _setup_fake_module(self, class_names=None, extra_dict=None): |
| 40 | class_names = class_names or [] |
| 41 | fake_module = types.ModuleType('fake_service_client') |
| 42 | _dict = {} |
| 43 | # Add fake classes to the fake module |
| 44 | for name in class_names: |
| 45 | _dict[name] = type(name, (object,), {}) |
| 46 | # Store it for assertions |
| 47 | self.classes.append(_dict[name]) |
| 48 | if extra_dict: |
| 49 | _dict[extra_dict] = extra_dict |
| 50 | fake_module.__dict__.update(_dict) |
| 51 | fixture_importlib = self.useFixture(fixtures.MockPatch( |
| 52 | 'importlib.import_module', return_value=fake_module)) |
| 53 | return fixture_importlib.mock |
| 54 | |
| 55 | def test___init___one_class(self): |
| 56 | fake_partial = 'fake_partial' |
| 57 | partial_mock = self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 58 | 'tempest.lib.services.clients.ClientsFactory._get_partial_class', |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 59 | return_value=fake_partial)).mock |
| 60 | class_names = ['FakeServiceClient1'] |
| 61 | mock_importlib = self._setup_fake_module(class_names=class_names) |
| 62 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 63 | params = {'k1': 'v1', 'k2': 'v2'} |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 64 | factory = clients.ClientsFactory('fake_path', class_names, |
| 65 | auth_provider, **params) |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 66 | # Assert module has been imported |
| 67 | mock_importlib.assert_called_once_with('fake_path') |
| 68 | # All attributes have been created |
| 69 | for client in class_names: |
| 70 | self.assertThat(factory, has_attribute(client)) |
| 71 | # Partial have been invoked correctly |
| 72 | partial_mock.assert_called_once_with( |
| 73 | self.classes[0], auth_provider, params) |
| 74 | # Get the clients |
| 75 | for name in class_names: |
| 76 | self.assertEqual(fake_partial, getattr(factory, name)) |
| 77 | |
| 78 | def test___init___two_classes(self): |
| 79 | fake_partial = 'fake_partial' |
| 80 | partial_mock = self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 81 | 'tempest.lib.services.clients.ClientsFactory._get_partial_class', |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 82 | return_value=fake_partial)).mock |
| 83 | class_names = ['FakeServiceClient1', 'FakeServiceClient2'] |
| 84 | mock_importlib = self._setup_fake_module(class_names=class_names) |
| 85 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 86 | params = {'k1': 'v1', 'k2': 'v2'} |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 87 | factory = clients.ClientsFactory('fake_path', class_names, |
| 88 | auth_provider, **params) |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 89 | # Assert module has been imported |
| 90 | mock_importlib.assert_called_once_with('fake_path') |
| 91 | # All attributes have been created |
| 92 | for client in class_names: |
| 93 | self.assertThat(factory, has_attribute(client)) |
| 94 | # Partial have been invoked the right number of times |
| 95 | partial_mock.call_count = len(class_names) |
| 96 | # Get the clients |
| 97 | for name in class_names: |
| 98 | self.assertEqual(fake_partial, getattr(factory, name)) |
| 99 | |
| 100 | def test___init___no_module(self): |
| 101 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 102 | class_names = ['FakeServiceClient1', 'FakeServiceClient2'] |
| 103 | with testtools.ExpectedException(ImportError, '.*fake_module.*'): |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 104 | clients.ClientsFactory('fake_module', class_names, |
| 105 | auth_provider) |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 106 | |
| 107 | def test___init___not_a_class(self): |
| 108 | class_names = ['FakeServiceClient1', 'FakeServiceClient2'] |
| 109 | extended_class_names = class_names + ['not_really_a_class'] |
| 110 | self._setup_fake_module( |
| 111 | class_names=class_names, extra_dict='not_really_a_class') |
| 112 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 113 | expected_msg = '.*not_really_a_class.*str.*' |
| 114 | with testtools.ExpectedException(TypeError, expected_msg): |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 115 | clients.ClientsFactory('fake_module', extended_class_names, |
| 116 | auth_provider) |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 117 | |
| 118 | def test___init___class_not_found(self): |
| 119 | class_names = ['FakeServiceClient1', 'FakeServiceClient2'] |
| 120 | extended_class_names = class_names + ['not_really_a_class'] |
| 121 | self._setup_fake_module(class_names=class_names) |
| 122 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 123 | expected_msg = '.*not_really_a_class.*fake_service_client.*' |
| 124 | with testtools.ExpectedException(AttributeError, expected_msg): |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 125 | clients.ClientsFactory('fake_module', extended_class_names, |
| 126 | auth_provider) |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 127 | |
| 128 | def test__get_partial_class_no_later_kwargs(self): |
| 129 | expected_fake_client = 'not_really_a_client' |
| 130 | self._setup_fake_module(class_names=[]) |
| 131 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 132 | params = {'k1': 'v1', 'k2': 'v2'} |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 133 | factory = clients.ClientsFactory( |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 134 | 'fake_path', [], auth_provider, **params) |
| 135 | klass_mock = mock.Mock(return_value=expected_fake_client) |
| 136 | partial = factory._get_partial_class(klass_mock, auth_provider, params) |
| 137 | # Class has not be initialised yet |
| 138 | klass_mock.assert_not_called() |
| 139 | # Use partial and assert on parameters |
| 140 | client = partial() |
| 141 | self.assertEqual(expected_fake_client, client) |
| 142 | klass_mock.assert_called_once_with(auth_provider=auth_provider, |
| 143 | **params) |
| 144 | |
| 145 | def test__get_partial_class_later_kwargs(self): |
| 146 | expected_fake_client = 'not_really_a_client' |
| 147 | self._setup_fake_module(class_names=[]) |
| 148 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 149 | params = {'k1': 'v1', 'k2': 'v2'} |
| 150 | later_params = {'k2': 'v4', 'k3': 'v3'} |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 151 | factory = clients.ClientsFactory( |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 152 | 'fake_path', [], auth_provider, **params) |
| 153 | klass_mock = mock.Mock(return_value=expected_fake_client) |
| 154 | partial = factory._get_partial_class(klass_mock, auth_provider, params) |
| 155 | # Class has not be initialised yet |
| 156 | klass_mock.assert_not_called() |
| 157 | # Use partial and assert on parameters |
| 158 | client = partial(**later_params) |
| 159 | params.update(later_params) |
| 160 | self.assertEqual(expected_fake_client, client) |
| 161 | klass_mock.assert_called_once_with(auth_provider=auth_provider, |
| 162 | **params) |
| 163 | |
Andrea Frittoli (andreaf) | f9d9a9d | 2016-06-30 17:35:38 +0100 | [diff] [blame] | 164 | def test__get_partial_class_with_alias(self): |
| 165 | expected_fake_client = 'not_really_a_client' |
| 166 | client_alias = 'fake_client' |
| 167 | self._setup_fake_module(class_names=[]) |
| 168 | auth_provider = fake_auth_provider.FakeAuthProvider() |
| 169 | params = {'k1': 'v1', 'k2': 'v2'} |
| 170 | later_params = {'k2': 'v4', 'k3': 'v3'} |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 171 | factory = clients.ClientsFactory( |
Andrea Frittoli (andreaf) | f9d9a9d | 2016-06-30 17:35:38 +0100 | [diff] [blame] | 172 | 'fake_path', [], auth_provider, **params) |
| 173 | klass_mock = mock.Mock(return_value=expected_fake_client) |
| 174 | partial = factory._get_partial_class(klass_mock, auth_provider, params) |
| 175 | # Class has not be initialised yet |
| 176 | klass_mock.assert_not_called() |
| 177 | # Use partial and assert on parameters |
| 178 | client = partial(alias=client_alias, **later_params) |
| 179 | params.update(later_params) |
| 180 | self.assertEqual(expected_fake_client, client) |
| 181 | klass_mock.assert_called_once_with(auth_provider=auth_provider, |
| 182 | **params) |
| 183 | self.assertThat(factory, has_attribute(client_alias)) |
| 184 | self.assertEqual(expected_fake_client, getattr(factory, client_alias)) |
| 185 | |
Andrea Frittoli (andreaf) | 73dd51d | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 186 | |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 187 | class TestServiceClients(base.TestCase): |
| 188 | |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 189 | def setUp(self): |
| 190 | super(TestServiceClients, self).setUp() |
| 191 | self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 192 | 'tempest.lib.services.clients.tempest_modules', return_value={})) |
Andrea Frittoli (andreaf) | 40c9d6b | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 193 | self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 194 | 'tempest.lib.services.clients._tempest_internal_modules', |
Andrea Frittoli (andreaf) | 40c9d6b | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 195 | return_value=set(['fake_service1']))) |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 196 | |
| 197 | def test___init___creds_v2_uri(self): |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 198 | # Verify that no API request is made, since no mock |
| 199 | # is required to run the test successfully |
| 200 | creds = fake_credentials.FakeKeystoneV2Credentials() |
| 201 | uri = 'fake_uri' |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 202 | _manager = clients.ServiceClients(creds, identity_uri=uri) |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 203 | self.assertIsInstance(_manager.auth_provider, |
| 204 | auth.KeystoneV2AuthProvider) |
| 205 | |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 206 | def test___init___creds_v3_uri(self): |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 207 | # Verify that no API request is made, since no mock |
| 208 | # is required to run the test successfully |
| 209 | creds = fake_credentials.FakeKeystoneV3Credentials() |
| 210 | uri = 'fake_uri' |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 211 | _manager = clients.ServiceClients(creds, identity_uri=uri) |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 212 | self.assertIsInstance(_manager.auth_provider, |
| 213 | auth.KeystoneV3AuthProvider) |
| 214 | |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 215 | def test___init___base_creds_uri(self): |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 216 | creds = fake_credentials.FakeCredentials() |
| 217 | uri = 'fake_uri' |
| 218 | with testtools.ExpectedException(exceptions.InvalidCredentials): |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 219 | clients.ServiceClients(creds, identity_uri=uri) |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 220 | |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 221 | def test___init___invalid_creds_uri(self): |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 222 | creds = fake_credentials.FakeKeystoneV2Credentials() |
| 223 | delattr(creds, 'username') |
| 224 | uri = 'fake_uri' |
| 225 | with testtools.ExpectedException(exceptions.InvalidCredentials): |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 226 | clients.ServiceClients(creds, identity_uri=uri) |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 227 | |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 228 | def test___init___creds_uri_none(self): |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 229 | creds = fake_credentials.FakeKeystoneV2Credentials() |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 230 | msg = ("Invalid Credentials\nDetails: ServiceClients requires a " |
| 231 | "non-empty") |
Andrea Frittoli (andreaf) | 2395014 | 2016-06-13 12:39:29 +0100 | [diff] [blame] | 232 | with testtools.ExpectedException(exceptions.InvalidCredentials, |
| 233 | value_re=msg): |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 234 | clients.ServiceClients(creds, None) |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 235 | |
| 236 | def test___init___creds_uri_params(self): |
| 237 | creds = fake_credentials.FakeKeystoneV2Credentials() |
| 238 | expeted_params = {'fake_param1': 'fake_value1', |
| 239 | 'fake_param2': 'fake_value2'} |
| 240 | params = {'fake_service1': expeted_params} |
| 241 | uri = 'fake_uri' |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 242 | _manager = clients.ServiceClients(creds, identity_uri=uri, |
| 243 | client_parameters=params) |
Joe H. Rahme | a72f2c6 | 2016-07-11 16:28:19 +0200 | [diff] [blame] | 244 | self.assertIn('fake_service1', _manager.parameters) |
| 245 | for _key in expeted_params: |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 246 | self.assertIn(_key, _manager.parameters['fake_service1'].keys()) |
| 247 | self.assertEqual(expeted_params[_key], |
| 248 | _manager.parameters['fake_service1'].get(_key)) |
| 249 | |
| 250 | def test___init___creds_uri_params_unknown_services(self): |
| 251 | creds = fake_credentials.FakeKeystoneV2Credentials() |
| 252 | fake_params = {'fake_param1': 'fake_value1'} |
| 253 | params = {'unknown_service1': fake_params, |
| 254 | 'unknown_service2': fake_params} |
| 255 | uri = 'fake_uri' |
| 256 | msg = "(?=.*{0})(?=.*{1})".format(*list(params.keys())) |
| 257 | with testtools.ExpectedException( |
| 258 | exceptions.UnknownServiceClient, value_re=msg): |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 259 | clients.ServiceClients(creds, identity_uri=uri, |
| 260 | client_parameters=params) |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 261 | |
| 262 | def _get_manager(self, init_region='fake_region'): |
| 263 | # Get a manager to invoke _setup_parameters on |
| 264 | creds = fake_credentials.FakeKeystoneV2Credentials() |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 265 | return clients.ServiceClients(creds, identity_uri='fake_uri', |
| 266 | region=init_region) |
Andrea Frittoli (andreaf) | de5fb0c | 2016-06-13 12:15:00 +0100 | [diff] [blame] | 267 | |
| 268 | def test__setup_parameters_none_no_region(self): |
| 269 | kwargs = {} |
| 270 | _manager = self._get_manager(init_region=None) |
| 271 | _params = _manager._setup_parameters(kwargs) |
| 272 | self.assertNotIn('region', _params) |
| 273 | |
| 274 | def test__setup_parameters_none(self): |
| 275 | kwargs = {} |
| 276 | _manager = self._get_manager() |
| 277 | _params = _manager._setup_parameters(kwargs) |
| 278 | self.assertIn('region', _params) |
| 279 | self.assertEqual('fake_region', _params['region']) |
| 280 | |
| 281 | def test__setup_parameters_all(self): |
| 282 | expected_params = {'region': 'fake_region1', |
| 283 | 'catalog_type': 'fake_service2_mod', |
| 284 | 'fake_param1': 'fake_value1', |
| 285 | 'fake_param2': 'fake_value2'} |
| 286 | _manager = self._get_manager() |
| 287 | _params = _manager._setup_parameters(expected_params) |
| 288 | for _key in _params.keys(): |
| 289 | self.assertEqual(expected_params[_key], |
| 290 | _params[_key]) |
Andrea Frittoli (andreaf) | 6d4d85a | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 291 | |
| 292 | def test_register_service_client_module(self): |
Andrea Frittoli (andreaf) | 6d4d85a | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 293 | expected_params = {'fake_param1': 'fake_value1', |
| 294 | 'fake_param2': 'fake_value2'} |
| 295 | _manager = self._get_manager(init_region='fake_region_default') |
Andrea Frittoli (andreaf) | f2affcc | 2016-06-28 21:41:47 +0100 | [diff] [blame] | 296 | # Mock after the _manager is setup to preserve the call count |
| 297 | factory_mock = self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 298 | 'tempest.lib.services.clients.ClientsFactory')).mock |
Andrea Frittoli (andreaf) | 6d4d85a | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 299 | _manager.register_service_client_module( |
| 300 | name='fake_module', |
| 301 | service_version='fake_service', |
| 302 | module_path='fake.path.to.module', |
| 303 | client_names=[], |
| 304 | **expected_params) |
| 305 | self.assertThat(_manager, has_attribute('fake_module')) |
| 306 | # Assert called once, without check for exact parameters |
| 307 | self.assertTrue(factory_mock.called) |
| 308 | self.assertEqual(1, factory_mock.call_count) |
| 309 | # Assert expected params are in with their values |
| 310 | actual_kwargs = factory_mock.call_args[1] |
| 311 | self.assertIn('region', actual_kwargs) |
| 312 | self.assertEqual('fake_region_default', actual_kwargs['region']) |
| 313 | for param in expected_params: |
| 314 | self.assertIn(param, actual_kwargs) |
| 315 | self.assertEqual(expected_params[param], actual_kwargs[param]) |
| 316 | # Assert the new service is registered |
| 317 | self.assertIn('fake_service', _manager._registered_services) |
| 318 | |
| 319 | def test_register_service_client_module_override_default(self): |
Andrea Frittoli (andreaf) | 6d4d85a | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 320 | new_region = 'new_region' |
| 321 | expected_params = {'fake_param1': 'fake_value1', |
| 322 | 'fake_param2': 'fake_value2', |
| 323 | 'region': new_region} |
| 324 | _manager = self._get_manager(init_region='fake_region_default') |
Andrea Frittoli (andreaf) | f2affcc | 2016-06-28 21:41:47 +0100 | [diff] [blame] | 325 | # Mock after the _manager is setup to preserve the call count |
| 326 | factory_mock = self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 327 | 'tempest.lib.services.clients.ClientsFactory')).mock |
Andrea Frittoli (andreaf) | 6d4d85a | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 328 | _manager.register_service_client_module( |
| 329 | name='fake_module', |
| 330 | service_version='fake_service', |
| 331 | module_path='fake.path.to.module', |
| 332 | client_names=[], |
| 333 | **expected_params) |
| 334 | self.assertThat(_manager, has_attribute('fake_module')) |
| 335 | # Assert called once, without check for exact parameters |
| 336 | self.assertTrue(factory_mock.called) |
| 337 | self.assertEqual(1, factory_mock.call_count) |
| 338 | # Assert expected params are in with their values |
| 339 | actual_kwargs = factory_mock.call_args[1] |
| 340 | self.assertIn('region', actual_kwargs) |
| 341 | self.assertEqual(new_region, actual_kwargs['region']) |
| 342 | for param in expected_params: |
| 343 | self.assertIn(param, actual_kwargs) |
| 344 | self.assertEqual(expected_params[param], actual_kwargs[param]) |
| 345 | # Assert the new service is registered |
| 346 | self.assertIn('fake_service', _manager._registered_services) |
| 347 | |
| 348 | def test_register_service_client_module_duplicate_name(self): |
| 349 | self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 350 | 'tempest.lib.services.clients.ClientsFactory')).mock |
Andrea Frittoli (andreaf) | 6d4d85a | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 351 | _manager = self._get_manager() |
| 352 | name_owner = 'this_is_a_string' |
| 353 | setattr(_manager, 'fake_module', name_owner) |
| 354 | expected_error = '.*' + name_owner |
| 355 | with testtools.ExpectedException( |
| 356 | exceptions.ServiceClientRegistrationException, expected_error): |
| 357 | _manager.register_service_client_module( |
| 358 | name='fake_module', module_path='fake.path.to.module', |
| 359 | service_version='fake_service', client_names=[]) |
| 360 | |
| 361 | def test_register_service_client_module_duplicate_service(self): |
| 362 | self.useFixture(fixtures.MockPatch( |
Andrea Frittoli (andreaf) | e07579c | 2016-08-05 07:27:02 +0100 | [diff] [blame] | 363 | 'tempest.lib.services.clients.ClientsFactory')).mock |
Andrea Frittoli (andreaf) | 6d4d85a | 2016-06-21 17:20:31 +0100 | [diff] [blame] | 364 | _manager = self._get_manager() |
| 365 | duplicate_service = 'fake_service1' |
| 366 | expected_error = '.*' + duplicate_service |
| 367 | with testtools.ExpectedException( |
| 368 | exceptions.ServiceClientRegistrationException, expected_error): |
| 369 | _manager.register_service_client_module( |
| 370 | name='fake_module', module_path='fake.path.to.module', |
| 371 | service_version=duplicate_service, client_names=[]) |