Commit 64adb266c80ba6e8c01ed3822c04385bf5b2bc70 - cinder-tempest-plugin

Merge "Port to the tempest stable plugin interface (clients)" Zuul authored 1 year, 7 months ago Gerrit Code Review committed 1 year, 7 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	]