def test_update_volume(self):
return_value = {"volume": fakes.FakeVolume()}
self.cinder.volumes.update.return_value = return_value
self.assertEqual(return_value["volume"], self.service.update_volume(1))
self.cinder.volumes.update.assert_called_once_with(1)
self._test_atomic_action_timer(self.atomic_actions(),
"cinder_v2.update_volume")
def test_delete_metadata_not_enough_keys(self):
volume = fakes.FakeVolume()
keys = ["a", "b", "c", "d", "e"]
self.assertRaises(exceptions.InvalidArgumentsException,
self.service.delete_metadata,
volume,
keys,
deletes=2,
delete_size=3)
def test_extend_volume(self, mock_create_volume):
volume = mock_create_volume.return_value
self.service._wait_available_volume = mock.MagicMock()
self.service._wait_available_volume.return_value = fakes.FakeVolume()
self.assertEqual(self.service._wait_available_volume.return_value,
self.service.extend_volume(volume, 1))
self.cinder.volumes.extend.assert_called_once_with(volume, 1)
self.service._wait_available_volume.assert_called_once_with(volume)
def test_set_metadata(self):
volume = fakes.FakeVolume()
self.service.set_metadata(volume, sets=2, set_size=4)
calls = self.cinder.volumes.set_metadata.call_args_list
self.assertEqual(2, len(calls))
for call in calls:
call_volume, metadata = call[0]
self.assertEqual(volume, call_volume)
self.assertEqual(4, len(metadata))
def test__wait_available_volume(self):
volume = fakes.FakeVolume()
self.assertEqual(self.mock_wait_for_status.mock.return_value,
self.service._wait_available_volume(volume))
self.mock_wait_for_status.mock.assert_called_once_with(
volume,
ready_statuses=["available"],
update_resource=self.service._update_resource,
timeout=CONF.benchmark.cinder_volume_create_timeout,
check_interval=CONF.benchmark.cinder_volume_create_poll_interval)
def test_update_volume_with_name_description(self):
return_value = {"volume": fakes.FakeVolume()}
self.cinder.volumes.update.return_value = return_value
return_volume = self.service.update_volume(
1, name="volume", description="fake")
self.cinder.volumes.update.assert_called_once_with(
1, name="volume", description="fake")
self.assertEqual(return_value["volume"], return_volume)
self._test_atomic_action_timer(self.atomic_actions(),
"cinder_v2.update_volume")
def test__set_metadata(self):
volume = fakes.FakeVolume()
self.scenario._set_metadata(volume, sets=2, set_size=4)
calls = self.clients("cinder").volumes.set_metadata.call_args_list
self.assertEqual(len(calls), 2)
for call in calls:
call_volume, metadata = call[0]
self.assertEqual(call_volume, volume)
self.assertEqual(len(metadata), 4)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.set_4_metadatas_2_times")
def test_create_snapshot_with_name(self):
self.service._wait_available_volume = mock.MagicMock()
self.service._wait_available_volume.return_value = fakes.FakeVolume()
return_snapshot = self.service.create_snapshot(1, name="snapshot")
self.cinder.volume_snapshots.create.assert_called_once_with(
1, name="snapshot", description=None, force=False, metadata=None)
self.service._wait_available_volume.assert_called_once_with(
self.cinder.volume_snapshots.create.return_value)
self.assertEqual(self.service._wait_available_volume.return_value,
return_snapshot)
self._test_atomic_action_timer(self.atomic_actions(),
"cinder_v2.create_snapshot")
def test_create_backup_with_name(self):
self.service._wait_available_volume = mock.MagicMock()
self.service._wait_available_volume.return_value = fakes.FakeVolume()
return_backup = self.service.create_backup(1, name="backup")
self.cinder.backups.create.assert_called_once_with(
1, name="backup", description=None, container=None,
incremental=False, force=False, snapshot_id=None)
self.service._wait_available_volume.assert_called_once_with(
self.cinder.backups.create.return_value)
self.assertEqual(self.service._wait_available_volume.return_value,
return_backup)
self._test_atomic_action_timer(self.atomic_actions(),
"cinder_v2.create_backup")
def test_create_snapshot(self):
self.service._wait_available_volume = mock.MagicMock()
self.service._wait_available_volume.return_value = fakes.FakeVolume()
self.service.generate_random_name = mock.MagicMock(
return_value="snapshot")
return_snapshot = self.service.create_snapshot(1)
self.cinder.volume_snapshots.create.assert_called_once_with(
1, display_name="snapshot", display_description=None, force=False)
self.service._wait_available_volume.assert_called_once_with(
self.cinder.volume_snapshots.create.return_value)
self.assertEqual(self.service._wait_available_volume.return_value,
return_snapshot)
self._test_atomic_action_timer(self.atomic_actions(),
"cinder_v1.create_snapshot")
def test_delete_metadata(self):
volume = fakes.FakeVolume()
keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"]
self.service.delete_metadata(volume, keys, deletes=3, delete_size=4)
calls = self.cinder.volumes.delete_metadata.call_args_list
self.assertEqual(3, len(calls))
all_deleted = []
for call in calls:
call_volume, del_keys = call[0]
self.assertEqual(volume, call_volume)
self.assertEqual(4, len(del_keys))
for key in del_keys:
self.assertIn(key, keys)
self.assertNotIn(key, all_deleted)
all_deleted.append(key)
def test_create_backup(self):
self.service._wait_available_volume = mock.MagicMock()
self.service._wait_available_volume.return_value = fakes.FakeVolume()
self.service.generate_random_name = mock.MagicMock(
return_value="backup")
return_backup = self.service.create_backup(1)
self.cinder.backups.create.assert_called_once_with(1,
name="backup",
description=None,
container=None)
self.service._wait_available_volume.assert_called_once_with(
self.cinder.backups.create.return_value)
self.assertEqual(self.service._wait_available_volume.return_value,
return_backup)
self._test_atomic_action_timer(self.atomic_actions(),
"cinder_v1.create_backup")
def test__delete_metadata(self):
volume = fakes.FakeVolume()
keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"]
self.scenario._delete_metadata(volume, keys, deletes=3, delete_size=4)
calls = self.clients("cinder").volumes.delete_metadata.call_args_list
self.assertEqual(len(calls), 3)
all_deleted = []
for call in calls:
call_volume, del_keys = call[0]
self.assertEqual(call_volume, volume)
self.assertEqual(len(del_keys), 4)
for key in del_keys:
self.assertIn(key, keys)
self.assertNotIn(key, all_deleted)
all_deleted.append(key)
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.delete_4_metadatas_3_times")
def test_create_volume_with_size_range(self, mock_random):
mock_random.randint.return_value = 3
self.service._wait_available_volume = mock.MagicMock()
self.service._wait_available_volume.return_value = fakes.FakeVolume()
return_volume = self.service.create_volume(
size={"min": 1, "max": 5}, name="volume")
kwargs = {"name": "volume",
"description": None,
"consistencygroup_id": None,
"snapshot_id": None,
"source_volid": None,
"volume_type": None,
"availability_zone": None,
"metadata": None,
"imageRef": None,
"scheduler_hints": None}
self.cinder.volumes.create.assert_called_once_with(
3, **kwargs)
self.service._wait_available_volume.assert_called_once_with(
self.cinder.volumes.create.return_value)
self.assertEqual(self.service._wait_available_volume.return_value,
return_volume)
class VolumeGeneratorTestCase(test.TestCase):
def test_init(self):
context = {}
context["task"] = mock.MagicMock()
context["config"] = {
"volumes": {
"size": 1,
}
}
new_context = copy.deepcopy(context)
new_context["volumes"] = []
volumes.VolumeGenerator(context)
self.assertEqual(new_context, context)
@mock.patch("%s.cinder.utils.CinderScenario._create_volume" % SCN,
return_value=fakes.FakeVolume(id="uuid"))
@mock.patch("%s.volumes.osclients" % CTX)
def test_setup(self, mock_osclients, mock_volume_create):
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
ctx_volumes = [{
'volume_id': 'uuid',
'endpoint': 'endpoint',
'tenant_id': i
} for i in range(2)]
user_key = [{
'id': i,
'tenant_id': j,
'endpoint': 'endpoint'
} for j in range(2) for i in range(5)]
real_context = {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
}
},
"admin": {
"endpoint": mock.MagicMock()
},
"task": mock.MagicMock(),
"users": user_key,
}
new_context = copy.deepcopy(real_context)
new_context["volumes"] = ctx_volumes
volumes_ctx = volumes.VolumeGenerator(real_context)
volumes_ctx.setup()
self.assertEqual(new_context, real_context)
@mock.patch("%s.volumes.osclients" % CTX)
@mock.patch("%s.cleanup.utils.delete_cinder_resources" % CTX)
def test_cleanup(self, mock_cinder_remover, mock_osclients):
ctx_volumes = [{
'volume_id': 'uuid',
'endpoint': mock.MagicMock(),
'tenant_id': i
} for i in range(2)]
user_key = [{
'id': i,
'tenant_id': j,
'endpoint': 'endpoint'
} for j in range(2) for i in range(5)]
context = {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
}
},
"admin": {
"endpoint": mock.MagicMock()
},
"task": mock.MagicMock(),
"users": user_key,
"volumes": ctx_volumes,
}
volumes_ctx = volumes.VolumeGenerator(context)
volumes_ctx.cleanup()
self.assertEqual(2, len(mock_cinder_remover.mock_calls))
@mock.patch("%s.volumes.osclients" % CTX)
@mock.patch("%s.cleanup.utils.delete_cinder_resources" % CTX)
def test_cleanup_exception(self, mock_cinder_remover, mock_osclients):
ctx_volumes = [{
'volume_id': 'uuid',
'endpoint': mock.MagicMock(),
'tenant_id': i
} for i in range(2)]
user_key = [{
'id': i,
'tenant_id': j,
'endpoint': 'endpoint'
} for j in range(2) for i in range(5)]
context = {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
}
},
"admin": {
"endpoint": mock.MagicMock()
},
"task": mock.MagicMock(),
"users": user_key,
"volumes": ctx_volumes,
}
mock_cinder_remover.side_effect = Exception()
volumes_ctx = volumes.VolumeGenerator(context)
volumes_ctx.cleanup()
self.assertEqual(2, len(mock_cinder_remover.mock_calls))
def test__get_volume(self):
volume = fakes.FakeVolume()
self.assertEqual(self.clients("cinder").volumes.get.return_value,
self.scenario._get_volume(volume.id))
self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.get_volume")
class VolumeGeneratorTestCase(test.ScenarioTestCase):
def _gen_tenants(self, count):
tenants = {}
for id_ in range(count):
tenants[str(id_)] = {"name": str(id_)}
return tenants
def test_init(self):
self.context.update(
{"config": {
"volumes": {
"size": 1,
"volumes_per_tenant": 5,
}
}})
inst = volumes.VolumeGenerator(self.context)
self.assertEqual(inst.config, self.context["config"]["volumes"])
@ddt.data({"config": {
"size": 1,
"volumes_per_tenant": 5
}}, {"config": {
"size": 1,
"type": None,
"volumes_per_tenant": 5
}}, {
"config": {
"size": 1,
"type": -1,
"volumes_per_tenant": 5
},
"validation_raises": jsonschema.exceptions.ValidationError
})
@ddt.unpack
@mock.patch("%s.cinder.utils.CinderScenario._create_volume" % SCN,
return_value=fakes.FakeVolume(id="uuid"))
def test_setup(self,
mock_cinder_scenario__create_volume,
config,
validation_raises=None):
try:
volumes.VolumeGenerator.validate(config)
except Exception as e:
if not isinstance(e, validation_raises):
raise
users_per_tenant = 5
volumes_per_tenant = config.get("volumes_per_tenant", 5)
tenants = self._gen_tenants(2)
users = []
for id_ in tenants:
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id_,
"credential": mock.MagicMock()
})
self.context.update({
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": config
},
"admin": {
"credential": mock.MagicMock()
},
"users": users,
"tenants": tenants
})
new_context = copy.deepcopy(self.context)
for id_ in tenants.keys():
new_context["tenants"][id_].setdefault("volumes", [])
for i in range(volumes_per_tenant):
new_context["tenants"][id_]["volumes"].append({"id": "uuid"})
volumes_ctx = volumes.VolumeGenerator(self.context)
volumes_ctx.setup()
self.assertEqual(new_context, self.context)
@mock.patch("%s.cinder.volumes.resource_manager.cleanup" % CTX)
def test_cleanup(self, mock_cleanup):
tenants_count = 2
users_per_tenant = 5
volumes_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = []
for id_ in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id_,
"credential": "credential"
})
tenants[id_].setdefault("volumes", [])
for j in range(volumes_per_tenant):
tenants[id_]["volumes"].append({"id": "uuid"})
self.context.update({
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
"volumes_per_tenant": 5,
}
},
"admin": {
"credential": mock.MagicMock()
},
"users": users,
"tenants": tenants
})
volumes_ctx = volumes.VolumeGenerator(self.context)
volumes_ctx.cleanup()
mock_cleanup.assert_called_once_with(names=["cinder.volumes"],
users=self.context["users"],
api_versions=None)
@mock.patch("%s.cinder.volumes.resource_manager.cleanup" % CTX)
def test_cleanup_api_versions(self, mock_cleanup):
tenants_count = 2
users_per_tenant = 5
volumes_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = []
for id_ in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id_,
"credential": "credential"
})
tenants[id_].setdefault("volumes", [])
for j in range(volumes_per_tenant):
tenants[id_]["volumes"].append({"id": "uuid"})
api_version = {"cinder": {"version": 1, "service_type": "volume"}}
self.context.update({
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
"type": "volume_type",
"volumes_per_tenant": 5,
},
"api_versions": api_version
},
"admin": {
"credential": mock.MagicMock()
},
"users": users,
"tenants": tenants
})
volumes_ctx = volumes.VolumeGenerator(self.context)
volumes_ctx.cleanup()
mock_cleanup.assert_called_once_with(names=["cinder.volumes"],
users=self.context["users"],
api_versions=api_version)
class VolumeGeneratorTestCase(test.ScenarioTestCase):
def _gen_tenants(self, count):
tenants = {}
for id_ in range(count):
tenants[str(id_)] = {"name": str(id_)}
return tenants
def test_init(self):
self.context.update(
{"config": {
"volumes": {
"size": 1,
"volumes_per_tenant": 5,
}
}})
inst = volumes.VolumeGenerator(self.context)
self.assertEqual(inst.config, self.context["config"]["volumes"])
@mock.patch("%s.cinder.utils.CinderScenario._create_volume" % SCN,
return_value=fakes.FakeVolume(id="uuid"))
def test_setup(self, mock_cinder_scenario__create_volume):
tenants_count = 2
users_per_tenant = 5
volumes_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = []
for id_ in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id_,
"credential": mock.MagicMock()
})
self.context.update({
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
"volumes_per_tenant": volumes_per_tenant,
}
},
"admin": {
"credential": mock.MagicMock()
},
"users": users,
"tenants": tenants
})
new_context = copy.deepcopy(self.context)
for id_ in tenants.keys():
new_context["tenants"][id_].setdefault("volumes", [])
for i in range(volumes_per_tenant):
new_context["tenants"][id_]["volumes"].append({"id": "uuid"})
volumes_ctx = volumes.VolumeGenerator(self.context)
volumes_ctx.setup()
self.assertEqual(new_context, self.context)
@mock.patch("%s.cinder.volumes.resource_manager.cleanup" % CTX)
def test_cleanup(self, mock_cleanup):
tenants_count = 2
users_per_tenant = 5
volumes_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = []
for id_ in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id_,
"credential": "credential"
})
tenants[id_].setdefault("volumes", [])
for j in range(volumes_per_tenant):
tenants[id_]["volumes"].append({"id": "uuid"})
self.context.update({
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
"volumes_per_tenant": 5,
}
},
"admin": {
"credential": mock.MagicMock()
},
"users": users,
"tenants": tenants
})
volumes_ctx = volumes.VolumeGenerator(self.context)
volumes_ctx.cleanup()
mock_cleanup.assert_called_once_with(names=["cinder.volumes"],
users=self.context["users"])
class VolumeGeneratorTestCase(test.TestCase):
def _gen_tenants(self, count):
tenants = dict()
for id in range(count):
tenants[str(id)] = dict(name=str(id))
return tenants
def test_init(self):
context = {}
context["task"] = mock.MagicMock()
context["config"] = {
"volumes": {
"size": 1,
"volumes_per_tenant": 5,
}
}
inst = volumes.VolumeGenerator(context)
self.assertEqual(inst.config, context["config"]["volumes"])
@mock.patch("%s.cinder.utils.CinderScenario._create_volume" % SCN,
return_value=fakes.FakeVolume(id="uuid"))
@mock.patch("%s.volumes.osclients" % CTX)
def test_setup(self, mock_osclients, mock_volume_create):
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
tenants_count = 2
users_per_tenant = 5
volumes_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = list()
for id in tenants.keys():
for i in range(users_per_tenant):
users.append({"id": i, "tenant_id": id,
"endpoint": "endpoint"})
real_context = {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
"volumes_per_tenant": 5,
}
},
"admin": {
"endpoint": mock.MagicMock()
},
"task": mock.MagicMock(),
"users": users,
"tenants": tenants
}
new_context = copy.deepcopy(real_context)
for id in tenants.keys():
new_context["tenants"][id].setdefault("volumes", list())
for i in range(volumes_per_tenant):
new_context["tenants"][id]["volumes"].append({"id": "uuid"})
volumes_ctx = volumes.VolumeGenerator(real_context)
volumes_ctx.setup()
self.assertEqual(new_context, real_context)
@mock.patch("%s.volumes.osclients" % CTX)
@mock.patch("%s.volumes.resource_manager.cleanup" % CTX)
def test_cleanup(self, mock_cleanup, mock_osclients):
tenants_count = 2
users_per_tenant = 5
volumes_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = list()
for id in tenants.keys():
for i in range(users_per_tenant):
users.append({"id": i, "tenant_id": id,
"endpoint": "endpoint"})
tenants[id].setdefault("volumes", list())
for j in range(volumes_per_tenant):
tenants[id]["volumes"].append({"id": "uuid"})
context = {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"volumes": {
"size": 1,
"volumes_per_tenant": 5,
}
},
"admin": {
"endpoint": mock.MagicMock()
},
"task": mock.MagicMock(),
"users": users,
"tenants": tenants
}
volumes_ctx = volumes.VolumeGenerator(context)
volumes_ctx.cleanup()
mock_cleanup.assert_called_once_with(names=["cinder.volumes"],
users=context["users"])
