Gitiles
Code Review Sign In
spfactory.storpool.com / tempest / c307420dc580757d5fbaa99489da0cfb9de09f81 / . / tempest / tests / cmd / test_verify_tempest_config.py
blob: 9df07a160f89be533503e44f9be1b70496c6dd4a [file] [log] [blame]
Matthew Treinish9b896242014-04-23 21:25:27 +0000[diff] [blame]1# Copyright 2014 IBM Corp.
2#
3# Licensed under the Apache License, Version 2.0 (the "License"); you may
4# not use this file except in compliance with the License. You may obtain
5# a copy of 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
13# under the License.
14
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]15
16import mock
Matthew Treinish21905512015-07-13 10:33:35 -0400[diff] [blame]17from oslo_serialization import jsonutils as json
Doug Hellmann583ce2c2015-03-11 14:55:46 +0000[diff] [blame]18from oslotest import mockpatch
Matthew Treinish9b896242014-04-23 21:25:27 +0000[diff] [blame]19
20from tempest.cmd import verify_tempest_config
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]21from tempest import config
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]22from tempest.tests import fake_config
Jordan Pittier41129042016-03-29 21:21:16 +0200[diff] [blame]23from tempest.tests.lib import base
Matthew Treinish9b896242014-04-23 21:25:27 +0000[diff] [blame]24
25
26class TestGetAPIVersions(base.TestCase):
27
28 def test_url_grab_versioned_nova_nossl(self):
29 base_url = 'http://127.0.0.1:8774/v2/'
30 endpoint = verify_tempest_config._get_unversioned_endpoint(base_url)
31 self.assertEqual('http://127.0.0.1:8774', endpoint)
32
33 def test_url_grab_versioned_nova_ssl(self):
34 base_url = 'https://127.0.0.1:8774/v3/'
35 endpoint = verify_tempest_config._get_unversioned_endpoint(base_url)
36 self.assertEqual('https://127.0.0.1:8774', endpoint)
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]37
38
39class TestDiscovery(base.TestCase):
40
41 def setUp(self):
42 super(TestDiscovery, self).setUp()
43 self.useFixture(fake_config.ConfigFixture())
44 self.stubs.Set(config, 'TempestConfigPrivate', fake_config.FakePrivate)
45
46 def test_get_keystone_api_versions(self):
47 self.useFixture(mockpatch.PatchObject(
48 verify_tempest_config, '_get_unversioned_endpoint',
49 return_value='http://fake_endpoint:5000'))
50 fake_resp = {'versions': {'values': [{'id': 'v2.0'}, {'id': 'v3.0'}]}}
51 fake_resp = json.dumps(fake_resp)
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]52 self.useFixture(mockpatch.Patch(
53 'tempest.lib.common.http.ClosingHttp.request',
54 return_value=(None, fake_resp)))
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]55 fake_os = mock.MagicMock()
56 versions = verify_tempest_config._get_api_versions(fake_os, 'keystone')
57 self.assertIn('v2.0', versions)
58 self.assertIn('v3.0', versions)
59
60 def test_get_cinder_api_versions(self):
61 self.useFixture(mockpatch.PatchObject(
62 verify_tempest_config, '_get_unversioned_endpoint',
63 return_value='http://fake_endpoint:5000'))
64 fake_resp = {'versions': [{'id': 'v1.0'}, {'id': 'v2.0'}]}
65 fake_resp = json.dumps(fake_resp)
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]66 self.useFixture(mockpatch.Patch(
67 'tempest.lib.common.http.ClosingHttp.request',
68 return_value=(None, fake_resp)))
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]69 fake_os = mock.MagicMock()
70 versions = verify_tempest_config._get_api_versions(fake_os, 'cinder')
71 self.assertIn('v1.0', versions)
72 self.assertIn('v2.0', versions)
73
74 def test_get_nova_versions(self):
75 self.useFixture(mockpatch.PatchObject(
76 verify_tempest_config, '_get_unversioned_endpoint',
77 return_value='http://fake_endpoint:5000'))
78 fake_resp = {'versions': [{'id': 'v2.0'}, {'id': 'v3.0'}]}
79 fake_resp = json.dumps(fake_resp)
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]80 self.useFixture(mockpatch.Patch(
81 'tempest.lib.common.http.ClosingHttp.request',
82 return_value=(None, fake_resp)))
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]83 fake_os = mock.MagicMock()
84 versions = verify_tempest_config._get_api_versions(fake_os, 'nova')
85 self.assertIn('v2.0', versions)
86 self.assertIn('v3.0', versions)
87
Brant Knudson5a59f872016-03-18 13:07:00 -0500[diff] [blame]88 def test_get_versions_invalid_response(self):
89 # When the response doesn't contain a JSON response, an error is
90 # logged.
91 mock_log_error = self.useFixture(mockpatch.PatchObject(
92 verify_tempest_config.LOG, 'error')).mock
93
94 self.useFixture(mockpatch.PatchObject(
95 verify_tempest_config, '_get_unversioned_endpoint'))
96
97 # Simulated response is not JSON.
98 sample_body = (
99 '<html><head>Sample Response</head><body>This is the sample page '
100 'for the web server. Why are you requesting it?</body></html>')
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]101 self.useFixture(mockpatch.Patch(
102 'tempest.lib.common.http.ClosingHttp.request',
103 return_value=(None, sample_body)))
Brant Knudson5a59f872016-03-18 13:07:00 -0500[diff] [blame]104
105 # service value doesn't matter, just needs to match what
106 # _get_api_versions puts in its client_dict.
107 self.assertRaises(ValueError, verify_tempest_config._get_api_versions,
108 os=mock.MagicMock(), service='keystone')
109 self.assertTrue(mock_log_error.called)
110
Adam Gandelman03af5562014-10-07 12:22:48 -0700[diff] [blame]111 def test_verify_api_versions(self):
Ken'ichi Ohmichia58c1562014-12-15 00:39:55 +0000[diff] [blame]112 api_services = ['cinder', 'glance', 'keystone']
Adam Gandelman03af5562014-10-07 12:22:48 -0700[diff] [blame]113 fake_os = mock.MagicMock()
114 for svc in api_services:
115 m = 'verify_%s_api_versions' % svc
116 with mock.patch.object(verify_tempest_config, m) as verify_mock:
117 verify_tempest_config.verify_api_versions(fake_os, svc, True)
118 verify_mock.assert_called_once_with(fake_os, True)
119
120 def test_verify_api_versions_not_implemented(self):
Ken'ichi Ohmichia58c1562014-12-15 00:39:55 +0000[diff] [blame]121 api_services = ['cinder', 'glance', 'keystone']
Adam Gandelman03af5562014-10-07 12:22:48 -0700[diff] [blame]122 fake_os = mock.MagicMock()
123 for svc in api_services:
124 m = 'verify_%s_api_versions' % svc
125 with mock.patch.object(verify_tempest_config, m) as verify_mock:
126 verify_tempest_config.verify_api_versions(fake_os, 'foo', True)
127 self.assertFalse(verify_mock.called)
128
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]129 @mock.patch('tempest.lib.common.http.ClosingHttp.request')
130 def test_verify_keystone_api_versions_no_v3(self, mock_request):
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]131 self.useFixture(mockpatch.PatchObject(
132 verify_tempest_config, '_get_unversioned_endpoint',
133 return_value='http://fake_endpoint:5000'))
134 fake_resp = {'versions': {'values': [{'id': 'v2.0'}]}}
135 fake_resp = json.dumps(fake_resp)
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]136 mock_request.return_value = (None, fake_resp)
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]137 fake_os = mock.MagicMock()
138 with mock.patch.object(verify_tempest_config,
139 'print_and_or_update') as print_mock:
140 verify_tempest_config.verify_keystone_api_versions(fake_os, True)
141 print_mock.assert_called_once_with('api_v3',
Nikita Gerasimov35fbdc12015-08-07 19:58:24 +0300[diff] [blame]142 'identity-feature-enabled',
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]143 False, True)
144
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]145 @mock.patch('tempest.lib.common.http.ClosingHttp.request')
146 def test_verify_keystone_api_versions_no_v2(self, mock_request):
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]147 self.useFixture(mockpatch.PatchObject(
148 verify_tempest_config, '_get_unversioned_endpoint',
149 return_value='http://fake_endpoint:5000'))
150 fake_resp = {'versions': {'values': [{'id': 'v3.0'}]}}
151 fake_resp = json.dumps(fake_resp)
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]152 mock_request.return_value = (None, fake_resp)
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]153 fake_os = mock.MagicMock()
154 with mock.patch.object(verify_tempest_config,
155 'print_and_or_update') as print_mock:
156 verify_tempest_config.verify_keystone_api_versions(fake_os, True)
157 print_mock.assert_called_once_with('api_v2',
Nikita Gerasimov35fbdc12015-08-07 19:58:24 +0300[diff] [blame]158 'identity-feature-enabled',
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]159 False, True)
160
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]161 @mock.patch('tempest.lib.common.http.ClosingHttp.request')
162 def test_verify_cinder_api_versions_no_v2(self, mock_request):
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]163 self.useFixture(mockpatch.PatchObject(
164 verify_tempest_config, '_get_unversioned_endpoint',
165 return_value='http://fake_endpoint:5000'))
166 fake_resp = {'versions': [{'id': 'v1.0'}]}
167 fake_resp = json.dumps(fake_resp)
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]168 mock_request.return_value = (None, fake_resp)
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]169 fake_os = mock.MagicMock()
170 with mock.patch.object(verify_tempest_config,
171 'print_and_or_update') as print_mock:
172 verify_tempest_config.verify_cinder_api_versions(fake_os, True)
Nikita Gerasimov35fbdc12015-08-07 19:58:24 +0300[diff] [blame]173 print_mock.assert_called_once_with('api_v2', 'volume-feature-enabled',
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]174 False, True)
175
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]176 @mock.patch('tempest.lib.common.http.ClosingHttp.request')
177 def test_verify_cinder_api_versions_no_v1(self, mock_request):
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]178 self.useFixture(mockpatch.PatchObject(
179 verify_tempest_config, '_get_unversioned_endpoint',
180 return_value='http://fake_endpoint:5000'))
181 fake_resp = {'versions': [{'id': 'v2.0'}]}
182 fake_resp = json.dumps(fake_resp)
Jordan Pittier00f25962016-03-18 17:10:07 +0100[diff] [blame]183 mock_request.return_value = (None, fake_resp)
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]184 fake_os = mock.MagicMock()
185 with mock.patch.object(verify_tempest_config,
186 'print_and_or_update') as print_mock:
187 verify_tempest_config.verify_cinder_api_versions(fake_os, True)
Nikita Gerasimov35fbdc12015-08-07 19:58:24 +0300[diff] [blame]188 print_mock.assert_called_once_with('api_v1', 'volume-feature-enabled',
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]189 False, True)
190
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]191 def test_verify_glance_version_no_v2_with_v1_1(self):
192 def fake_get_versions():
David Kranz0df154d2015-06-02 17:02:27 -0400[diff] [blame]193 return (None, ['v1.1'])
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]194 fake_os = mock.MagicMock()
195 fake_os.image_client.get_versions = fake_get_versions
196 with mock.patch.object(verify_tempest_config,
197 'print_and_or_update') as print_mock:
198 verify_tempest_config.verify_glance_api_versions(fake_os, True)
Nikita Gerasimov35fbdc12015-08-07 19:58:24 +0300[diff] [blame]199 print_mock.assert_called_once_with('api_v2', 'image-feature-enabled',
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]200 False, True)
201
202 def test_verify_glance_version_no_v2_with_v1_0(self):
203 def fake_get_versions():
David Kranz0df154d2015-06-02 17:02:27 -0400[diff] [blame]204 return (None, ['v1.0'])
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]205 fake_os = mock.MagicMock()
206 fake_os.image_client.get_versions = fake_get_versions
207 with mock.patch.object(verify_tempest_config,
208 'print_and_or_update') as print_mock:
209 verify_tempest_config.verify_glance_api_versions(fake_os, True)
Nikita Gerasimov35fbdc12015-08-07 19:58:24 +0300[diff] [blame]210 print_mock.assert_called_once_with('api_v2', 'image-feature-enabled',
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]211 False, True)
212
213 def test_verify_glance_version_no_v1(self):
214 def fake_get_versions():
David Kranz0df154d2015-06-02 17:02:27 -0400[diff] [blame]215 return (None, ['v2.0'])
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]216 fake_os = mock.MagicMock()
217 fake_os.image_client.get_versions = fake_get_versions
218 with mock.patch.object(verify_tempest_config,
219 'print_and_or_update') as print_mock:
220 verify_tempest_config.verify_glance_api_versions(fake_os, True)
Nikita Gerasimov35fbdc12015-08-07 19:58:24 +0300[diff] [blame]221 print_mock.assert_called_once_with('api_v1', 'image-feature-enabled',
Matthew Treinishd14c9df2014-04-27 00:54:25 -0400[diff] [blame]222 False, True)
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]223
224 def test_verify_extensions_neutron(self):
225 def fake_list_extensions():
David Kranz34e88122014-12-11 15:24:05 -0500[diff] [blame]226 return {'extensions': [{'alias': 'fake1'},
227 {'alias': 'fake2'},
228 {'alias': 'not_fake'}]}
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]229 fake_os = mock.MagicMock()
Ken'ichi Ohmichi52bb8122016-01-26 01:43:06 +0000[diff] [blame]230 fake_os.network_extensions_client.list_extensions = (
231 fake_list_extensions)
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]232 self.useFixture(mockpatch.PatchObject(
233 verify_tempest_config, 'get_enabled_extensions',
234 return_value=(['fake1', 'fake2', 'fake3'])))
235 results = verify_tempest_config.verify_extensions(fake_os,
236 'neutron', {})
237 self.assertIn('neutron', results)
238 self.assertIn('fake1', results['neutron'])
239 self.assertTrue(results['neutron']['fake1'])
240 self.assertIn('fake2', results['neutron'])
241 self.assertTrue(results['neutron']['fake2'])
242 self.assertIn('fake3', results['neutron'])
243 self.assertFalse(results['neutron']['fake3'])
244 self.assertIn('not_fake', results['neutron'])
245 self.assertFalse(results['neutron']['not_fake'])
246
247 def test_verify_extensions_neutron_all(self):
248 def fake_list_extensions():
David Kranz34e88122014-12-11 15:24:05 -0500[diff] [blame]249 return {'extensions': [{'alias': 'fake1'},
250 {'alias': 'fake2'},
251 {'alias': 'not_fake'}]}
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]252 fake_os = mock.MagicMock()
Ken'ichi Ohmichi52bb8122016-01-26 01:43:06 +0000[diff] [blame]253 fake_os.network_extensions_client.list_extensions = (
254 fake_list_extensions)
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]255 self.useFixture(mockpatch.PatchObject(
256 verify_tempest_config, 'get_enabled_extensions',
257 return_value=(['all'])))
258 results = verify_tempest_config.verify_extensions(fake_os,
259 'neutron', {})
260 self.assertIn('neutron', results)
261 self.assertIn('extensions', results['neutron'])
Matthew Treinish6bbc8742014-08-25 18:28:15 -0400[diff] [blame]262 self.assertEqual(sorted(['fake1', 'fake2', 'not_fake']),
263 sorted(results['neutron']['extensions']))
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]264
265 def test_verify_extensions_cinder(self):
266 def fake_list_extensions():
Joseph Lanoux6809bab2014-12-18 14:57:18 +0000[diff] [blame]267 return {'extensions': [{'alias': 'fake1'},
268 {'alias': 'fake2'},
269 {'alias': 'not_fake'}]}
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]270 fake_os = mock.MagicMock()
Ivan Kolodyazhnybcfc32e2015-08-06 13:31:36 +0300[diff] [blame]271 # NOTE (e0ne): mock both v1 and v2 APIs
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]272 fake_os.volumes_extension_client.list_extensions = fake_list_extensions
Ivan Kolodyazhnybcfc32e2015-08-06 13:31:36 +0300[diff] [blame]273 fake_os.volumes_v2_extension_client.list_extensions = (
274 fake_list_extensions)
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]275 self.useFixture(mockpatch.PatchObject(
276 verify_tempest_config, 'get_enabled_extensions',
277 return_value=(['fake1', 'fake2', 'fake3'])))
278 results = verify_tempest_config.verify_extensions(fake_os,
279 'cinder', {})
280 self.assertIn('cinder', results)
281 self.assertIn('fake1', results['cinder'])
282 self.assertTrue(results['cinder']['fake1'])
283 self.assertIn('fake2', results['cinder'])
284 self.assertTrue(results['cinder']['fake2'])
285 self.assertIn('fake3', results['cinder'])
286 self.assertFalse(results['cinder']['fake3'])
287 self.assertIn('not_fake', results['cinder'])
288 self.assertFalse(results['cinder']['not_fake'])
289
290 def test_verify_extensions_cinder_all(self):
291 def fake_list_extensions():
Joseph Lanoux6809bab2014-12-18 14:57:18 +0000[diff] [blame]292 return {'extensions': [{'alias': 'fake1'},
293 {'alias': 'fake2'},
294 {'alias': 'not_fake'}]}
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]295 fake_os = mock.MagicMock()
Ivan Kolodyazhnybcfc32e2015-08-06 13:31:36 +0300[diff] [blame]296 # NOTE (e0ne): mock both v1 and v2 APIs
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]297 fake_os.volumes_extension_client.list_extensions = fake_list_extensions
Ivan Kolodyazhnybcfc32e2015-08-06 13:31:36 +0300[diff] [blame]298 fake_os.volumes_v2_extension_client.list_extensions = (
299 fake_list_extensions)
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]300 self.useFixture(mockpatch.PatchObject(
301 verify_tempest_config, 'get_enabled_extensions',
302 return_value=(['all'])))
303 results = verify_tempest_config.verify_extensions(fake_os,
304 'cinder', {})
305 self.assertIn('cinder', results)
306 self.assertIn('extensions', results['cinder'])
Matthew Treinish6bbc8742014-08-25 18:28:15 -0400[diff] [blame]307 self.assertEqual(sorted(['fake1', 'fake2', 'not_fake']),
308 sorted(results['cinder']['extensions']))
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]309
310 def test_verify_extensions_nova(self):
311 def fake_list_extensions():
David Kranz5cf4ba42015-02-10 14:00:50 -0500[diff] [blame]312 return ([{'alias': 'fake1'}, {'alias': 'fake2'},
313 {'alias': 'not_fake'}])
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]314 fake_os = mock.MagicMock()
315 fake_os.extensions_client.list_extensions = fake_list_extensions
316 self.useFixture(mockpatch.PatchObject(
317 verify_tempest_config, 'get_enabled_extensions',
318 return_value=(['fake1', 'fake2', 'fake3'])))
319 results = verify_tempest_config.verify_extensions(fake_os,
320 'nova', {})
321 self.assertIn('nova', results)
322 self.assertIn('fake1', results['nova'])
323 self.assertTrue(results['nova']['fake1'])
324 self.assertIn('fake2', results['nova'])
325 self.assertTrue(results['nova']['fake2'])
326 self.assertIn('fake3', results['nova'])
327 self.assertFalse(results['nova']['fake3'])
328 self.assertIn('not_fake', results['nova'])
329 self.assertFalse(results['nova']['not_fake'])
330
331 def test_verify_extensions_nova_all(self):
332 def fake_list_extensions():
David Kranz5cf4ba42015-02-10 14:00:50 -0500[diff] [blame]333 return ({'extensions': [{'alias': 'fake1'},
334 {'alias': 'fake2'},
335 {'alias': 'not_fake'}]})
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]336 fake_os = mock.MagicMock()
337 fake_os.extensions_client.list_extensions = fake_list_extensions
338 self.useFixture(mockpatch.PatchObject(
339 verify_tempest_config, 'get_enabled_extensions',
340 return_value=(['all'])))
341 results = verify_tempest_config.verify_extensions(fake_os,
342 'nova', {})
343 self.assertIn('nova', results)
344 self.assertIn('extensions', results['nova'])
Matthew Treinish6bbc8742014-08-25 18:28:15 -0400[diff] [blame]345 self.assertEqual(sorted(['fake1', 'fake2', 'not_fake']),
346 sorted(results['nova']['extensions']))
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]347
Matthew Treinishfabe77c2014-04-27 10:38:00 -0400[diff] [blame]348 def test_verify_extensions_swift(self):
349 def fake_list_extensions():
350 return (None, {'fake1': 'metadata',
351 'fake2': 'metadata',
352 'not_fake': 'metadata',
353 'swift': 'metadata'})
354 fake_os = mock.MagicMock()
355 fake_os.account_client.list_extensions = fake_list_extensions
356 self.useFixture(mockpatch.PatchObject(
357 verify_tempest_config, 'get_enabled_extensions',
358 return_value=(['fake1', 'fake2', 'fake3'])))
359 results = verify_tempest_config.verify_extensions(fake_os, 'swift', {})
360 self.assertIn('swift', results)
361 self.assertIn('fake1', results['swift'])
362 self.assertTrue(results['swift']['fake1'])
363 self.assertIn('fake2', results['swift'])
364 self.assertTrue(results['swift']['fake2'])
365 self.assertIn('fake3', results['swift'])
366 self.assertFalse(results['swift']['fake3'])
367 self.assertIn('not_fake', results['swift'])
368 self.assertFalse(results['swift']['not_fake'])
369
370 def test_verify_extensions_swift_all(self):
371 def fake_list_extensions():
372 return (None, {'fake1': 'metadata',
373 'fake2': 'metadata',
374 'not_fake': 'metadata',
375 'swift': 'metadata'})
376 fake_os = mock.MagicMock()
377 fake_os.account_client.list_extensions = fake_list_extensions
378 self.useFixture(mockpatch.PatchObject(
379 verify_tempest_config, 'get_enabled_extensions',
380 return_value=(['all'])))
381 results = verify_tempest_config.verify_extensions(fake_os,
382 'swift', {})
383 self.assertIn('swift', results)
384 self.assertIn('extensions', results['swift'])
Matthew Treinish6bbc8742014-08-25 18:28:15 -0400[diff] [blame]385 self.assertEqual(sorted(['not_fake', 'fake1', 'fake2']),
386 sorted(results['swift']['extensions']))