Commit 545a8875d01a73c2e08a1ed528cd7fc080ebba5a - cinder-tempest-plugin

Port to the tempest stable plugin interface (clients) This is one of the last tempest plugins which was still not using the proper interface to define its clients. (Hopefully) no behavioral changes, just refactoring. Change-Id: Ia57c771186cd1bf283f30b58007395d33aefa4a9 Luigi Toscano 1 year, 8 months ago

6 changed file(s) with 98 addition(s) and 66 deletion(s). Raw diff Collapse all Expand all

+36

-39

cinder_tempest_plugin/api/volume/admin/test_consistencygroups.py less more

19	19	from tempest.lib import decorators
20	20
21	21	from cinder_tempest_plugin.api.volume import base
22		from cinder_tempest_plugin import cinder_clients
23	22
24	23	CONF = config.CONF
25	24
26	25
27	26	class ConsistencyGroupsV2Test(base.BaseVolumeAdminTest):
28		@classmethod
29		def setup_clients(cls):
30		super(ConsistencyGroupsV2Test, cls).setup_clients()
31
32		manager = cinder_clients.Manager(cls.os_admin)
33		cls.consistencygroups_adm_client = manager.consistencygroups_adm_client
34	27
35	28	@classmethod
36	29	def skip_checks(cls):

40	33	"feature disabled")
41	34
42	35	def _delete_consistencygroup(self, cg_id):
43		self.consistencygroups_adm_client.delete_consistencygroup(cg_id)
	36	self.admin_consistencygroups_client.delete_consistencygroup(cg_id)
44	37	vols = self.admin_volume_client.list_volumes(detail=True)['volumes']
45	38	for vol in vols:
46	39	if vol['consistencygroup_id'] == cg_id:
47	40	self.admin_volume_client.wait_for_resource_deletion(vol['id'])
48		self.consistencygroups_adm_client.wait_for_consistencygroup_deletion(
	41	self.admin_consistencygroups_client.wait_for_consistencygroup_deletion(
49	42	cg_id)
50	43
51	44	def _delete_cgsnapshot(self, cgsnapshot_id, cg_id):
52		self.consistencygroups_adm_client.delete_cgsnapshot(cgsnapshot_id)
	45	self.admin_consistencygroups_client.delete_cgsnapshot(cgsnapshot_id)
53	46	vols = self.admin_volume_client.list_volumes(detail=True)['volumes']
54	47	snapshots = self.os_admin.snapshots_v2_client.list_snapshots(
55	48	detail=True)['snapshots']

59	52	vol['id'] == snap['volume_id']):
60	53	(self.snapshots_client.
61	54	wait_for_resource_deletion(snap['id']))
62		self.consistencygroups_adm_client.wait_for_cgsnapshot_deletion(
	55	self.admin_consistencygroups_client.wait_for_cgsnapshot_deletion(
63	56	cgsnapshot_id)
64	57
65	58	@decorators.idempotent_id('3fe776ba-ec1f-4e6c-8d78-4b14c3a7fc44')

72	65	# Create CG
73	66	cg_name = data_utils.rand_name('CG')
74	67	create_consistencygroup = (
75		self.consistencygroups_adm_client.create_consistencygroup)
76		cg = create_consistencygroup(volume_type['id'],
77		name=cg_name)['consistencygroup']
78		self.consistencygroups_adm_client.wait_for_consistencygroup_status(
	68	self.admin_consistencygroups_client.create_consistencygroup)
	69	cg = create_consistencygroup(volume_type['id'],
	70	name=cg_name)['consistencygroup']
	71	self.admin_consistencygroups_client.wait_for_consistencygroup_status(
79	72	cg['id'], 'available')
80	73	self.assertEqual(cg_name, cg['name'])
81	74

91	84	volume['id'], 'available')
92	85
93	86	# Get a given CG
94		cg = self.consistencygroups_adm_client.show_consistencygroup(
	87	cg = self.admin_consistencygroups_client.show_consistencygroup(
95	88	cg['id'])['consistencygroup']
96	89	self.assertEqual(cg_name, cg['name'])
97	90
98	91	# Get all CGs with detail
99		cgs = self.consistencygroups_adm_client.list_consistencygroups(
	92	cgs = self.admin_consistencygroups_client.list_consistencygroups(
100	93	detail=True)['consistencygroups']
101	94	self.assertIn((cg['name'], cg['id']),
102	95	[(m['name'], m['id']) for m in cgs])

116	109	# Create CG
117	110	cg_name = data_utils.rand_name('CG')
118	111	create_consistencygroup = (
119		self.consistencygroups_adm_client.create_consistencygroup)
120		cg = create_consistencygroup(volume_type['id'],
121		name=cg_name)['consistencygroup']
122		self.consistencygroups_adm_client.wait_for_consistencygroup_status(
	112	self.admin_consistencygroups_client.create_consistencygroup)
	113	cg = create_consistencygroup(volume_type['id'],
	114	name=cg_name)['consistencygroup']
	115	self.admin_consistencygroups_client.wait_for_consistencygroup_status(
123	116	cg['id'], 'available')
124	117	self.assertEqual(cg_name, cg['name'])
125	118

136	129	# Create cgsnapshot
137	130	cgsnapshot_name = data_utils.rand_name('cgsnapshot')
138	131	create_cgsnapshot = (
139		self.consistencygroups_adm_client.create_cgsnapshot)
	132	self.admin_consistencygroups_client.create_cgsnapshot)
140	133	cgsnapshot = create_cgsnapshot(cg['id'],
141	134	name=cgsnapshot_name)['cgsnapshot']
142		self.consistencygroups_adm_client.wait_for_cgsnapshot_status(
	135	self.admin_consistencygroups_client.wait_for_cgsnapshot_status(
143	136	cgsnapshot['id'], 'available')
144	137	self.assertEqual(cgsnapshot_name, cgsnapshot['name'])
145	138	snapshots = self.os_admin.snapshots_v2_client.list_snapshots(

151	144	snap['id'], 'available')
152	145
153	146	# Get a given CG snapshot
154		cgsnapshot = self.consistencygroups_adm_client.show_cgsnapshot(
	147	cgsnapshot = self.admin_consistencygroups_client.show_cgsnapshot(
155	148	cgsnapshot['id'])['cgsnapshot']
156	149	self.assertEqual(cgsnapshot_name, cgsnapshot['name'])
157	150
158	151	# Get all CG snapshots with detail
159		cgsnapshots = self.consistencygroups_adm_client.list_cgsnapshots(
	152	cgsnapshots = self.admin_consistencygroups_client.list_cgsnapshots(
160	153	detail=True)['cgsnapshots']
161	154	self.assertIn((cgsnapshot['name'], cgsnapshot['id']),
162	155	[(m['name'], m['id']) for m in cgsnapshots])

176	169	# Create CG
177	170	cg_name = data_utils.rand_name('CG')
178	171	create_consistencygroup = (
179		self.consistencygroups_adm_client.create_consistencygroup)
180		cg = create_consistencygroup(volume_type['id'],
181		name=cg_name)['consistencygroup']
182		self.consistencygroups_adm_client.wait_for_consistencygroup_status(
	172	self.admin_consistencygroups_client.create_consistencygroup)
	173	cg = create_consistencygroup(volume_type['id'],
	174	name=cg_name)['consistencygroup']
	175	self.admin_consistencygroups_client.wait_for_consistencygroup_status(
183	176	cg['id'], 'available')
184	177	self.assertEqual(cg_name, cg['name'])
185	178

196	189	# Create cgsnapshot
197	190	cgsnapshot_name = data_utils.rand_name('cgsnapshot')
198	191	create_cgsnapshot = (
199		self.consistencygroups_adm_client.create_cgsnapshot)
	192	self.admin_consistencygroups_client.create_cgsnapshot)
200	193	cgsnapshot = create_cgsnapshot(cg['id'],
201	194	name=cgsnapshot_name)['cgsnapshot']
202		self.consistencygroups_adm_client.wait_for_cgsnapshot_status(
	195	self.admin_consistencygroups_client.wait_for_cgsnapshot_status(
203	196	cgsnapshot['id'], 'available')
204	197	self.assertEqual(cgsnapshot_name, cgsnapshot['name'])
205	198	snapshots = self.snapshots_client.list_snapshots(

212	205	# Create CG from CG snapshot
213	206	cg_name2 = data_utils.rand_name('CG_from_snap')
214	207	create_consistencygroup2 = (
215		self.consistencygroups_adm_client.create_consistencygroup_from_src)
	208	self.admin_consistencygroups_client.
	209	create_consistencygroup_from_src
	210	)
216	211	cg2 = create_consistencygroup2(cgsnapshot_id=cgsnapshot['id'],
217	212	name=cg_name2)['consistencygroup']
218		self.consistencygroups_adm_client.wait_for_consistencygroup_status(
	213	self.admin_consistencygroups_client.wait_for_consistencygroup_status(
219	214	cg2['id'], 'available')
220	215	self.assertEqual(cg_name2, cg2['name'])
221	216	vols = self.admin_volume_client.list_volumes(

241	236	# Create CG
242	237	cg_name = data_utils.rand_name('CG')
243	238	create_consistencygroup = (
244		self.consistencygroups_adm_client.create_consistencygroup)
245		cg = create_consistencygroup(volume_type['id'],
246		name=cg_name)['consistencygroup']
247		self.consistencygroups_adm_client.wait_for_consistencygroup_status(
	239	self.admin_consistencygroups_client.create_consistencygroup)
	240	cg = create_consistencygroup(volume_type['id'],
	241	name=cg_name)['consistencygroup']
	242	self.admin_consistencygroups_client.wait_for_consistencygroup_status(
248	243	cg['id'], 'available')
249	244	self.assertEqual(cg_name, cg['name'])
250	245

261	256	# Create CG from CG
262	257	cg_name2 = data_utils.rand_name('CG_from_cg')
263	258	create_consistencygroup2 = (
264		self.consistencygroups_adm_client.create_consistencygroup_from_src)
	259	self.admin_consistencygroups_client.
	260	create_consistencygroup_from_src
	261	)
265	262	cg2 = create_consistencygroup2(source_cgid=cg['id'],
266	263	name=cg_name2)['consistencygroup']
267		self.consistencygroups_adm_client.wait_for_consistencygroup_status(
	264	self.admin_consistencygroups_client.wait_for_consistencygroup_status(
268	265	cg2['id'], 'available')
269	266	self.assertEqual(cg_name2, cg2['name'])
270	267	vols = self.admin_volume_client.list_volumes(

-0

cinder_tempest_plugin/api/volume/base.py less more

49	49	cls.backups_client = cls.os_primary.backups_client_latest
50	50	cls.volumes_client = cls.os_primary.volumes_client_latest
51	51	cls.snapshots_client = cls.os_primary.snapshots_client_latest
	52	cls.volume_revert_client = (
	53	cls.os_primary.volume_revert_v3.VolumeRevertClient()
	54	)
52	55
53	56	@classmethod
54	57	def setup_credentials(cls):

195	198	cls.admin_volume_types_client = cls.os_admin.volume_types_client_latest
196	199	cls.admin_backups_client = cls.os_admin.backups_client_latest
197	200	cls.admin_volume_client = cls.os_admin.volumes_client_latest
	201	cls.admin_consistencygroups_client = (
	202	cls.os_admin.consistencygroups_v3.ConsistencyGroupsClient()
	203	)
198	204
199	205	@classmethod
200	206	def create_volume_type(cls, name=None, **kwargs):

-8

cinder_tempest_plugin/api/volume/test_volume_revert.py less more

18	18	from tempest.lib import exceptions
19	19
20	20	from cinder_tempest_plugin.api.volume import base
21		from cinder_tempest_plugin import cinder_clients
22	21
23	22	CONF = config.CONF
24	23

31	30	super(VolumeRevertTests, cls).skip_checks()
32	31	if not CONF.volume_feature_enabled.volume_revert:
33	32	raise cls.skipException("Cinder volume revert feature disabled")
34
35		@classmethod
36		def setup_clients(cls):
37		super(VolumeRevertTests, cls).setup_clients()
38
39		manager = cinder_clients.Manager(cls.os_primary)
40		cls.volume_revert_client = manager.volume_revert_client
41	33
42	34	def setUp(self):
43	35	super(VolumeRevertTests, self).setUp()

+11

-19

cinder_tempest_plugin/cinder_clients.py less more

13	13	# under the License.
14	14
15	15	from tempest import config
16
17		from cinder_tempest_plugin.services import consistencygroups_client
18		from cinder_tempest_plugin.services import volume_revert_client
	16	from tempest.lib.services import clients
19	17
20	18	CONF = config.CONF
21	19
22	20
23		class Manager(object):
24		def __init__(self, base_manager):
25		params = {
26		'service': CONF.volume.catalog_type,
27		'region': CONF.volume.region or CONF.identity.region,
28		'endpoint_type': CONF.volume.endpoint_type,
29		'build_interval': CONF.volume.build_interval,
30		'build_timeout': CONF.volume.build_timeout
31		}
32		params.update(base_manager.default_params)
33		auth_provider = base_manager.auth_provider
	21	class Clients(clients.ServiceClients):
	22	"""Tempest stable service clients and loaded plugins service clients"""
34	23
35		self.consistencygroups_adm_client = (
36		consistencygroups_client.ConsistencyGroupsClient(auth_provider,
37		**params))
38		self.volume_revert_client = (
39		volume_revert_client.VolumeRevertClient(auth_provider, **params))
	24	def __init__(self, credentials, service=None):
	25	"""Emulate the interface of Tempest's clients.Manager"""
	26	# Identity settings
	27	if CONF.identity.auth_version == 'v2':
	28	identity_uri = CONF.identity.uri
	29	else:
	30	identity_uri = CONF.identity.uri_v3
	31	super(Clients, self).__init__(credentials, identity_uri)

+23

-0

cinder_tempest_plugin/plugin.py less more

68	68	project_config.barbican_service_option))
69	69
70	70	return opt_lists
	71
	72	def get_service_clients(self):
	73	volumes_config = config.service_client_config('volume')
	74
	75	consistencygroups_params = {
	76	'name': 'consistencygroups_v3',
	77	'service_version': 'consistencygroups.v3',
	78	'module_path': 'cinder_tempest_plugin.services.'
	79	'consistencygroups_client',
	80	'client_names': ['ConsistencyGroupsClient'],
	81	}
	82	consistencygroups_params.update(volumes_config)
	83
	84	volumerevert_params = {
	85	'name': 'volume_revert_v3',
	86	'service_version': 'volume_revert.v3',
	87	'module_path': 'cinder_tempest_plugin.services.'
	88	'volume_revert_client',
	89	'client_names': ['VolumeRevertClient'],
	90	}
	91	volumerevert_params.update(volumes_config)
	92
	93	return [consistencygroups_params, volumerevert_params]

+22

-0

cinder_tempest_plugin/services/__init__.py less more

	0	#
	1	# Licensed under the Apache License, Version 2.0 (the "License"); you may not
	2	# use this file except in compliance with the License. You may obtain a copy of
	3	# the License at
	4	#
	5	# http://www.apache.org/licenses/LICENSE-2.0
	6	#
	7	# Unless required by applicable law or agreed to in writing, software
	8	# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	9	# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	10	# License for the specific language governing permissions and limitations under
	11	# the License.
	12
	13	from cinder_tempest_plugin.services.consistencygroups_client import \
	14	ConsistencyGroupsClient
	15	from cinder_tempest_plugin.services.volume_revert_client import \
	16	VolumeRevertClient
	17
	18	__all__ = [
	19	'ConsistencyGroupsClient',
	20	'VolumeRevertClient'
	21	]