From 9b1ee113e84af766a68d3d55fb01411283964c6d Mon Sep 17 00:00:00 2001 From: Mikhail Dubov Date: Sun, 15 Dec 2013 01:09:37 +0400 Subject: [PATCH] Move Fake objects to a special tests.fakes module A set of Fake objects originally created for nova scenarios unit tests turned out to be very useful for several other unit tests as well. Here, we move all these Fake objects to a special tests.fakes module. This will also simplify code reuse in future unit tests. Blueprint unit-tests-refactoring Change-Id: I2b3c6a3f1543a186fe498d886e3fd4bfe615dce8 --- .../benchmark/scenarios/nova/test_servers.py | 8 +- tests/benchmark/scenarios/nova/test_utils.py | 326 +--------------- tests/benchmark/test_test_engine.py | 8 +- tests/benchmark/test_utils.py | 82 ++-- tests/fakes.py | 355 ++++++++++++++++++ 5 files changed, 397 insertions(+), 382 deletions(-) create mode 100644 tests/fakes.py diff --git a/tests/benchmark/scenarios/nova/test_servers.py b/tests/benchmark/scenarios/nova/test_servers.py index b9ace78c6a..fd98c5c3ac 100644 --- a/tests/benchmark/scenarios/nova/test_servers.py +++ b/tests/benchmark/scenarios/nova/test_servers.py @@ -19,7 +19,7 @@ from rally.benchmark.scenarios.nova import servers from rally.benchmark import utils as butils from rally import exceptions as rally_exceptions from rally import test -from tests.benchmark.scenarios.nova import test_utils +from tests import fakes NOVA_SERVERS = "rally.benchmark.scenarios.nova.servers.NovaServers" @@ -53,9 +53,9 @@ class NovaServersTestCase(test.TestCase): kwargs = {'fakearg': 'f'} expected_kwargs = {'fakearg': 'f'} - fc = test_utils.FakeClients() + fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc - nova = test_utils.FakeNovaClient() + nova = fakes.FakeNovaClient() fc.get_nova_client = lambda: nova temp_keys = ["username", "password", "tenant_name", "uri"] @@ -239,7 +239,7 @@ class NovaServersTestCase(test.TestCase): mock_random_name): fake_server = object() - fake_image = test_utils.FakeImageManager().create() + fake_image = fakes.FakeImageManager().create() fake_image.id = "image_id" mock_random_name.return_value = "random_name" diff --git a/tests/benchmark/scenarios/nova/test_utils.py b/tests/benchmark/scenarios/nova/test_utils.py index 7c15835b71..00fdabcd2c 100644 --- a/tests/benchmark/scenarios/nova/test_utils.py +++ b/tests/benchmark/scenarios/nova/test_utils.py @@ -1,3 +1,4 @@ +# Copyright 2013: Mirantis Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may @@ -13,327 +14,12 @@ # under the License. import mock -import uuid -from novaclient import exceptions from rally.benchmark.scenarios.nova import utils from rally.benchmark import utils as butils from rally import exceptions as rally_exceptions from rally import test - - -# NOTE(msdubov): A set of 'Fake' classes below is of great use in the test case -# for utils and also in the test cases for bechmark scenarios. - - -class FakeResource(object): - - def __init__(self, manager=None): - self.name = uuid.uuid4() - self.status = "ACTIVE" - self.manager = manager - self.uuid = uuid.uuid4() - self.id = self.uuid - - def __getattr__(self, name): - # NOTE(msdubov): e.g. server.delete() -> manager.delete(server) - def manager_func(*args, **kwargs): - getattr(self.manager, name)(self, *args, **kwargs) - return manager_func - - -class FakeServer(FakeResource): - - def __init__(self, manager=None): - super(FakeServer, self).__init__(manager) - - def suspend(self): - self.status = "SUSPENDED" - - -class FakeFailedServer(FakeResource): - - def __init__(self, manager=None): - super(FakeFailedServer, self).__init__(manager) - self.status = "ERROR" - - -class FakeImage(FakeResource): - - def __init__(self, manager=None): - super(FakeImage, self).__init__(manager) - - -class FakeFloatingIP(FakeResource): - pass - - -class FakeTenant(FakeResource): - pass - - -class FakeUser(FakeResource): - pass - - -class FakeNetwork(FakeResource): - pass - - -class FakeKeypair(FakeResource): - pass - - -class FakeSecurityGroup(FakeResource): - pass - - -class FakeVolume(FakeResource): - pass - - -class FakeVolumeType(FakeResource): - pass - - -class FakeVolumeTransfer(FakeResource): - pass - - -class FakeVolumeSnapshot(FakeResource): - pass - - -class FakeVolumeBackup(FakeResource): - pass - - -class FakeManager(object): - - def __init__(self): - super(FakeManager, self).__init__() - self.cache = {} - - def get(self, resource): - uuid = getattr(resource, 'uuid', None) or resource - return self.cache.get(uuid, None) - - def delete(self, resource): - cached = self.get(resource) - if cached is not None: - del self.cache[cached.uuid] - - def _cache(self, resource): - self.cache[resource.uuid] = resource - return resource - - def list(self, **kwargs): - resources = [] - for uuid in self.cache.keys(): - resources.append(self.cache[uuid]) - return resources - - -class FakeServerManager(FakeManager): - - def __init__(self, image_mgr=None): - super(FakeServerManager, self).__init__() - self.images = image_mgr or FakeImageManager() - - def get(self, resource): - server = self.cache.get(resource.uuid, None) - if server is not None: - return server - raise exceptions.NotFound("Server %s not found" % (resource.name)) - - def _create(self, server_class=FakeServer, name=None): - server = self._cache(server_class(self)) - if name is not None: - server.name = name - return server - - def create(self, name, image_id, flavor_id): - return self._create(name=name) - - def create_image(self, server, name): - image = self.images.create() - return image.uuid - - def add_floating_ip(self, server, fip): - pass - - def remove_floating_ip(self, server, fip): - pass - - -class FakeFailedServerManager(FakeServerManager): - - def create(self, name, image_id, flavor_id): - return self._create(FakeFailedServer, name) - - -class FakeImageManager(FakeManager): - - def create(self): - return self._cache(FakeImage(self)) - - def delete(self, image): - cached = self.cache.get(image.uuid, None) - if cached is not None: - cached.status = "DELETED" - - -class FakeFloatingIPsManager(FakeManager): - - def create(self): - return FakeFloatingIP(self) - - -class FakeTenantsManager(FakeManager): - - def create(self, name): - return FakeTenant(self) - - -class FakeNetworkManager(FakeManager): - - def create(self, net_id): - net = FakeNetwork(self) - net.id = net_id - return self._cache(net) - - -class FakeKeypairManager(FakeManager): - - def create(self, name): - kp = FakeKeypair(self) - kp.name = name or kp.name - return self._cache(kp) - - -class FakeSecurityGroupManager(FakeManager): - - def create(self, name): - sg = FakeSecurityGroup(self) - sg.name = name or sg.name - return self._cache(sg) - - -class FakeUsersManager(FakeManager): - - def create(self, username, password, email, tenant_id): - return FakeUser(self) - - -class FakeVolumeManager(FakeManager): - - def create(self, name=None): - volume = FakeVolume(self) - volume.name = name or volume.name - return self._cache(volume) - - -class FakeVolumeTypeManager(FakeManager): - - def create(self, name): - vol_type = FakeVolumeType(self) - vol_type.name = name or vol_type.name - return self._cache(vol_type) - - -class FakeVolumeTransferManager(FakeManager): - - def create(self, name): - transfer = FakeVolumeTransfer(self) - transfer.name = name or transfer.name - return self._cache(transfer) - - -class FakeVolumeSnapshotManager(FakeManager): - - def create(self, name): - snapshot = FakeVolumeSnapshot(self) - snapshot.name = name or snapshot.name - return self._cache(snapshot) - - -class FakeVolumeBackupManager(FakeManager): - - def create(self, name): - backup = FakeVolumeBackup(self) - backup.name = name or backup.name - return self._cache(backup) - - -class FakeGlanceClient(object): - - def __init__(self, nova_client): - self.images = nova_client.images - - -class FakeCinderClient(object): - - def __init__(self): - self.volumes = FakeVolumeManager() - self.volume_types = FakeVolumeTypeManager() - self.transfers = FakeVolumeTransferManager() - self.volume_snapshots = FakeVolumeSnapshotManager() - self.backups = FakeVolumeBackupManager() - - -class FakeNovaClient(object): - - def __init__(self, failed_server_manager=False): - self.images = FakeImageManager() - if failed_server_manager: - self.servers = FakeFailedServerManager(self.images) - else: - self.servers = FakeServerManager(self.images) - self.floating_ips = FakeFloatingIPsManager() - self.networks = FakeNetworkManager() - self.keypairs = FakeKeypairManager() - self.security_groups = FakeSecurityGroupManager() - - -class FakeKeystoneClient(object): - - def __init__(self): - self.tenants = FakeTenantsManager() - self.users = FakeUsersManager() - self.project_id = 'abc123' - - -class FakeClients(object): - - def __init__(self): - self.nova = None - self.glance = None - self.keystone = None - self.cinder = None - - def get_keystone_client(self): - if self.keystone is not None: - return self.keystone - self.keystone = FakeKeystoneClient() - return self.keystone - - def get_nova_client(self): - if self.nova is not None: - return self.nova - self.nova = FakeNovaClient() - return self.nova - - def get_glance_client(self): - if self.glance is not None: - return self.glance - self.glance = FakeGlanceClient(self.get_nova_client()) - return self.glance - - def get_cinder_client(self): - if self.cinder is not None: - return self.cinder - self.cinder = FakeCinderClient() - return self.cinder +from tests import fakes class NovaScenarioTestCase(test.TestCase): @@ -348,7 +34,7 @@ class NovaScenarioTestCase(test.TestCase): self.assertTrue(name.isalpha()) def test_failed_server_status(self): - server_manager = FakeFailedServerManager() + server_manager = fakes.FakeFailedServerManager() self.assertRaises(rally_exceptions.GetResourceFailure, butils.get_from_manager(), server_manager.create('fails', '1', '2')) @@ -366,11 +52,11 @@ class NovaScenarioTestCase(test.TestCase): mock_ris.return_value = _is_ready get_from_mgr = butils.get_from_manager() - fc = FakeClients() + fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc - fake_nova = FakeNovaClient() + fake_nova = fakes.FakeNovaClient() fc.get_nova_client = lambda: fake_nova - fsm = FakeServerManager(fake_nova.images) + fsm = fakes.FakeServerManager(fake_nova.images) fake_server = fsm.create("s1", "i1", 1) fsm.create = lambda name, iid, fid: fake_server fake_nova.servers = fsm diff --git a/tests/benchmark/test_test_engine.py b/tests/benchmark/test_test_engine.py index 1256f65c44..b2b8645cbe 100644 --- a/tests/benchmark/test_test_engine.py +++ b/tests/benchmark/test_test_engine.py @@ -22,7 +22,7 @@ from rally.benchmark import engine from rally import consts from rally import exceptions from rally import test -from tests.benchmark.scenarios.nova import test_utils +from tests import fakes class TestEngineTestCase(test.TestCase): @@ -156,7 +156,7 @@ class TestEngineTestCase(test.TestCase): @mock.patch("rally.benchmark.utils.ScenarioRunner.run") @mock.patch("rally.benchmark.utils.osclients") def test_benchmark(self, mock_osclients, mock_run): - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() tester = engine.TestEngine(self.valid_test_config_continuous_times, mock.MagicMock()) with tester.bind(self.valid_cloud_config): @@ -170,7 +170,7 @@ class TestEngineTestCase(test.TestCase): fake_task = mock.MagicMock() tester = engine.TestEngine(self.valid_test_config_continuous_times, fake_task) - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() mock_run.return_value = self.run_success mock_scenario_run.return_value = {} with tester.bind(self.valid_cloud_config): @@ -206,7 +206,7 @@ class TestEngineTestCase(test.TestCase): fake_task = mock.MagicMock() tester = engine.TestEngine(self.valid_test_config_continuous_times, fake_task) - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() mock_run.return_value = self.run_success mock_scenario_run.side_effect = exceptions.TestException() try: diff --git a/tests/benchmark/test_utils.py b/tests/benchmark/test_utils.py index ce423fb2f6..523fd0bea9 100644 --- a/tests/benchmark/test_utils.py +++ b/tests/benchmark/test_utils.py @@ -20,37 +20,10 @@ import os import tempfile import time -from rally.benchmark import base from rally.benchmark import config from rally.benchmark import utils from rally import test -from rally import utils as rally_utils -from tests.benchmark.scenarios.nova import test_utils - - -class FakeScenario(base.Scenario): - - @classmethod - def class_init(cls, endpoints): - pass - - @classmethod - def do_it(cls, **kwargs): - pass - - @classmethod - def too_long(cls, **kwargs): - pass - - @classmethod - def something_went_wrong(cls, **kwargs): - raise Exception("Something went wrong") - - -class FakeTimer(rally_utils.Timer): - - def duration(self): - return 10 +from tests import fakes class MockedPool(object): @@ -78,7 +51,7 @@ class ScenarioTestCase(test.TestCase): def test_init_calls_register(self): with mock.patch("rally.benchmark.utils.osclients") as mock_osclients: - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() with mock.patch("rally.benchmark.utils.base") as mock_base: utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) self.assertEqual(mock_base.mock_calls, @@ -86,7 +59,7 @@ class ScenarioTestCase(test.TestCase): def test_create_temp_tenants_and_users(self): with mock.patch("rally.benchmark.utils.osclients") as mock_osclients: - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) tenants = 10 users_per_tenant = 5 @@ -99,7 +72,7 @@ class ScenarioTestCase(test.TestCase): def test_run_scenario(self): with mock.patch("rally.benchmark.utils.osclients") as mock_osclients: - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() with mock.patch("rally.benchmark.utils.utils") as mock_utils: runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) utils.__openstack_clients__ = ["client"] @@ -107,9 +80,9 @@ class ScenarioTestCase(test.TestCase): times = 3 duration = 0.01 - mock_utils.Timer = FakeTimer - results = runner._run_scenario(FakeScenario, "do_it", {}, - "continuous", + mock_utils.Timer = fakes.FakeTimer + results = runner._run_scenario(fakes.FakeScenario, + "do_it", {}, "continuous", {"times": times, "active_users": active_users, "timeout": 2}) @@ -117,8 +90,8 @@ class ScenarioTestCase(test.TestCase): for i in range(times)] self.assertEqual(results, expected) - results = runner._run_scenario(FakeScenario, "do_it", {}, - "continuous", + results = runner._run_scenario(fakes.FakeScenario, + "do_it", {}, "continuous", {"duration": duration, "active_users": active_users, "timeout": 2}) @@ -132,13 +105,13 @@ class ScenarioTestCase(test.TestCase): def test_run_scenario_timeout(self, mock_time, mock_next, mock_osclients): mock_time.side_effect = [1, 2, 3, 10] mock_next.side_effect = multiprocessing.TimeoutError() - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) utils.__openstack_clients__ = ["client"] times = 4 active_users = 2 - results = runner._run_scenario(FakeScenario, "too_long", {}, - "continuous", + results = runner._run_scenario(fakes.FakeScenario, + "too_long", {}, "continuous", {"times": times, "active_users": active_users, "timeout": 0.01}) @@ -149,8 +122,8 @@ class ScenarioTestCase(test.TestCase): str(multiprocessing.TimeoutError)) duration = 0.1 - results = runner._run_scenario(FakeScenario, "too_long", {}, - "continuous", + results = runner._run_scenario(fakes.FakeScenario, + "too_long", {}, "continuous", {"duration": duration, "active_users": active_users, "timeout": 0.01}) @@ -162,15 +135,15 @@ class ScenarioTestCase(test.TestCase): def test_run_scenario_exception_inside_test(self): with mock.patch("rally.benchmark.utils.osclients") as mock_osclients: - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) utils.__openstack_clients__ = ["client"] times = 1 duration = 0.01 active_users = 2 with mock.patch("rally.benchmark.utils.utils") as mock_utils: - mock_utils.Timer = FakeTimer - results = runner._run_scenario(FakeScenario, + mock_utils.Timer = fakes.FakeTimer + results = runner._run_scenario(fakes.FakeScenario, "something_went_wrong", {}, "continuous", {"times": times, @@ -182,7 +155,7 @@ class ScenarioTestCase(test.TestCase): self.assertEqual(r['error'][:2], [str(Exception), "Something went wrong"]) - results = runner._run_scenario(FakeScenario, + results = runner._run_scenario(fakes.FakeScenario, "something_went_wrong", {}, "continuous", {"duration": duration, @@ -201,21 +174,22 @@ class ScenarioTestCase(test.TestCase): @mock.patch("rally.benchmark.utils.osclients") def test_run_scenario_continuously_for_times(self, mock_osclients, mock_multi): - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) utils.__openstack_clients__ = ["client"] times = 3 active_users = 4 timeout = 5 mock_multi.Pool = mock.MagicMock() - runner._run_scenario_continuously_for_times(FakeScenario, "do_it", {}, + runner._run_scenario_continuously_for_times(fakes.FakeScenario, + "do_it", {}, times, active_users, timeout) expect = [ mock.call(active_users), mock.call().imap( utils._run_scenario_loop, - [(i, FakeScenario, "do_it", {}) + [(i, fakes.FakeScenario, "do_it", {}) for i in xrange(times)] ) ] @@ -231,7 +205,7 @@ class ScenarioTestCase(test.TestCase): @mock.patch("rally.benchmark.utils.osclients") def test_run_scenario_continuously_for_duration(self, mock_osclients, mock_multi, mock_generate): - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) utils.__openstack_clients__ = ["client"] duration = 0 @@ -239,7 +213,7 @@ class ScenarioTestCase(test.TestCase): timeout = 5 mock_multi.Pool = mock.MagicMock() mock_generate.return_value = {} - runner._run_scenario_continuously_for_duration(FakeScenario, + runner._run_scenario_continuously_for_duration(fakes.FakeScenario, "do_it", {}, duration, active_users, timeout) expect = [ @@ -258,7 +232,7 @@ class ScenarioTestCase(test.TestCase): FakeScenario = mock.MagicMock() FakeScenario.init = mock.MagicMock(return_value={}) - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) runner._run_scenario_continuously_for_times = \ mock.MagicMock(return_value="result") @@ -293,7 +267,7 @@ class ScenarioTestCase(test.TestCase): FakeScenario = mock.MagicMock() FakeScenario.init = mock.MagicMock(return_value={}) - mock_osclients.Clients.return_value = test_utils.FakeClients() + mock_osclients.Clients.return_value = fakes.FakeClients() runner = utils.ScenarioRunner(mock.MagicMock(), self.fake_kw) runner._run_scenario = mock.MagicMock(return_value="result") runner._create_temp_tenants_and_users = mock.MagicMock( @@ -349,8 +323,8 @@ class ScenarioTestCase(test.TestCase): FakeScenario = mock.MagicMock() FakeScenario.init = mock.MagicMock(return_value={}) - mock_cms = [test_utils.FakeClients(), test_utils.FakeClients(), - test_utils.FakeClients()] + mock_cms = [fakes.FakeClients(), fakes.FakeClients(), + fakes.FakeClients()] clients = [ dict(( ("nova", cl.get_nova_client()), diff --git a/tests/fakes.py b/tests/fakes.py new file mode 100644 index 0000000000..2094d1e874 --- /dev/null +++ b/tests/fakes.py @@ -0,0 +1,355 @@ +# Copyright 2013: Mirantis Inc. +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. + +import uuid + +from novaclient import exceptions +from rally.benchmark import base +from rally import utils as rally_utils + + +class FakeResource(object): + + def __init__(self, manager=None): + self.name = uuid.uuid4() + self.status = "ACTIVE" + self.manager = manager + self.uuid = uuid.uuid4() + self.id = self.uuid + + def __getattr__(self, name): + # NOTE(msdubov): e.g. server.delete() -> manager.delete(server) + def manager_func(*args, **kwargs): + getattr(self.manager, name)(self, *args, **kwargs) + return manager_func + + +class FakeServer(FakeResource): + + def __init__(self, manager=None): + super(FakeServer, self).__init__(manager) + + def suspend(self): + self.status = "SUSPENDED" + + +class FakeFailedServer(FakeResource): + + def __init__(self, manager=None): + super(FakeFailedServer, self).__init__(manager) + self.status = "ERROR" + + +class FakeImage(FakeResource): + + def __init__(self, manager=None): + super(FakeImage, self).__init__(manager) + + +class FakeFloatingIP(FakeResource): + pass + + +class FakeTenant(FakeResource): + pass + + +class FakeUser(FakeResource): + pass + + +class FakeNetwork(FakeResource): + pass + + +class FakeKeypair(FakeResource): + pass + + +class FakeSecurityGroup(FakeResource): + pass + + +class FakeVolume(FakeResource): + pass + + +class FakeVolumeType(FakeResource): + pass + + +class FakeVolumeTransfer(FakeResource): + pass + + +class FakeVolumeSnapshot(FakeResource): + pass + + +class FakeVolumeBackup(FakeResource): + pass + + +class FakeManager(object): + + def __init__(self): + super(FakeManager, self).__init__() + self.cache = {} + + def get(self, resource): + uuid = getattr(resource, 'uuid', None) or resource + return self.cache.get(uuid, None) + + def delete(self, resource): + cached = self.get(resource) + if cached is not None: + del self.cache[cached.uuid] + + def _cache(self, resource): + self.cache[resource.uuid] = resource + return resource + + def list(self, **kwargs): + resources = [] + for uuid in self.cache.keys(): + resources.append(self.cache[uuid]) + return resources + + +class FakeServerManager(FakeManager): + + def __init__(self, image_mgr=None): + super(FakeServerManager, self).__init__() + self.images = image_mgr or FakeImageManager() + + def get(self, resource): + server = self.cache.get(resource.uuid, None) + if server is not None: + return server + raise exceptions.NotFound("Server %s not found" % (resource.name)) + + def _create(self, server_class=FakeServer, name=None): + server = self._cache(server_class(self)) + if name is not None: + server.name = name + return server + + def create(self, name, image_id, flavor_id): + return self._create(name=name) + + def create_image(self, server, name): + image = self.images.create() + return image.uuid + + def add_floating_ip(self, server, fip): + pass + + def remove_floating_ip(self, server, fip): + pass + + +class FakeFailedServerManager(FakeServerManager): + + def create(self, name, image_id, flavor_id): + return self._create(FakeFailedServer, name) + + +class FakeImageManager(FakeManager): + + def create(self): + return self._cache(FakeImage(self)) + + def delete(self, image): + cached = self.cache.get(image.uuid, None) + if cached is not None: + cached.status = "DELETED" + + +class FakeFloatingIPsManager(FakeManager): + + def create(self): + return FakeFloatingIP(self) + + +class FakeTenantsManager(FakeManager): + + def create(self, name): + return FakeTenant(self) + + +class FakeNetworkManager(FakeManager): + + def create(self, net_id): + net = FakeNetwork(self) + net.id = net_id + return self._cache(net) + + +class FakeKeypairManager(FakeManager): + + def create(self, name): + kp = FakeKeypair(self) + kp.name = name or kp.name + return self._cache(kp) + + +class FakeSecurityGroupManager(FakeManager): + + def create(self, name): + sg = FakeSecurityGroup(self) + sg.name = name or sg.name + return self._cache(sg) + + +class FakeUsersManager(FakeManager): + + def create(self, username, password, email, tenant_id): + return FakeUser(self) + + +class FakeVolumeManager(FakeManager): + + def create(self, name=None): + volume = FakeVolume(self) + volume.name = name or volume.name + return self._cache(volume) + + +class FakeVolumeTypeManager(FakeManager): + + def create(self, name): + vol_type = FakeVolumeType(self) + vol_type.name = name or vol_type.name + return self._cache(vol_type) + + +class FakeVolumeTransferManager(FakeManager): + + def create(self, name): + transfer = FakeVolumeTransfer(self) + transfer.name = name or transfer.name + return self._cache(transfer) + + +class FakeVolumeSnapshotManager(FakeManager): + + def create(self, name): + snapshot = FakeVolumeSnapshot(self) + snapshot.name = name or snapshot.name + return self._cache(snapshot) + + +class FakeVolumeBackupManager(FakeManager): + + def create(self, name): + backup = FakeVolumeBackup(self) + backup.name = name or backup.name + return self._cache(backup) + + +class FakeGlanceClient(object): + + def __init__(self, nova_client): + self.images = nova_client.images + + +class FakeCinderClient(object): + + def __init__(self): + self.volumes = FakeVolumeManager() + self.volume_types = FakeVolumeTypeManager() + self.transfers = FakeVolumeTransferManager() + self.volume_snapshots = FakeVolumeSnapshotManager() + self.backups = FakeVolumeBackupManager() + + +class FakeNovaClient(object): + + def __init__(self, failed_server_manager=False): + self.images = FakeImageManager() + if failed_server_manager: + self.servers = FakeFailedServerManager(self.images) + else: + self.servers = FakeServerManager(self.images) + self.floating_ips = FakeFloatingIPsManager() + self.networks = FakeNetworkManager() + self.keypairs = FakeKeypairManager() + self.security_groups = FakeSecurityGroupManager() + + +class FakeKeystoneClient(object): + + def __init__(self): + self.tenants = FakeTenantsManager() + self.users = FakeUsersManager() + self.project_id = 'abc123' + + +class FakeClients(object): + + def __init__(self): + self.nova = None + self.glance = None + self.keystone = None + self.cinder = None + + def get_keystone_client(self): + if self.keystone is not None: + return self.keystone + self.keystone = FakeKeystoneClient() + return self.keystone + + def get_nova_client(self): + if self.nova is not None: + return self.nova + self.nova = FakeNovaClient() + return self.nova + + def get_glance_client(self): + if self.glance is not None: + return self.glance + self.glance = FakeGlanceClient(self.get_nova_client()) + return self.glance + + def get_cinder_client(self): + if self.cinder is not None: + return self.cinder + self.cinder = FakeCinderClient() + return self.cinder + + +class FakeScenario(base.Scenario): + + @classmethod + def class_init(cls, endpoints): + pass + + @classmethod + def do_it(cls, **kwargs): + pass + + @classmethod + def too_long(cls, **kwargs): + pass + + @classmethod + def something_went_wrong(cls, **kwargs): + raise Exception("Something went wrong") + + +class FakeTimer(rally_utils.Timer): + + def duration(self): + return 10