From 65d1158526d9597506bf1d29e8a219e76ce6866b Mon Sep 17 00:00:00 2001 From: Clinton Knight Date: Wed, 28 Jan 2015 14:35:02 -0500 Subject: [PATCH] Replace legacy StubOutForTesting class The Manila test module uses a class called StubOutForTesting, which is an awkward holdover from when the unit tests were using Mox. Alex wrote a more elegant and capable mocker method, manila.test.TestCase.mock_object, in the Cinder project which we have now added to Manila. So to remove the duplicate functionality and legacy code, all references to self.stubs.Set() in the Manila tests should be replaced with self.mock_object() and any related dead code should be removed. Resolves-bug: #1415602 Change-Id: Ie5f203c0b2cb57ad00d9ec8db0529075b6fef261 --- manila/test.py | 15 +- .../tests/api/contrib/test_admin_actions.py | 14 +- manila/tests/api/contrib/test_services.py | 12 +- .../tests/api/contrib/test_share_actions.py | 21 +- .../api/contrib/test_types_extra_specs.py | 74 +-- manila/tests/api/contrib/test_types_manage.py | 16 +- manila/tests/api/fakes.py | 28 -- manila/tests/api/v1/test_limits.py | 6 +- manila/tests/api/v1/test_security_service.py | 2 +- manila/tests/api/v1/test_share_metadata.py | 129 +++-- manila/tests/api/v1/test_share_servers.py | 52 +- manila/tests/api/v1/test_share_snapshots.py | 42 +- manila/tests/api/v1/test_shares.py | 67 +-- manila/tests/api/v1/test_volume_types.py | 16 +- manila/tests/compute/test_nova.py | 53 +-- manila/tests/fake_notifier.py | 11 +- manila/tests/fake_utils.py | 4 +- .../tests/network/neutron/test_neutron_api.py | 53 +-- .../network/neutron/test_neutron_plugin.py | 10 +- manila/tests/scheduler/test_host_filters.py | 2 +- manila/tests/scheduler/test_host_manager.py | 2 +- manila/tests/scheduler/test_scheduler.py | 2 +- manila/tests/share/drivers/emc/test_driver.py | 2 +- .../tests/share/drivers/emc/test_emc_vnx.py | 2 +- .../share/drivers/ganesha/test_manager.py | 171 +++---- .../tests/share/drivers/ganesha/test_utils.py | 4 +- .../share/drivers/huawei/test_huawei_nas.py | 2 +- .../share/drivers/ibm/test_ganesha_utils.py | 34 +- manila/tests/share/drivers/ibm/test_gpfs.py | 61 +-- .../share/drivers/netapp/test_cluster_mode.py | 110 +++-- manila/tests/share/drivers/test_ganesha.py | 72 +-- manila/tests/share/drivers/test_generic.py | 384 ++++++++------- manila/tests/share/drivers/test_glusterfs.py | 137 +++--- .../share/drivers/test_glusterfs_native.py | 53 +-- .../share/drivers/test_service_instance.py | 446 +++++++++--------- .../share/drivers/zfssa/test_zfssarest.py | 38 +- .../share/drivers/zfssa/test_zfssashare.py | 22 +- manila/tests/share/test_api.py | 139 +++--- manila/tests/share/test_driver.py | 14 +- manila/tests/share/test_manager.py | 224 +++++---- manila/tests/share/test_rpcapi.py | 4 +- manila/tests/share/test_volume_types.py | 30 +- manila/tests/test_context.py | 2 +- manila/tests/test_quota.py | 52 +- manila/tests/test_utils.py | 4 +- manila/tests/volume/test_cinder.py | 37 +- 46 files changed, 1311 insertions(+), 1364 deletions(-) diff --git a/manila/test.py b/manila/test.py index 8a9d3968..0f198c4e 100644 --- a/manila/test.py +++ b/manila/test.py @@ -101,16 +101,6 @@ class Database(fixtures.Fixture): db_migrate.stamp('head') -class StubOutForTesting(object): - def __init__(self, parent): - self.parent = parent - - def Set(self, obj, attr_name, new_attr): - stub = mock.patch.object(obj, attr_name, new_attr) - stub.start() - self.parent.addCleanup(stub.stop) - - class TestCase(base_test.BaseTestCase): """Test case base class for all unit tests.""" @@ -132,7 +122,6 @@ class TestCase(base_test.BaseTestCase): ) self.useFixture(_DB_CACHE) - self.stubs = StubOutForTesting(self) self.injected = [] self._services = [] self.flags(fatal_exception_format_errors=True) @@ -153,7 +142,7 @@ class TestCase(base_test.BaseTestCase): self.useFixture(self.messaging_conf) rpc.init(CONF) - fake_notifier.stub_notifier(self.stubs) + fake_notifier.stub_notifier(self) def tearDown(self): """Runs after each test method to tear down test environment.""" @@ -195,12 +184,12 @@ class TestCase(base_test.BaseTestCase): self._services.append(svc) return svc - # TODO(cknight): StubOutForTesting should be removed in favor of this. def mock_object(self, obj, attr_name, new_attr=None, **kwargs): """Use python mock to mock an object attribute Mocks the specified objects attribute with the given value. Automatically performs 'addCleanup' for the mock. + """ if not new_attr: new_attr = mock.Mock() diff --git a/manila/tests/api/contrib/test_admin_actions.py b/manila/tests/api/contrib/test_admin_actions.py index 7952086f..1cd9c77a 100644 --- a/manila/tests/api/contrib/test_admin_actions.py +++ b/manila/tests/api/contrib/test_admin_actions.py @@ -207,9 +207,10 @@ class AdminActionsTest(test.TestCase): def test_admin_force_delete_snapshot(self): snapshot = stubs.stub_snapshot(1, host='foo') - self.stubs.Set(db, 'share_get', lambda x, y: snapshot) - self.stubs.Set(db, 'share_snapshot_get', lambda x, y: snapshot) - self.stubs.Set(share_api.API, 'delete_snapshot', lambda *x, **y: True) + self.mock_object(db, 'share_get', lambda x, y: snapshot) + self.mock_object(db, 'share_snapshot_get', lambda x, y: snapshot) + self.mock_object(share_api.API, 'delete_snapshot', + lambda *x, **y: True) path = '/v1/fake/snapshots/%s/action' % snapshot['id'] req = webob.Request.blank(path) req.method = 'POST' @@ -221,9 +222,10 @@ class AdminActionsTest(test.TestCase): def test_member_force_delete_snapshot(self): snapshot = stubs.stub_snapshot(1, host='foo') - self.stubs.Set(db, 'share_get', lambda x, y: snapshot) - self.stubs.Set(db, 'share_snapshot_get', lambda x, y: snapshot) - self.stubs.Set(share_api.API, 'delete_snapshot', lambda *x, **y: True) + self.mock_object(db, 'share_get', lambda x, y: snapshot) + self.mock_object(db, 'share_snapshot_get', lambda x, y: snapshot) + self.mock_object(share_api.API, 'delete_snapshot', + lambda *x, **y: True) path = '/v1/fake/snapshots/%s/action' % snapshot['id'] req = webob.Request.blank(path) req.method = 'POST' diff --git a/manila/tests/api/contrib/test_services.py b/manila/tests/api/contrib/test_services.py index c62dd495..a81dde10 100644 --- a/manila/tests/api/contrib/test_services.py +++ b/manila/tests/api/contrib/test_services.py @@ -180,12 +180,12 @@ class ServicesTest(test.TestCase): def setUp(self): super(ServicesTest, self).setUp() - self.stubs.Set(db, "service_get_all", fake_service_get_all) - self.stubs.Set(timeutils, "utcnow", fake_utcnow) - self.stubs.Set(db, "service_get_by_args", - fake_service_get_by_host_binary) - self.stubs.Set(db, "service_update", fake_service_update) - self.stubs.Set(policy, "enforce", fake_policy_enforce) + self.mock_object(db, "service_get_all", fake_service_get_all) + self.mock_object(timeutils, "utcnow", fake_utcnow) + self.mock_object(db, "service_get_by_args", + fake_service_get_by_host_binary) + self.mock_object(db, "service_update", fake_service_update) + self.mock_object(policy, "enforce", fake_policy_enforce) self.context = context.get_admin_context() self.controller = services.ServiceController() diff --git a/manila/tests/api/contrib/test_share_actions.py b/manila/tests/api/contrib/test_share_actions.py index 93019b36..be8dcedf 100644 --- a/manila/tests/api/contrib/test_share_actions.py +++ b/manila/tests/api/contrib/test_share_actions.py @@ -48,12 +48,12 @@ class ShareActionsTest(test.TestCase): super(ShareActionsTest, self).setUp() self.controller = share_actions.ShareActionsController() - self.stubs.Set(share_api.API, 'get', stubs.stub_share_get) + self.mock_object(share_api.API, 'get', stubs.stub_share_get) def test_allow_access(self): def _stub_allow_access(*args, **kwargs): return {'fake': 'fake'} - self.stubs.Set(share_api.API, "allow_access", _stub_allow_access) + self.mock_object(share_api.API, "allow_access", _stub_allow_access) id = 'fake_share_id' body = { @@ -70,7 +70,7 @@ class ShareActionsTest(test.TestCase): def test_allow_access_cert_min_accessto(self): def _stub_allow_access(*args, **kwargs): return {'fake': 'fake'} - self.stubs.Set(share_api.API, "allow_access", _stub_allow_access) + self.mock_object(share_api.API, "allow_access", _stub_allow_access) body = { "os-allow_access": { @@ -86,7 +86,7 @@ class ShareActionsTest(test.TestCase): def test_allow_access_cert_typical_accessto(self): def _stub_allow_access(*args, **kwargs): return {'fake': 'fake'} - self.stubs.Set(share_api.API, "allow_access", _stub_allow_access) + self.mock_object(share_api.API, "allow_access", _stub_allow_access) body = { "os-allow_access": { @@ -102,7 +102,7 @@ class ShareActionsTest(test.TestCase): def test_allow_access_cert_max_accessto(self): def _stub_allow_access(*args, **kwargs): return {'fake': 'fake'} - self.stubs.Set(share_api.API, "allow_access", _stub_allow_access) + self.mock_object(share_api.API, "allow_access", _stub_allow_access) access_to = 'x' * 64 body = { @@ -204,8 +204,8 @@ class ShareActionsTest(test.TestCase): def _stub_deny_access(*args, **kwargs): pass - self.stubs.Set(share_api.API, "deny_access", _stub_deny_access) - self.stubs.Set(share_api.API, "access_get", _fake_access_get) + self.mock_object(share_api.API, "deny_access", _stub_deny_access) + self.mock_object(share_api.API, "access_get", _fake_access_get) id = 'fake_share_id' body = {"os-deny_access": {"access_id": 'fake_acces_id'}} @@ -217,8 +217,8 @@ class ShareActionsTest(test.TestCase): def _stub_deny_access(*args, **kwargs): pass - self.stubs.Set(share_api.API, "deny_access", _stub_deny_access) - self.stubs.Set(share_api.API, "access_get", _fake_access_get) + self.mock_object(share_api.API, "deny_access", _stub_deny_access) + self.mock_object(share_api.API, "access_get", _fake_access_get) id = 'super_fake_share_id' body = {"os-deny_access": {"access_id": 'fake_acces_id'}} @@ -236,7 +236,8 @@ class ShareActionsTest(test.TestCase): "access_type": "fakeip", "access_to": "127.0.0.1"}] - self.stubs.Set(share_api.API, "access_get_all", _fake_access_get_all) + self.mock_object(share_api.API, "access_get_all", + _fake_access_get_all) id = 'fake_share_id' body = {"os-access_list": None} req = fakes.HTTPRequest.blank('/v1/tenant1/shares/%s/action' % id) diff --git a/manila/tests/api/contrib/test_types_extra_specs.py b/manila/tests/api/contrib/test_types_extra_specs.py index ea5591b3..afe2aba8 100644 --- a/manila/tests/api/contrib/test_types_extra_specs.py +++ b/manila/tests/api/contrib/test_types_extra_specs.py @@ -65,7 +65,7 @@ class VolumeTypesExtraSpecsTest(test.TestCase): def setUp(self): super(VolumeTypesExtraSpecsTest, self).setUp() self.flags(host='fake') - self.stubs.Set(manila.db, 'volume_type_get', volume_type_get) + self.mock_object(manila.db, 'volume_type_get', volume_type_get) self.api_path = '/v2/fake/os-volume-types/1/extra_specs' self.controller = types_extra_specs.VolumeTypeExtraSpecsController() @@ -74,8 +74,8 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.addCleanup(fake_notifier.reset) def test_index(self): - self.stubs.Set(manila.db, 'volume_type_extra_specs_get', - return_volume_type_extra_specs) + self.mock_object(manila.db, 'volume_type_extra_specs_get', + return_volume_type_extra_specs) req = fakes.HTTPRequest.blank(self.api_path) res_dict = self.controller.index(req, 1) @@ -83,8 +83,8 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.assertEqual('value1', res_dict['extra_specs']['key1']) def test_index_no_data(self): - self.stubs.Set(manila.db, 'volume_type_extra_specs_get', - return_empty_volume_type_extra_specs) + self.mock_object(manila.db, 'volume_type_extra_specs_get', + return_empty_volume_type_extra_specs) req = fakes.HTTPRequest.blank(self.api_path) res_dict = self.controller.index(req, 1) @@ -92,8 +92,8 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.assertEqual(0, len(res_dict['extra_specs'])) def test_show(self): - self.stubs.Set(manila.db, 'volume_type_extra_specs_get', - return_volume_type_extra_specs) + self.mock_object(manila.db, 'volume_type_extra_specs_get', + return_volume_type_extra_specs) req = fakes.HTTPRequest.blank(self.api_path + '/key5') res_dict = self.controller.show(req, 1, 'key5') @@ -101,16 +101,16 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.assertEqual('value5', res_dict['key5']) def test_show_spec_not_found(self): - self.stubs.Set(manila.db, 'volume_type_extra_specs_get', - return_empty_volume_type_extra_specs) + self.mock_object(manila.db, 'volume_type_extra_specs_get', + return_empty_volume_type_extra_specs) req = fakes.HTTPRequest.blank(self.api_path + '/key6') self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, req, 1, 'key6') def test_delete(self): - self.stubs.Set(manila.db, 'volume_type_extra_specs_delete', - delete_volume_type_extra_specs) + self.mock_object(manila.db, 'volume_type_extra_specs_delete', + delete_volume_type_extra_specs) self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0) req = fakes.HTTPRequest.blank(self.api_path + '/key5') @@ -118,17 +118,17 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.assertEqual(len(fake_notifier.NOTIFICATIONS), 1) def test_delete_not_found(self): - self.stubs.Set(manila.db, 'volume_type_extra_specs_delete', - delete_volume_type_extra_specs_not_found) + self.mock_object(manila.db, 'volume_type_extra_specs_delete', + delete_volume_type_extra_specs_not_found) req = fakes.HTTPRequest.blank(self.api_path + '/key6') self.assertRaises(webob.exc.HTTPNotFound, self.controller.delete, req, 1, 'key6') def test_create(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) body = {"extra_specs": {"key1": "value1"}} self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0) @@ -139,9 +139,9 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.assertEqual('value1', res_dict['extra_specs']['key1']) def test_create_with_too_small_key(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) too_small_key = "" body = {"extra_specs": {too_small_key: "value"}} self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0) @@ -150,9 +150,9 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.controller.create, req, 1, body) def test_create_with_too_big_key(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) too_big_key = "k" * 256 body = {"extra_specs": {too_big_key: "value"}} self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0) @@ -161,9 +161,9 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.controller.create, req, 1, body) def test_create_with_too_small_value(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) too_small_value = "" body = {"extra_specs": {"key": too_small_value}} self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0) @@ -172,9 +172,9 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.controller.create, req, 1, body) def test_create_with_too_big_value(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) too_big_value = "v" * 256 body = {"extra_specs": {"key": too_big_value}} self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0) @@ -231,9 +231,9 @@ class VolumeTypesExtraSpecsTest(test.TestCase): res_dict['extra_specs']['other3_alphanum.-_:']) def test_update_item(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) body = {"key1": "value1"} self.assertEqual(len(fake_notifier.NOTIFICATIONS), 0) @@ -244,9 +244,9 @@ class VolumeTypesExtraSpecsTest(test.TestCase): self.assertEqual('value1', res_dict['key1']) def test_update_item_too_many_keys(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) body = {"key1": "value1", "key2": "value2"} req = fakes.HTTPRequest.blank(self.api_path + '/key1') @@ -254,9 +254,9 @@ class VolumeTypesExtraSpecsTest(test.TestCase): req, 1, 'key1', body) def test_update_item_body_uri_mismatch(self): - self.stubs.Set(manila.db, - 'volume_type_extra_specs_update_or_create', - return_create_volume_type_extra_specs) + self.mock_object(manila.db, + 'volume_type_extra_specs_update_or_create', + return_create_volume_type_extra_specs) body = {"key1": "value1"} req = fakes.HTTPRequest.blank(self.api_path + '/bad') diff --git a/manila/tests/api/contrib/test_types_manage.py b/manila/tests/api/contrib/test_types_manage.py index 0c42da81..c72a187c 100644 --- a/manila/tests/api/contrib/test_types_manage.py +++ b/manila/tests/api/contrib/test_types_manage.py @@ -80,14 +80,14 @@ class VolumeTypesManageApiTest(test.TestCase): """to reset notifier drivers left over from other api/contrib tests""" fake_notifier.reset() self.addCleanup(fake_notifier.reset) - self.stubs.Set(volume_types, 'create', - return_volume_types_create) - self.stubs.Set(volume_types, 'get_volume_type_by_name', - return_volume_types_get_by_name) - self.stubs.Set(volume_types, 'get_volume_type', - return_volume_types_get_volume_type) - self.stubs.Set(volume_types, 'destroy', - return_volume_types_destroy) + self.mock_object(volume_types, 'create', + return_volume_types_create) + self.mock_object(volume_types, 'get_volume_type_by_name', + return_volume_types_get_by_name) + self.mock_object(volume_types, 'get_volume_type', + return_volume_types_get_volume_type) + self.mock_object(volume_types, 'destroy', + return_volume_types_destroy) def test_volume_types_delete(self): req = fakes.HTTPRequest.blank('/v2/fake/types/1') diff --git a/manila/tests/api/fakes.py b/manila/tests/api/fakes.py index 799664bf..85e54f62 100644 --- a/manila/tests/api/fakes.py +++ b/manila/tests/api/fakes.py @@ -30,7 +30,6 @@ from manila.api.v1 import limits from manila.api.v1 import router from manila.api import versions from manila import context -from manila import exception as exc from manila import wsgi @@ -84,33 +83,6 @@ def wsgi_app(inner_app_v2=None, fake_auth=True, fake_auth_context=None, return mapper -def stub_out_rate_limiting(stubs): - def fake_rate_init(self, app): - # super(limits.RateLimitingMiddleware, self).__init__(app) - self.application = app - - # FIXME(ja): unsure about limits in volumes - # stubs.Set(manila.api.openstack.compute.limits.RateLimitingMiddleware, - # '__init__', fake_rate_init) - - # stubs.Set(manila.api.openstack.compute.limits.RateLimitingMiddleware, - # '__call__', fake_wsgi) - - -def stub_out_key_pair_funcs(stubs, have_key_pair=True): - def key_pair(context, user_id): - return [dict(name='key', public_key='public_key')] - - def one_key_pair(context, user_id, name): - if name == 'key': - return dict(name='key', public_key='public_key') - else: - raise exc.KeypairNotFound(user_id=user_id, name=name) - - def no_key_pair(context, user_id): - return [] - - class FakeToken(object): id_count = 0 diff --git a/manila/tests/api/v1/test_limits.py b/manila/tests/api/v1/test_limits.py index 3b0495f6..5f7df065 100644 --- a/manila/tests/api/v1/test_limits.py +++ b/manila/tests/api/v1/test_limits.py @@ -52,15 +52,15 @@ class BaseLimitTestSuite(test.TestCase): def setUp(self): super(BaseLimitTestSuite, self).setUp() self.time = 0.0 - self.stubs.Set(limits.Limit, "_get_time", self._get_time) + self.mock_object(limits.Limit, "_get_time", self._get_time) self.absolute_limits = {} def stub_get_project_quotas(context, project_id, usages=True): return dict((k, dict(limit=v)) for k, v in self.absolute_limits.items()) - self.stubs.Set(manila.quota.QUOTAS, "get_project_quotas", - stub_get_project_quotas) + self.mock_object(manila.quota.QUOTAS, "get_project_quotas", + stub_get_project_quotas) def _get_time(self): """Return the "time" according to this test suite.""" diff --git a/manila/tests/api/v1/test_security_service.py b/manila/tests/api/v1/test_security_service.py index 6ef78759..a6e08ab6 100644 --- a/manila/tests/api/v1/test_security_service.py +++ b/manila/tests/api/v1/test_security_service.py @@ -107,7 +107,7 @@ class ShareApiTest(test.TestCase): sec_service = self.ss_active_directory.copy() create_stub = mock.Mock( return_value=sec_service) - self.stubs.Set(db, 'security_service_create', create_stub) + self.mock_object(db, 'security_service_create', create_stub) req = fakes.HTTPRequest.blank('/security-services') res_dict = self.controller.create( diff --git a/manila/tests/api/v1/test_share_metadata.py b/manila/tests/api/v1/test_share_metadata.py index 203abab1..2a84c3a1 100644 --- a/manila/tests/api/v1/test_share_metadata.py +++ b/manila/tests/api/v1/test_share_metadata.py @@ -90,13 +90,12 @@ class ShareMetaDataTest(test.TestCase): def setUp(self): super(ShareMetaDataTest, self).setUp() self.share_api = manila.share.api.API() - fakes.stub_out_key_pair_funcs(self.stubs) - self.stubs.Set(manila.db, 'share_get', return_share) - self.stubs.Set(manila.db, 'share_metadata_get', - return_share_metadata) + self.mock_object(manila.db, 'share_get', return_share) + self.mock_object(manila.db, 'share_metadata_get', + return_share_metadata) - self.stubs.Set(self.share_api, 'update_share_metadata', - fake_update_share_metadata) + self.mock_object(self.share_api, 'update_share_metadata', + fake_update_share_metadata) self.share_controller = shares.ShareController() self.controller = share_metadata.ShareMetadataController() @@ -127,15 +126,15 @@ class ShareMetaDataTest(test.TestCase): self.assertEqual(expected, res_dict) def test_index_nonexistent_share(self): - self.stubs.Set(manila.db, 'share_metadata_get', - return_share_nonexistent) + self.mock_object(manila.db, 'share_metadata_get', + return_share_nonexistent) req = fakes.HTTPRequest.blank(self.url) self.assertRaises(webob.exc.HTTPNotFound, self.controller.index, req, self.url) def test_index_no_data(self): - self.stubs.Set(manila.db, 'share_metadata_get', - return_empty_share_metadata) + self.mock_object(manila.db, 'share_metadata_get', + return_empty_share_metadata) req = fakes.HTTPRequest.blank(self.url) res_dict = self.controller.index(req, self.req_id) expected = {'metadata': {}} @@ -148,24 +147,24 @@ class ShareMetaDataTest(test.TestCase): self.assertEqual(expected, res_dict) def test_show_nonexistent_share(self): - self.stubs.Set(manila.db, 'share_metadata_get', - return_share_nonexistent) + self.mock_object(manila.db, 'share_metadata_get', + return_share_nonexistent) req = fakes.HTTPRequest.blank(self.url + '/key2') self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, req, self.req_id, 'key2') def test_show_meta_not_found(self): - self.stubs.Set(manila.db, 'share_metadata_get', - return_empty_share_metadata) + self.mock_object(manila.db, 'share_metadata_get', + return_empty_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key6') self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, req, self.req_id, 'key6') def test_delete(self): - self.stubs.Set(manila.db, 'share_metadata_get', - return_share_metadata) - self.stubs.Set(manila.db, 'share_metadata_delete', - delete_share_metadata) + self.mock_object(manila.db, 'share_metadata_get', + return_share_metadata) + self.mock_object(manila.db, 'share_metadata_delete', + delete_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key2') req.method = 'DELETE' res = self.controller.delete(req, self.req_id, 'key2') @@ -173,26 +172,26 @@ class ShareMetaDataTest(test.TestCase): self.assertEqual(200, res.status_int) def test_delete_nonexistent_share(self): - self.stubs.Set(manila.db, 'share_get', - return_share_nonexistent) + self.mock_object(manila.db, 'share_get', + return_share_nonexistent) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'DELETE' self.assertRaises(webob.exc.HTTPNotFound, self.controller.delete, req, self.req_id, 'key1') def test_delete_meta_not_found(self): - self.stubs.Set(manila.db, 'share_metadata_get', - return_empty_share_metadata) + self.mock_object(manila.db, 'share_metadata_get', + return_empty_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key6') req.method = 'DELETE' self.assertRaises(webob.exc.HTTPNotFound, self.controller.delete, req, self.req_id, 'key6') def test_create(self): - self.stubs.Set(manila.db, 'share_metadata_get', - return_empty_share_metadata) - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_get', + return_empty_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank('/v1/share_metadata') req.method = 'POST' @@ -203,8 +202,8 @@ class ShareMetaDataTest(test.TestCase): self.assertEqual(body, res_dict) def test_create_empty_body(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url) req.method = 'POST' req.headers["content-type"] = "application/json" @@ -213,8 +212,8 @@ class ShareMetaDataTest(test.TestCase): self.controller.create, req, self.req_id, None) def test_create_item_empty_key(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' body = {"meta": {"": "value1"}} @@ -225,8 +224,8 @@ class ShareMetaDataTest(test.TestCase): self.controller.create, req, self.req_id, body) def test_create_item_key_too_long(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' body = {"meta": {("a" * 260): "value1"}} @@ -238,12 +237,12 @@ class ShareMetaDataTest(test.TestCase): req, self.req_id, body) def test_create_nonexistent_share(self): - self.stubs.Set(manila.db, 'share_get', - return_share_nonexistent) - self.stubs.Set(manila.db, 'share_metadata_get', - return_share_metadata) - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_get', + return_share_nonexistent) + self.mock_object(manila.db, 'share_metadata_get', + return_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank('/v1/share_metadata') req.method = 'POST' @@ -254,8 +253,8 @@ class ShareMetaDataTest(test.TestCase): self.controller.create, req, self.req_id, body) def test_update_all(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url) req.method = 'PUT' req.content_type = "application/json" @@ -271,8 +270,8 @@ class ShareMetaDataTest(test.TestCase): self.assertEqual(expected, res_dict) def test_update_all_empty_container(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url) req.method = 'PUT' req.content_type = "application/json" @@ -283,8 +282,8 @@ class ShareMetaDataTest(test.TestCase): self.assertEqual(expected, res_dict) def test_update_all_malformed_container(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url) req.method = 'PUT' req.content_type = "application/json" @@ -300,8 +299,8 @@ class ShareMetaDataTest(test.TestCase): {None: 'value'}, {None: None}) def test_update_all_malformed_data(self, metadata): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url) req.method = 'PUT' req.content_type = "application/json" @@ -313,7 +312,7 @@ class ShareMetaDataTest(test.TestCase): expected) def test_update_all_nonexistent_share(self): - self.stubs.Set(manila.db, 'share_get', return_share_nonexistent) + self.mock_object(manila.db, 'share_get', return_share_nonexistent) req = fakes.HTTPRequest.blank(self.url) req.method = 'PUT' req.content_type = "application/json" @@ -324,8 +323,8 @@ class ShareMetaDataTest(test.TestCase): self.controller.update_all, req, '100', body) def test_update_item(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' body = {"meta": {"key1": "value1"}} @@ -336,8 +335,8 @@ class ShareMetaDataTest(test.TestCase): self.assertEqual(expected, res_dict) def test_update_item_nonexistent_share(self): - self.stubs.Set(manila.db, 'share_get', - return_share_nonexistent) + self.mock_object(manila.db, 'share_get', + return_share_nonexistent) req = fakes.HTTPRequest.blank('/v1.1/fake/shares/asdf/metadata/key1') req.method = 'PUT' body = {"meta": {"key1": "value1"}} @@ -349,8 +348,8 @@ class ShareMetaDataTest(test.TestCase): body) def test_update_item_empty_body(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' req.headers["content-type"] = "application/json" @@ -360,8 +359,8 @@ class ShareMetaDataTest(test.TestCase): None) def test_update_item_empty_key(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' body = {"meta": {"": "value1"}} @@ -372,8 +371,8 @@ class ShareMetaDataTest(test.TestCase): self.controller.update, req, self.req_id, '', body) def test_update_item_key_too_long(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' body = {"meta": {("a" * 260): "value1"}} @@ -385,8 +384,8 @@ class ShareMetaDataTest(test.TestCase): req, self.req_id, ("a" * 260), body) def test_update_item_value_too_long(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' body = {"meta": {"key1": ("a" * 1025)}} @@ -398,8 +397,8 @@ class ShareMetaDataTest(test.TestCase): req, self.req_id, "key1", body) def test_update_item_too_many_keys(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/key1') req.method = 'PUT' body = {"meta": {"key1": "value1", "key2": "value2"}} @@ -411,8 +410,8 @@ class ShareMetaDataTest(test.TestCase): body) def test_update_item_body_uri_mismatch(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url + '/bad') req.method = 'PUT' body = {"meta": {"key1": "value1"}} @@ -424,8 +423,8 @@ class ShareMetaDataTest(test.TestCase): body) def test_invalid_metadata_items_on_create(self): - self.stubs.Set(manila.db, 'share_metadata_update', - return_create_share_metadata) + self.mock_object(manila.db, 'share_metadata_update', + return_create_share_metadata) req = fakes.HTTPRequest.blank(self.url) req.method = 'POST' req.headers["content-type"] = "application/json" diff --git a/manila/tests/api/v1/test_share_servers.py b/manila/tests/api/v1/test_share_servers.py index 910b48bd..e88727be 100644 --- a/manila/tests/api/v1/test_share_servers.py +++ b/manila/tests/api/v1/test_share_servers.py @@ -161,10 +161,10 @@ class ShareServerAPITest(test.TestCase): def setUp(self): super(ShareServerAPITest, self).setUp() self.controller = share_servers.ShareServerController() - self.stubs.Set(policy, 'check_policy', - mock.Mock(return_value=True)) - self.stubs.Set(db_api, 'share_server_get_all', - mock.Mock(return_value=fake_share_server_get_all())) + self.mock_object(policy, 'check_policy', + mock.Mock(return_value=True)) + self.mock_object(db_api, 'share_server_get_all', + mock.Mock(return_value=fake_share_server_get_all())) def test_index_no_filters(self): result = self.controller.index(FakeRequestAdmin) @@ -221,8 +221,8 @@ class ShareServerAPITest(test.TestCase): self.assertEqual(len(result['share_servers']), 0) def test_show(self): - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(return_value=fake_share_server_get())) + self.mock_object(db_api, 'share_server_get', + mock.Mock(return_value=fake_share_server_get())) result = self.controller.show( FakeRequestAdmin, fake_share_server_get_result['share_server']['id']) @@ -234,9 +234,9 @@ class ShareServerAPITest(test.TestCase): fake_share_server_get_result['share_server']) def test_details(self): - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(return_value=fake_share_server_get())) - self.stubs.Set( + self.mock_object(db_api, 'share_server_get', + mock.Mock(return_value=fake_share_server_get())) + self.mock_object( db_api, 'share_server_backend_details_get', mock.Mock(return_value=fake_share_server_backend_details_get())) result = self.controller.details( @@ -253,10 +253,9 @@ class ShareServerAPITest(test.TestCase): def test_delete_active_server(self): share_server = FakeShareServer(status=constants.STATUS_ACTIVE) - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(return_value=share_server)) - self.stubs.Set(self.controller.share_api, 'delete_share_server', - mock.Mock()) + self.mock_object(db_api, 'share_server_get', + mock.Mock(return_value=share_server)) + self.mock_object(self.controller.share_api, 'delete_share_server') self.controller.delete( FakeRequestAdmin, fake_share_server_get_result['share_server']['id']) @@ -269,10 +268,9 @@ class ShareServerAPITest(test.TestCase): def test_delete_error_server(self): share_server = FakeShareServer(status=constants.STATUS_ERROR) - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(return_value=share_server)) - self.stubs.Set(self.controller.share_api, 'delete_share_server', - mock.Mock()) + self.mock_object(db_api, 'share_server_get', + mock.Mock(return_value=share_server)) + self.mock_object(self.controller.share_api, 'delete_share_server') self.controller.delete( FakeRequestAdmin, fake_share_server_get_result['share_server']['id']) @@ -290,10 +288,10 @@ class ShareServerAPITest(test.TestCase): raise exception.ShareServerInUse(share_server_id=share_server_id) share_server = fake_share_server_get() - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(return_value=share_server)) - self.stubs.Set(self.controller.share_api, 'delete_share_server', - mock.Mock(side_effect=raise_not_share_server_in_use)) + self.mock_object(db_api, 'share_server_get', + mock.Mock(return_value=share_server)) + self.mock_object(self.controller.share_api, 'delete_share_server', + mock.Mock(side_effect=raise_not_share_server_in_use)) self.assertRaises(exc.HTTPConflict, self.controller.delete, FakeRequestAdmin, @@ -310,8 +308,8 @@ class ShareServerAPITest(test.TestCase): raise exception.ShareServerNotFound( share_server_id=share_server_id) - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(side_effect=raise_not_found)) + self.mock_object(db_api, 'share_server_get', + mock.Mock(side_effect=raise_not_found)) self.assertRaises(exc.HTTPNotFound, self.controller.delete, FakeRequestAdmin, @@ -323,8 +321,8 @@ class ShareServerAPITest(test.TestCase): def test_delete_creating_server(self): share_server = FakeShareServer(status=constants.STATUS_CREATING) - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(return_value=share_server)) + self.mock_object(db_api, 'share_server_get', + mock.Mock(return_value=share_server)) self.assertRaises(exc.HTTPForbidden, self.controller.delete, FakeRequestAdmin, @@ -335,8 +333,8 @@ class ShareServerAPITest(test.TestCase): def test_delete_deleting_server(self): share_server = FakeShareServer(status=constants.STATUS_DELETING) - self.stubs.Set(db_api, 'share_server_get', - mock.Mock(return_value=share_server)) + self.mock_object(db_api, 'share_server_get', + mock.Mock(return_value=share_server)) self.assertRaises(exc.HTTPForbidden, self.controller.delete, FakeRequestAdmin, diff --git a/manila/tests/api/v1/test_share_snapshots.py b/manila/tests/api/v1/test_share_snapshots.py index 13729699..7fdb7f55 100644 --- a/manila/tests/api/v1/test_share_snapshots.py +++ b/manila/tests/api/v1/test_share_snapshots.py @@ -32,13 +32,13 @@ class ShareSnapshotApiTest(test.TestCase): super(ShareSnapshotApiTest, self).setUp() self.controller = share_snapshots.ShareSnapshotsController() - self.stubs.Set(share_api.API, 'get', stubs.stub_share_get) - self.stubs.Set(share_api.API, 'get_all_snapshots', - stubs.stub_snapshot_get_all_by_project) - self.stubs.Set(share_api.API, 'get_snapshot', - stubs.stub_snapshot_get) - self.stubs.Set(share_api.API, 'snapshot_update', - stubs.stub_snapshot_update) + self.mock_object(share_api.API, 'get', stubs.stub_share_get) + self.mock_object(share_api.API, 'get_all_snapshots', + stubs.stub_snapshot_get_all_by_project) + self.mock_object(share_api.API, 'get_snapshot', + stubs.stub_snapshot_get) + self.mock_object(share_api.API, 'snapshot_update', + stubs.stub_snapshot_update) self.snp_example = { 'share_id': 100, 'size': 12, @@ -49,8 +49,8 @@ class ShareSnapshotApiTest(test.TestCase): self.maxDiff = None def test_snapshot_create(self): - self.stubs.Set(share_api.API, 'create_snapshot', - stubs.stub_snapshot_create) + self.mock_object(share_api.API, 'create_snapshot', + stubs.stub_snapshot_create) body = { 'snapshot': { 'share_id': 100, @@ -96,15 +96,15 @@ class ShareSnapshotApiTest(test.TestCase): body) def test_snapshot_delete(self): - self.stubs.Set(share_api.API, 'delete_snapshot', - stubs.stub_snapshot_delete) + self.mock_object(share_api.API, 'delete_snapshot', + stubs.stub_snapshot_delete) req = fakes.HTTPRequest.blank('/snapshots/200') resp = self.controller.delete(req, 200) self.assertEqual(resp.status_int, 202) def test_snapshot_delete_nofound(self): - self.stubs.Set(share_api.API, 'get_snapshot', - stubs.stub_snapshot_get_notfound) + self.mock_object(share_api.API, 'get_snapshot', + stubs.stub_snapshot_get_notfound) req = fakes.HTTPRequest.blank('/snapshots/200') self.assertRaises(webob.exc.HTTPNotFound, self.controller.delete, @@ -141,16 +141,16 @@ class ShareSnapshotApiTest(test.TestCase): self.assertEqual(res_dict, expected) def test_snapshot_show_nofound(self): - self.stubs.Set(share_api.API, 'get_snapshot', - stubs.stub_snapshot_get_notfound) + self.mock_object(share_api.API, 'get_snapshot', + stubs.stub_snapshot_get_notfound) req = fakes.HTTPRequest.blank('/snapshots/200') self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, req, '200') def test_snapshot_list_summary(self): - self.stubs.Set(share_api.API, 'get_all_snapshots', - stubs.stub_snapshot_get_all_by_project) + self.mock_object(share_api.API, 'get_all_snapshots', + stubs.stub_snapshot_get_all_by_project) req = fakes.HTTPRequest.blank('/snapshots') res_dict = self.controller.index(req) expected = { @@ -195,8 +195,8 @@ class ShareSnapshotApiTest(test.TestCase): {'id': 'id2', 'display_name': 'n2'}, {'id': 'id3', 'display_name': 'n3'}, ] - self.stubs.Set(share_api.API, 'get_all_snapshots', - mock.Mock(return_value=snapshots)) + self.mock_object(share_api.API, 'get_all_snapshots', + mock.Mock(return_value=snapshots)) result = self.controller.index(req) @@ -251,8 +251,8 @@ class ShareSnapshotApiTest(test.TestCase): {'id': 'id3', 'display_name': 'n3'}, ] - self.stubs.Set(share_api.API, 'get_all_snapshots', - mock.Mock(return_value=snapshots)) + self.mock_object(share_api.API, 'get_all_snapshots', + mock.Mock(return_value=snapshots)) result = self.controller.detail(req) diff --git a/manila/tests/api/v1/test_shares.py b/manila/tests/api/v1/test_shares.py index fe3384f6..36e49745 100644 --- a/manila/tests/api/v1/test_shares.py +++ b/manila/tests/api/v1/test_shares.py @@ -34,13 +34,14 @@ class ShareApiTest(test.TestCase): def setUp(self): super(ShareApiTest, self).setUp() self.controller = shares.ShareController() - self.stubs.Set(share_api.API, 'get_all', - stubs.stub_get_all_shares) - self.stubs.Set(share_api.API, 'get', - stubs.stub_share_get) - self.stubs.Set(share_api.API, 'update', stubs.stub_share_update) - self.stubs.Set(share_api.API, 'delete', stubs.stub_share_delete) - self.stubs.Set(share_api.API, 'get_snapshot', stubs.stub_snapshot_get) + self.mock_object(share_api.API, 'get_all', + stubs.stub_get_all_shares) + self.mock_object(share_api.API, 'get', + stubs.stub_share_get) + self.mock_object(share_api.API, 'update', stubs.stub_share_update) + self.mock_object(share_api.API, 'delete', stubs.stub_share_delete) + self.mock_object(share_api.API, 'get_snapshot', + stubs.stub_snapshot_get) self.maxDiff = None self.shr_example = { "size": 100, @@ -99,7 +100,7 @@ class ShareApiTest(test.TestCase): size=100, share_proto=shr['share_proto'].upper(), availability_zone=shr['availability_zone'])) - self.stubs.Set(share_api.API, 'create', create_mock) + self.mock_object(share_api.API, 'create', create_mock) body = {"share": copy.deepcopy(shr)} req = fakes.HTTPRequest.blank('/shares') @@ -124,8 +125,8 @@ class ShareApiTest(test.TestCase): share_proto=shr['share_proto'].upper(), availability_zone=shr['availability_zone'], share_network_id=shr['share_network_id'])) - self.stubs.Set(share_api.API, 'create', create_mock) - self.stubs.Set(share_api.API, 'get_share_network', mock.Mock( + self.mock_object(share_api.API, 'create', create_mock) + self.mock_object(share_api.API, 'get_share_network', mock.Mock( return_value={'id': 'fakenetid'})) body = {"share": copy.deepcopy(shr)} @@ -155,7 +156,7 @@ class ShareApiTest(test.TestCase): availability_zone=shr['availability_zone'], snapshot_id=shr['snapshot_id'], share_network_id=shr['share_network_id'])) - self.stubs.Set(share_api.API, 'create', create_mock) + self.mock_object(share_api.API, 'create', create_mock) body = {"share": copy.deepcopy(shr)} req = fakes.HTTPRequest.blank('/shares') res_dict = self.controller.create(req, body) @@ -181,11 +182,12 @@ class ShareApiTest(test.TestCase): availability_zone=shr['availability_zone'], snapshot_id=shr['snapshot_id'], share_network_id=shr['share_network_id'])) - self.stubs.Set(share_api.API, 'create', create_mock) - self.stubs.Set(share_api.API, 'get_snapshot', stubs.stub_snapshot_get) - self.stubs.Set(share_api.API, 'get', mock.Mock( + self.mock_object(share_api.API, 'create', create_mock) + self.mock_object(share_api.API, 'get_snapshot', + stubs.stub_snapshot_get) + self.mock_object(share_api.API, 'get', mock.Mock( return_value={'share_network_id': parent_share_net})) - self.stubs.Set(share_api.API, 'get_share_network', mock.Mock( + self.mock_object(share_api.API, 'get_share_network', mock.Mock( return_value={'id': parent_share_net})) body = {"share": copy.deepcopy(shr)} @@ -215,11 +217,12 @@ class ShareApiTest(test.TestCase): availability_zone=shr['availability_zone'], snapshot_id=shr['snapshot_id'], share_network_id=shr['share_network_id'])) - self.stubs.Set(share_api.API, 'create', create_mock) - self.stubs.Set(share_api.API, 'get_snapshot', stubs.stub_snapshot_get) - self.stubs.Set(share_api.API, 'get', mock.Mock( + self.mock_object(share_api.API, 'create', create_mock) + self.mock_object(share_api.API, 'get_snapshot', + stubs.stub_snapshot_get) + self.mock_object(share_api.API, 'get', mock.Mock( return_value={'share_network_id': parent_share_net})) - self.stubs.Set(share_api.API, 'get_share_network', mock.Mock( + self.mock_object(share_api.API, 'get_share_network', mock.Mock( return_value={'id': parent_share_net})) body = {"share": copy.deepcopy(shr)} @@ -231,7 +234,7 @@ class ShareApiTest(test.TestCase): parent_share_net) def test_share_create_from_snapshot_invalid_share_net(self): - self.stubs.Set(share_api.API, 'create', mock.Mock()) + self.mock_object(share_api.API, 'create') shr = { "size": 100, "name": "Share Test Name", @@ -282,8 +285,8 @@ class ShareApiTest(test.TestCase): self.assertEqual(expected, res_dict) def test_share_show_no_share(self): - self.stubs.Set(share_api.API, 'get', - stubs.stub_share_get_notfound) + self.mock_object(share_api.API, 'get', + stubs.stub_share_get_notfound) req = fakes.HTTPRequest.blank('/shares/1') self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, @@ -322,8 +325,8 @@ class ShareApiTest(test.TestCase): self.assertNotEqual(res_dict['share']["size"], shr["size"]) def test_share_delete_no_share(self): - self.stubs.Set(share_api.API, 'get', - stubs.stub_share_get_notfound) + self.mock_object(share_api.API, 'get', + stubs.stub_share_get_notfound) req = fakes.HTTPRequest.blank('/shares/1') self.assertRaises(webob.exc.HTTPNotFound, self.controller.delete, @@ -357,8 +360,8 @@ class ShareApiTest(test.TestCase): {'id': 'id2', 'display_name': 'n2'}, {'id': 'id3', 'display_name': 'n3'}, ] - self.stubs.Set(share_api.API, 'get_all', - mock.Mock(return_value=shares)) + self.mock_object(share_api.API, 'get_all', + mock.Mock(return_value=shares)) result = self.controller.index(req) @@ -393,8 +396,8 @@ class ShareApiTest(test.TestCase): self._share_list_summary_with_search_opts(use_admin_context=True) def test_share_list_summary(self): - self.stubs.Set(share_api.API, 'get_all', - stubs.stub_share_get_all_by_project) + self.mock_object(share_api.API, 'get_all', + stubs.stub_share_get_all_by_project) req = fakes.HTTPRequest.blank('/shares') res_dict = self.controller.index(req) expected = { @@ -453,8 +456,8 @@ class ShareApiTest(test.TestCase): }, {'id': 'id3', 'display_name': 'n3'}, ] - self.stubs.Set(share_api.API, 'get_all', - mock.Mock(return_value=shares)) + self.mock_object(share_api.API, 'get_all', + mock.Mock(return_value=shares)) result = self.controller.detail(req) @@ -502,8 +505,8 @@ class ShareApiTest(test.TestCase): self._share_list_detail_with_search_opts(use_admin_context=True) def test_share_list_detail(self): - self.stubs.Set(share_api.API, 'get_all', - stubs.stub_share_get_all_by_project) + self.mock_object(share_api.API, 'get_all', + stubs.stub_share_get_all_by_project) env = {'QUERY_STRING': 'name=Share+Test+Name'} req = fakes.HTTPRequest.blank('/shares/detail', environ=env) res_dict = self.controller.detail(req) diff --git a/manila/tests/api/v1/test_volume_types.py b/manila/tests/api/v1/test_volume_types.py index 9dea5283..2c2ff13c 100644 --- a/manila/tests/api/v1/test_volume_types.py +++ b/manila/tests/api/v1/test_volume_types.py @@ -69,8 +69,8 @@ class VolumeTypesApiTest(test.TestCase): self.controller = types.VolumeTypesController() def test_volume_types_index(self): - self.stubs.Set(volume_types, 'get_all_types', - return_volume_types_get_all_types) + self.mock_object(volume_types, 'get_all_types', + return_volume_types_get_all_types) req = fakes.HTTPRequest.blank('/v2/fake/types') res_dict = self.controller.index(req) @@ -84,8 +84,8 @@ class VolumeTypesApiTest(test.TestCase): self.assertEqual('value1', entry['extra_specs']['key1']) def test_volume_types_index_no_data(self): - self.stubs.Set(volume_types, 'get_all_types', - return_empty_volume_types_get_all_types) + self.mock_object(volume_types, 'get_all_types', + return_empty_volume_types_get_all_types) req = fakes.HTTPRequest.blank('/v2/fake/types') res_dict = self.controller.index(req) @@ -93,8 +93,8 @@ class VolumeTypesApiTest(test.TestCase): self.assertEqual(0, len(res_dict['volume_types'])) def test_volume_types_show(self): - self.stubs.Set(volume_types, 'get_volume_type', - return_volume_types_get_volume_type) + self.mock_object(volume_types, 'get_volume_type', + return_volume_types_get_volume_type) req = fakes.HTTPRequest.blank('/v2/fake/types/1') res_dict = self.controller.show(req, 1) @@ -104,8 +104,8 @@ class VolumeTypesApiTest(test.TestCase): self.assertEqual('vol_type_1', res_dict['volume_type']['name']) def test_volume_types_show_not_found(self): - self.stubs.Set(volume_types, 'get_volume_type', - return_volume_types_get_volume_type) + self.mock_object(volume_types, 'get_volume_type', + return_volume_types_get_volume_type) req = fakes.HTTPRequest.blank('/v2/fake/types/777') self.assertRaises(webob.exc.HTTPNotFound, self.controller.show, diff --git a/manila/tests/compute/test_nova.py b/manila/tests/compute/test_nova.py index 80034c6d..c594c293 100644 --- a/manila/tests/compute/test_nova.py +++ b/manila/tests/compute/test_nova.py @@ -70,10 +70,10 @@ class NovaApiTestCase(test.TestCase): self.api = nova.API() self.novaclient = FakeNovaClient() self.ctx = context.get_admin_context() - self.stubs.Set(nova, 'novaclient', - mock.Mock(return_value=self.novaclient)) - self.stubs.Set(nova, '_untranslate_server_summary_view', - lambda server: server) + self.mock_object(nova, 'novaclient', + mock.Mock(return_value=self.novaclient)) + self.mock_object(nova, '_untranslate_server_summary_view', + lambda server: server) def test_server_create(self): result = self.api.server_create(self.ctx, 'server_name', 'fake_image', @@ -81,7 +81,7 @@ class NovaApiTestCase(test.TestCase): self.assertEqual(result['id'], 'created_id') def test_server_delete(self): - self.stubs.Set(self.novaclient.servers, 'delete', mock.Mock()) + self.mock_object(self.novaclient.servers, 'delete') self.api.server_delete(self.ctx, 'id1') self.novaclient.servers.delete.assert_called_once_with('id1') @@ -93,7 +93,8 @@ class NovaApiTestCase(test.TestCase): def test_server_get_by_name_or_id(self): instance_id = 'instance_id1' server = {'id': instance_id, 'fake_key': 'fake_value'} - self.stubs.Set(utils, 'find_resource', mock.Mock(return_value=server)) + self.mock_object(utils, 'find_resource', + mock.Mock(return_value=server)) result = self.api.server_get_by_name_or_id(self.ctx, instance_id) @@ -111,98 +112,96 @@ class NovaApiTestCase(test.TestCase): self.api.server_list(self.ctx)) def test_server_pause(self): - self.stubs.Set(self.novaclient.servers, 'pause', mock.Mock()) + self.mock_object(self.novaclient.servers, 'pause') self.api.server_pause(self.ctx, 'id1') self.novaclient.servers.pause.assert_called_once_with('id1') def test_server_unpause(self): - self.stubs.Set(self.novaclient.servers, 'unpause', mock.Mock()) + self.mock_object(self.novaclient.servers, 'unpause') self.api.server_unpause(self.ctx, 'id1') self.novaclient.servers.unpause.assert_called_once_with('id1') def test_server_suspend(self): - self.stubs.Set(self.novaclient.servers, 'suspend', mock.Mock()) + self.mock_object(self.novaclient.servers, 'suspend') self.api.server_suspend(self.ctx, 'id1') self.novaclient.servers.suspend.assert_called_once_with('id1') def test_server_resume(self): - self.stubs.Set(self.novaclient.servers, 'resume', mock.Mock()) + self.mock_object(self.novaclient.servers, 'resume') self.api.server_resume(self.ctx, 'id1') self.novaclient.servers.resume.assert_called_once_with('id1') def test_server_reboot_hard(self): - self.stubs.Set(self.novaclient.servers, 'reboot', mock.Mock()) + self.mock_object(self.novaclient.servers, 'reboot') self.api.server_reboot(self.ctx, 'id1') self.novaclient.servers.reboot.assert_called_once_with( 'id1', nova_servers.REBOOT_HARD) def test_server_reboot_soft(self): - self.stubs.Set(self.novaclient.servers, 'reboot', mock.Mock()) + self.mock_object(self.novaclient.servers, 'reboot') self.api.server_reboot(self.ctx, 'id1', True) self.novaclient.servers.reboot.assert_called_once_with( 'id1', nova_servers.REBOOT_SOFT) def test_server_rebuild(self): - self.stubs.Set(self.novaclient.servers, 'rebuild', mock.Mock()) + self.mock_object(self.novaclient.servers, 'rebuild') self.api.server_rebuild(self.ctx, 'id1', 'fake_image') self.novaclient.servers.rebuild.assert_called_once_with('id1', 'fake_image', None) def test_instance_volume_attach(self): - self.stubs.Set(self.novaclient.volumes, 'create_server_volume', - mock.Mock()) + self.mock_object(self.novaclient.volumes, 'create_server_volume') self.api.instance_volume_attach(self.ctx, 'instance_id', 'vol_id', 'device') self.novaclient.volumes.create_server_volume.\ assert_called_once_with('instance_id', 'vol_id', 'device') def test_instance_volume_detach(self): - self.stubs.Set(self.novaclient.volumes, 'delete_server_volume', - mock.Mock()) + self.mock_object(self.novaclient.volumes, 'delete_server_volume') self.api.instance_volume_detach(self.ctx, 'instance_id', 'att_id') self.novaclient.volumes.delete_server_volume.\ assert_called_once_with('instance_id', 'att_id') def test_instance_volumes_list(self): - self.stubs.Set(self.novaclient.volumes, 'get_server_volumes', - mock.Mock(return_value=[Volume('id1'), Volume('id2')])) + self.mock_object( + self.novaclient.volumes, 'get_server_volumes', + mock.Mock(return_value=[Volume('id1'), Volume('id2')])) self.cinderclient = self.novaclient - self.stubs.Set(cinder, 'cinderclient', - mock.Mock(return_value=self.novaclient)) + self.mock_object(cinder, 'cinderclient', + mock.Mock(return_value=self.novaclient)) result = self.api.instance_volumes_list(self.ctx, 'instance_id') self.assertEqual(len(result), 2) self.assertEqual(result[0].id, 'id1') self.assertEqual(result[1].id, 'id2') def test_server_update(self): - self.stubs.Set(self.novaclient.servers, 'update', mock.Mock()) + self.mock_object(self.novaclient.servers, 'update') self.api.server_update(self.ctx, 'id1', 'new_name') self.novaclient.servers.update.assert_called_once_with('id1', name='new_name') def test_update_server_volume(self): - self.stubs.Set(self.novaclient.volumes, 'update_server_volume', - mock.Mock()) + self.mock_object(self.novaclient.volumes, 'update_server_volume') self.api.update_server_volume(self.ctx, 'instance_id', 'att_id', 'new_vol_id') self.novaclient.volumes.update_server_volume.\ assert_called_once_with('instance_id', 'att_id', 'new_vol_id') def test_keypair_create(self): - self.stubs.Set(self.novaclient.keypairs, 'create', mock.Mock()) + self.mock_object(self.novaclient.keypairs, 'create') self.api.keypair_create(self.ctx, 'keypair_name') self.novaclient.keypairs.create.assert_called_once_with('keypair_name') def test_keypair_import(self): - self.stubs.Set(self.novaclient.keypairs, 'create', mock.Mock()) + self.mock_object(self.novaclient.keypairs, 'create') self.api.keypair_import(self.ctx, 'keypair_name', 'fake_pub_key') self.novaclient.keypairs.create.\ assert_called_once_with('keypair_name', 'fake_pub_key') def test_keypair_delete(self): - self.stubs.Set(self.novaclient.keypairs, 'delete', mock.Mock()) + self.mock_object(self.novaclient.keypairs, 'delete') self.api.keypair_delete(self.ctx, 'fake_keypair_id') self.novaclient.keypairs.delete.\ assert_called_once_with('fake_keypair_id') diff --git a/manila/tests/fake_notifier.py b/manila/tests/fake_notifier.py index 53277c04..78c039bd 100644 --- a/manila/tests/fake_notifier.py +++ b/manila/tests/fake_notifier.py @@ -61,10 +61,11 @@ class FakeNotifier(object): NOTIFICATIONS.append(msg) -def stub_notifier(stubs): - stubs.Set(messaging, 'Notifier', FakeNotifier) +def stub_notifier(testcase): + testcase.mock_object(messaging, 'Notifier', FakeNotifier) if rpc.NOTIFIER: serializer = getattr(rpc.NOTIFIER, '_serializer', None) - stubs.Set(rpc, 'NOTIFIER', FakeNotifier(rpc.NOTIFIER.transport, - rpc.NOTIFIER.publisher_id, - serializer=serializer)) + testcase.mock_object(rpc, 'NOTIFIER', + FakeNotifier(rpc.NOTIFIER.transport, + rpc.NOTIFIER.publisher_id, + serializer=serializer)) diff --git a/manila/tests/fake_utils.py b/manila/tests/fake_utils.py index 0cba29ad..b8b88256 100644 --- a/manila/tests/fake_utils.py +++ b/manila/tests/fake_utils.py @@ -105,7 +105,7 @@ def fake_execute(*cmd_parts, **kwargs): return reply -def stub_out_utils_execute(stubs): +def stub_out_utils_execute(testcase): fake_execute_set_repliers([]) fake_execute_clear_log() - stubs.Set(utils, 'execute', fake_execute) + testcase.mock_object(utils, 'execute', fake_execute) diff --git a/manila/tests/network/neutron/test_neutron_api.py b/manila/tests/network/neutron/test_neutron_api.py index 73bbe06f..da28ab2a 100644 --- a/manila/tests/network/neutron/test_neutron_api.py +++ b/manila/tests/network/neutron/test_neutron_api.py @@ -86,8 +86,8 @@ class NeutronApiTest(test.TestCase): def setUp(self): super(NeutronApiTest, self).setUp() self.context = context.get_admin_context() - self.stubs.Set(base, 'Base', fakes.FakeModel) - self.stubs.Set( + self.mock_object(base, 'Base', fakes.FakeModel) + self.mock_object( clientv20, 'Client', mock.Mock(return_value=FakeNeutronClient())) self.neutron_api = neutron_api.API() @@ -116,8 +116,8 @@ class NeutronApiTest(test.TestCase): def test_create_port_with_all_args(self): # Set up test data - self.stubs.Set(self.neutron_api, '_has_port_binding_extension', - mock.Mock(return_value=True)) + self.mock_object(self.neutron_api, '_has_port_binding_extension', + mock.Mock(return_value=True)) port_args = { 'tenant_id': 'test tenant', 'network_id': 'test net', 'host_id': 'test host', 'subnet_id': 'test subnet', @@ -149,8 +149,8 @@ class NeutronApiTest(test.TestCase): def test_create_port_with_required_args(self): # Set up test data - self.stubs.Set(self.neutron_api, '_has_port_binding_extension', - mock.Mock(return_value=True)) + self.mock_object(self.neutron_api, '_has_port_binding_extension', + mock.Mock(return_value=True)) port_args = {'tenant_id': 'test tenant', 'network_id': 'test net'} # Execute method 'create_port' @@ -166,10 +166,10 @@ class NeutronApiTest(test.TestCase): @mock.patch.object(neutron_api.LOG, 'exception', mock.Mock()) def test_create_port_exception(self): # Set up test data - self.stubs.Set( + self.mock_object( self.neutron_api, '_has_port_binding_extension', mock.Mock(return_value=True)) - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'create_port', mock.Mock(side_effect=neutron_client_exc.NeutronClientException)) port_args = {'tenant_id': 'test tenant', 'network_id': 'test net'} @@ -188,10 +188,10 @@ class NeutronApiTest(test.TestCase): @mock.patch.object(neutron_api.LOG, 'exception', mock.Mock()) def test_create_port_exception_status_409(self): # Set up test data - self.stubs.Set( + self.mock_object( self.neutron_api, '_has_port_binding_extension', mock.Mock(return_value=True)) - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'create_port', mock.Mock(side_effect=neutron_client_exc.NeutronClientException( status_code=409))) @@ -210,7 +210,7 @@ class NeutronApiTest(test.TestCase): def test_delete_port(self): # Set up test data - self.stubs.Set(self.neutron_api.client, 'delete_port', mock.Mock()) + self.mock_object(self.neutron_api.client, 'delete_port') port_id = 'test port id' # Execute method 'delete_port' @@ -224,7 +224,7 @@ class NeutronApiTest(test.TestCase): # Set up test data search_opts = {'test_option': 'test_value'} fake_ports = [{'fake port': 'fake port info'}] - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'list_ports', mock.Mock(return_value={'ports': fake_ports})) @@ -241,7 +241,7 @@ class NeutronApiTest(test.TestCase): # Set up test data port_id = 'test port id' fake_port = {'fake port': 'fake port info'} - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'show_port', mock.Mock(return_value={'port': fake_port})) @@ -257,7 +257,7 @@ class NeutronApiTest(test.TestCase): # Set up test data network_id = 'test network id' fake_network = {'fake network': 'fake network info'} - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'show_network', mock.Mock(return_value={'network': fake_network})) @@ -273,7 +273,7 @@ class NeutronApiTest(test.TestCase): def test_get_subnet(self): # Set up test data subnet_id = 'fake subnet id' - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'show_subnet', mock.Mock(return_value={'subnet': {}})) @@ -289,7 +289,7 @@ class NeutronApiTest(test.TestCase): def test_get_all_network(self): # Set up test data fake_networks = [{'fake network': 'fake network info'}] - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'list_networks', mock.Mock(return_value={'networks': fake_networks})) @@ -307,7 +307,7 @@ class NeutronApiTest(test.TestCase): {'name': neutron_constants.PORTBINDING_EXT}, {'name': neutron_constants.PROVIDER_NW_EXT}, ] - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'list_extensions', mock.Mock(return_value={'extensions': extensions})) @@ -368,7 +368,7 @@ class NeutronApiTest(test.TestCase): def test_list_routers(self): # Set up test data fake_routers = [{'fake router': 'fake router info'}] - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'list_routers', mock.Mock(return_value={'routers': fake_routers})) @@ -383,7 +383,7 @@ class NeutronApiTest(test.TestCase): def test_create_network_exception(self): # Set up test data net_args = {'tenant_id': 'test tenant', 'name': 'test name'} - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'create_network', mock.Mock(side_effect=neutron_client_exc.NeutronClientException)) @@ -406,7 +406,7 @@ class NeutronApiTest(test.TestCase): 'net_id': 'test net id', 'cidr': '10.0.0.0/24', } - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'create_subnet', mock.Mock(side_effect=neutron_client_exc.NeutronClientException)) @@ -431,7 +431,7 @@ class NeutronApiTest(test.TestCase): def test_create_router_exception(self): # Set up test data router_args = {'tenant_id': 'test tenant', 'name': 'test name'} - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'create_router', mock.Mock(side_effect=neutron_client_exc.NeutronClientException)) @@ -462,7 +462,7 @@ class NeutronApiTest(test.TestCase): # Set up test data port_id = 'test_port' fixed_ips = {'fixed_ips': [{'subnet_id': 'test subnet'}]} - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'update_port', mock.Mock(side_effect=neutron_client_exc.NeutronClientException)) @@ -501,7 +501,7 @@ class NeutronApiTest(test.TestCase): {'destination': '0.0.0.0/0', 'nexthop': '8.8.8.8', }, ], } - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'update_router', mock.Mock(side_effect=neutron_client_exc.NeutronClientException)) @@ -520,7 +520,7 @@ class NeutronApiTest(test.TestCase): # Set up test data router_id = 'test router id' fake_router = {'fake router': 'fake router info'} - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'show_router', mock.Mock(return_value={'router': fake_router})) @@ -537,8 +537,7 @@ class NeutronApiTest(test.TestCase): router_id = 'test port id' subnet_id = 'test subnet id' port_id = 'test port id' - self.stubs.Set( - self.neutron_api.client, 'add_interface_router', mock.Mock()) + self.mock_object(self.neutron_api.client, 'add_interface_router') # Execute method 'router_add_interface' self.neutron_api.router_add_interface(router_id, subnet_id, port_id) @@ -553,7 +552,7 @@ class NeutronApiTest(test.TestCase): router_id = 'test port id' subnet_id = 'test subnet id' port_id = 'test port id' - self.stubs.Set( + self.mock_object( self.neutron_api.client, 'add_interface_router', mock.Mock(side_effect=neutron_client_exc.NeutronClientException)) diff --git a/manila/tests/network/neutron/test_neutron_plugin.py b/manila/tests/network/neutron/test_neutron_plugin.py index 3ee254e5..5a3f4d96 100644 --- a/manila/tests/network/neutron/test_neutron_plugin.py +++ b/manila/tests/network/neutron/test_neutron_plugin.py @@ -314,7 +314,7 @@ class NeutronSingleNetworkPluginTest(test.TestCase): } } fake_net = {'subnets': ['fake1', 'fake2', fake_subnet_id]} - self.stubs.Set( + self.mock_object( neutron_api.API, 'get_network', mock.Mock(return_value=fake_net)) with test_utils.create_temp_config_with_opts(config_data): @@ -352,7 +352,7 @@ class NeutronSingleNetworkPluginTest(test.TestCase): 'neutron_subnet_id': 'fake_subnet_id', } } - self.stubs.Set( + self.mock_object( neutron_api.API, 'get_network', mock.Mock(return_value=fake_net)) with test_utils.create_temp_config_with_opts(config_data): @@ -370,7 +370,7 @@ class NeutronSingleNetworkPluginTest(test.TestCase): } } fake_net = {'subnets': [fake_subnet_id]} - self.stubs.Set( + self.mock_object( neutron_api.API, 'get_network', mock.Mock(return_value=fake_net)) with test_utils.create_temp_config_with_opts(config_data): instance = plugin.NeutronSingleNetworkPlugin() @@ -400,7 +400,7 @@ class NeutronSingleNetworkPluginTest(test.TestCase): 'neutron_net_id': n, 'neutron_subnet_id': s, } - self.stubs.Set( + self.mock_object( instance.db, 'share_network_update', mock.Mock(return_value=share_network)) @@ -420,7 +420,7 @@ class NeutronSingleNetworkPluginTest(test.TestCase): share_network_upd = 'updated_fake_share_network' count = 2 device_owner = 'fake_device_owner' - self.stubs.Set( + self.mock_object( instance, '_update_share_network_net_data', mock.Mock(return_value=share_network_upd)) diff --git a/manila/tests/scheduler/test_host_filters.py b/manila/tests/scheduler/test_host_filters.py index 530a3e4a..8a26caab 100644 --- a/manila/tests/scheduler/test_host_filters.py +++ b/manila/tests/scheduler/test_host_filters.py @@ -44,7 +44,7 @@ class HostFiltersTestCase(test.TestCase): def _stub_service_is_up(self, ret_value): def fake_service_is_up(service): return ret_value - self.stubs.Set(utils, 'service_is_up', fake_service_is_up) + self.mock_object(utils, 'service_is_up', fake_service_is_up) def test_capacity_filter_passes(self): self._stub_service_is_up(True) diff --git a/manila/tests/scheduler/test_host_manager.py b/manila/tests/scheduler/test_host_manager.py index be355a08..003c7346 100644 --- a/manila/tests/scheduler/test_host_manager.py +++ b/manila/tests/scheduler/test_host_manager.py @@ -90,7 +90,7 @@ class HostManagerTestCase(test.TestCase): info['got_fprops'].append(filter_props) return True - self.stubs.Set(FakeFilterClass1, '_filter_one', fake_filter_one) + self.mock_object(FakeFilterClass1, '_filter_one', fake_filter_one) result = self.host_manager.get_filtered_hosts(self.fake_hosts, fake_properties) self._verify_result(info, result) diff --git a/manila/tests/scheduler/test_scheduler.py b/manila/tests/scheduler/test_scheduler.py index deaea9ec..70bbe963 100644 --- a/manila/tests/scheduler/test_scheduler.py +++ b/manila/tests/scheduler/test_scheduler.py @@ -178,7 +178,7 @@ class SimpleSchedulerSharesTestCase(test.TestCase): def setUp(self): super(SimpleSchedulerSharesTestCase, self).setUp() - self.stubs.Set(share_rpcapi, 'ShareAPI', mock.Mock()) + self.mock_object(share_rpcapi, 'ShareAPI') self.driver = simple.SimpleScheduler() self.context = context.RequestContext('fake_user', 'fake_project') diff --git a/manila/tests/share/drivers/emc/test_driver.py b/manila/tests/share/drivers/emc/test_driver.py index 3758ad1c..7309e394 100644 --- a/manila/tests/share/drivers/emc/test_driver.py +++ b/manila/tests/share/drivers/emc/test_driver.py @@ -111,7 +111,7 @@ class EMCShareFrameworkTestCase(test.TestCase): self.configuration = conf.Configuration(None) self.configuration.append_config_values = mock.Mock(return_value=0) self.configuration.share_backend_name = FAKE_BACKEND - self.stubs.Set(self.configuration, 'safe_get', self._fake_safe_get) + self.mock_object(self.configuration, 'safe_get', self._fake_safe_get) self.driver = emcdriver.EMCShareDriver( configuration=self.configuration) diff --git a/manila/tests/share/drivers/emc/test_emc_vnx.py b/manila/tests/share/drivers/emc/test_emc_vnx.py index 0b5b4496..b926af6b 100644 --- a/manila/tests/share/drivers/emc/test_emc_vnx.py +++ b/manila/tests/share/drivers/emc/test_emc_vnx.py @@ -1141,7 +1141,7 @@ class EMCShareDriverVNXTestCase(test.TestCase): self.configuration.emc_nas_password = 'fakepwd' self.configuration.emc_nas_server = TD.emc_nas_server_default self.configuration.share_backend_name = 'fake_backend' - self.stubs.Set(self.configuration, 'safe_get', self._fake_safe_get) + self.mock_object(self.configuration, 'safe_get', self._fake_safe_get) self.driver = emc_driver.EMCShareDriver( configuration=self.configuration) self.driver_setup() diff --git a/manila/tests/share/drivers/ganesha/test_manager.py b/manila/tests/share/drivers/ganesha/test_manager.py index 315d0e34..da618128 100644 --- a/manila/tests/share/drivers/ganesha/test_manager.py +++ b/manila/tests/share/drivers/ganesha/test_manager.py @@ -141,12 +141,12 @@ class GaneshaManagerTestCase(test.TestCase): self.mock_restart_service): self._manager = manager.GaneshaManager( self._execute, 'faketag', **manager_fake_kwargs) - self.stubs.Set(utils, 'synchronized', - mock.Mock(return_value=lambda f: f)) + self.mock_object(utils, 'synchronized', + mock.Mock(return_value=lambda f: f)) def test_init(self): - self.stubs.Set(self._manager, 'reset_exports', mock.Mock()) - self.stubs.Set(self._manager, 'restart_service', mock.Mock()) + self.mock_object(self._manager, 'reset_exports') + self.mock_object(self._manager, 'restart_service') self.assertEqual('/fakedir0/fakeconfig', self._manager.ganesha_config_path) self.assertEqual('faketag', self._manager.tag) @@ -174,7 +174,7 @@ class GaneshaManagerTestCase(test.TestCase): raise exception.GaneshaCommandFailure() test_execute = mock.Mock(side_effect=raise_exception) - self.stubs.Set(manager.LOG, 'error', mock.Mock()) + self.mock_object(manager.LOG, 'error') with contextlib.nested( mock.patch.object(manager.GaneshaManager, 'get_export_id', return_value=100), @@ -199,7 +199,7 @@ class GaneshaManagerTestCase(test.TestCase): raise exception.GaneshaCommandFailure() test_execute = mock.Mock(side_effect=raise_exception) - self.stubs.Set(manager.LOG, 'error', mock.Mock()) + self.mock_object(manager.LOG, 'error') with contextlib.nested( mock.patch.object(manager.GaneshaManager, 'get_export_id', return_value=100), @@ -226,8 +226,8 @@ class GaneshaManagerTestCase(test.TestCase): def test_write_file(self): test_data = 'fakedata' - self.stubs.Set(manager.pipes, 'quote', - mock.Mock(return_value='fakefile.conf.RANDOM')) + self.mock_object(manager.pipes, 'quote', + mock.Mock(return_value='fakefile.conf.RANDOM')) test_args = [ ('mktemp', '-p', '/fakedir0/export.d', '-t', 'fakefile.conf.XXXXXX'), @@ -242,8 +242,8 @@ class GaneshaManagerTestCase(test.TestCase): if args == test_args[0]: return ('fakefile.conf.RANDOM\n', '') - self.stubs.Set(self._manager, 'execute', - mock.Mock(side_effect=return_tmpfile)) + self.mock_object(self._manager, 'execute', + mock.Mock(side_effect=return_tmpfile)) self._manager._write_file(test_path, test_data) self._manager.execute.assert_has_calls([ mock.call(*test_args[0]), @@ -253,9 +253,9 @@ class GaneshaManagerTestCase(test.TestCase): def test_write_conf_file(self): test_data = 'fakedata' - self.stubs.Set(self._manager, '_getpath', - mock.Mock(return_value=test_path)) - self.stubs.Set(self._manager, '_write_file', mock.Mock()) + self.mock_object(self._manager, '_getpath', + mock.Mock(return_value=test_path)) + self.mock_object(self._manager, '_write_file') ret = self._manager._write_conf_file(test_name, test_data) self.assertEqual(test_path, ret) self._manager._getpath.assert_called_once_with(test_name) @@ -265,9 +265,9 @@ class GaneshaManagerTestCase(test.TestCase): def test_mkindex(self): test_ls_output = 'INDEX.conf\nfakefile.conf\nfakefile.txt' test_index = '%include /fakedir0/export.d/fakefile.conf\n' - self.stubs.Set(self._manager, 'execute', - mock.Mock(return_value=(test_ls_output, ''))) - self.stubs.Set(self._manager, '_write_conf_file', mock.Mock()) + self.mock_object(self._manager, 'execute', + mock.Mock(return_value=(test_ls_output, ''))) + self.mock_object(self._manager, '_write_conf_file') ret = self._manager._mkindex() self._manager.execute.assert_called_once_with( 'ls', '/fakedir0/export.d', run_as_root=False) @@ -278,12 +278,12 @@ class GaneshaManagerTestCase(test.TestCase): def test_read_export_file(self): test_args = ('cat', test_path) test_kwargs = {'message': 'reading export fakefile'} - self.stubs.Set(self._manager, '_getpath', - mock.Mock(return_value=test_path)) - self.stubs.Set(self._manager, 'execute', - mock.Mock(return_value=(test_ganesha_cnf,))) - self.stubs.Set(manager, 'parseconf', - mock.Mock(return_value=test_dict_unicode)) + self.mock_object(self._manager, '_getpath', + mock.Mock(return_value=test_path)) + self.mock_object(self._manager, 'execute', + mock.Mock(return_value=(test_ganesha_cnf,))) + self.mock_object(manager, 'parseconf', + mock.Mock(return_value=test_dict_unicode)) ret = self._manager._read_export_file(test_name) self._manager._getpath.assert_called_once_with(test_name) self._manager.execute.assert_called_once_with( @@ -292,10 +292,10 @@ class GaneshaManagerTestCase(test.TestCase): self.assertEqual(test_dict_unicode, ret) def test_write_export_file(self): - self.stubs.Set(manager, 'mkconf', - mock.Mock(return_value=test_ganesha_cnf)) - self.stubs.Set(self._manager, '_write_conf_file', - mock.Mock(return_value=test_path)) + self.mock_object(manager, 'mkconf', + mock.Mock(return_value=test_ganesha_cnf)) + self.mock_object(self._manager, '_write_conf_file', + mock.Mock(return_value=test_path)) ret = self._manager._write_export_file(test_name, test_dict_str) manager.mkconf.assert_called_once_with(test_dict_str) self._manager._write_conf_file.assert_called_once_with( @@ -310,10 +310,10 @@ class GaneshaManagerTestCase(test.TestCase): u'CLIENT': {u'Clients': u"'ip1','ip2'"} } } - self.stubs.Set(manager, 'mkconf', - mock.Mock(return_value=test_ganesha_cnf)) - self.stubs.Set(self._manager, '_write_conf_file', - mock.Mock(return_value=test_path)) + self.mock_object(manager, 'mkconf', + mock.Mock(return_value=test_ganesha_cnf)) + self.mock_object(self._manager, '_write_conf_file', + mock.Mock(return_value=test_path)) self.assertRaises(exception.InvalidParameterValue, self._manager._write_export_file, test_name, test_errordict) @@ -321,10 +321,10 @@ class GaneshaManagerTestCase(test.TestCase): self.assertFalse(self._manager._write_conf_file.called) def test_rm_export_file(self): - self.stubs.Set(self._manager, 'execute', - mock.Mock(return_value=('', ''))) - self.stubs.Set(self._manager, '_getpath', - mock.Mock(return_value=test_path)) + self.mock_object(self._manager, 'execute', + mock.Mock(return_value=('', ''))) + self.mock_object(self._manager, '_getpath', + mock.Mock(return_value=test_path)) ret = self._manager._rm_export_file(test_name) self._manager._getpath.assert_called_once_with(test_name) self._manager.execute.assert_called_once_with('rm', test_path) @@ -333,8 +333,8 @@ class GaneshaManagerTestCase(test.TestCase): def test_dbus_send_ganesha(self): test_args = ('arg1', 'arg2') test_kwargs = {'key': 'value'} - self.stubs.Set(self._manager, 'execute', - mock.Mock(return_value=('', ''))) + self.mock_object(self._manager, 'execute', + mock.Mock(return_value=('', ''))) ret = self._manager._dbus_send_ganesha('fakemethod', *test_args, **test_kwargs) self._manager.execute.assert_called_once_with( @@ -346,18 +346,17 @@ class GaneshaManagerTestCase(test.TestCase): self.assertEqual(None, ret) def test_remove_export_dbus(self): - self.stubs.Set(self._manager, '_dbus_send_ganesha', - mock.Mock()) + self.mock_object(self._manager, '_dbus_send_ganesha') ret = self._manager._remove_export_dbus(test_export_id) self._manager._dbus_send_ganesha.assert_called_once_with( 'RemoveExport', 'uint16:101') self.assertEqual(None, ret) def test_add_export(self): - self.stubs.Set(self._manager, '_write_export_file', - mock.Mock(return_value=test_path)) - self.stubs.Set(self._manager, '_dbus_send_ganesha', mock.Mock()) - self.stubs.Set(self._manager, '_mkindex', mock.Mock()) + self.mock_object(self._manager, '_write_export_file', + mock.Mock(return_value=test_path)) + self.mock_object(self._manager, '_dbus_send_ganesha') + self.mock_object(self._manager, '_mkindex') ret = self._manager.add_export(test_name, test_dict_str) self._manager._write_export_file.assert_called_once_with( test_name, test_dict_str) @@ -368,13 +367,14 @@ class GaneshaManagerTestCase(test.TestCase): self.assertEqual(None, ret) def test_add_export_error_during_mkindex(self): - self.stubs.Set(self._manager, '_write_export_file', - mock.Mock(return_value=test_path)) - self.stubs.Set(self._manager, '_dbus_send_ganesha', mock.Mock()) - self.stubs.Set(self._manager, '_mkindex', - mock.Mock(side_effect=exception.GaneshaCommandFailure)) - self.stubs.Set(self._manager, '_rm_export_file', mock.Mock()) - self.stubs.Set(self._manager, '_remove_export_dbus', mock.Mock()) + self.mock_object(self._manager, '_write_export_file', + mock.Mock(return_value=test_path)) + self.mock_object(self._manager, '_dbus_send_ganesha') + self.mock_object( + self._manager, '_mkindex', + mock.Mock(side_effect=exception.GaneshaCommandFailure)) + self.mock_object(self._manager, '_rm_export_file') + self.mock_object(self._manager, '_remove_export_dbus') self.assertRaises(exception.GaneshaCommandFailure, self._manager.add_export, test_name, test_dict_str) self._manager._write_export_file.assert_called_once_with( @@ -388,12 +388,13 @@ class GaneshaManagerTestCase(test.TestCase): test_export_id) def test_add_export_error_during_write_export_file(self): - self.stubs.Set(self._manager, '_write_export_file', - mock.Mock(side_effect=exception.GaneshaCommandFailure)) - self.stubs.Set(self._manager, '_dbus_send_ganesha', mock.Mock()) - self.stubs.Set(self._manager, '_mkindex', mock.Mock()) - self.stubs.Set(self._manager, '_rm_export_file', mock.Mock()) - self.stubs.Set(self._manager, '_remove_export_dbus', mock.Mock()) + self.mock_object( + self._manager, '_write_export_file', + mock.Mock(side_effect=exception.GaneshaCommandFailure)) + self.mock_object(self._manager, '_dbus_send_ganesha') + self.mock_object(self._manager, '_mkindex') + self.mock_object(self._manager, '_rm_export_file') + self.mock_object(self._manager, '_remove_export_dbus') self.assertRaises(exception.GaneshaCommandFailure, self._manager.add_export, test_name, test_dict_str) self._manager._write_export_file.assert_called_once_with( @@ -404,14 +405,14 @@ class GaneshaManagerTestCase(test.TestCase): self.assertFalse(self._manager._remove_export_dbus.called) def test_add_export_error_during_dbus_send_ganesha(self): - self.stubs.Set(self._manager, '_write_export_file', - mock.Mock(return_value=test_path)) - self.stubs.Set(self._manager, '_dbus_send_ganesha', - mock.Mock(side_effect=exception.GaneshaCommandFailure)) - self.stubs.Set(self._manager, '_mkindex', - mock.Mock()) - self.stubs.Set(self._manager, '_rm_export_file', mock.Mock()) - self.stubs.Set(self._manager, '_remove_export_dbus', mock.Mock()) + self.mock_object(self._manager, '_write_export_file', + mock.Mock(return_value=test_path)) + self.mock_object( + self._manager, '_dbus_send_ganesha', + mock.Mock(side_effect=exception.GaneshaCommandFailure)) + self.mock_object(self._manager, '_mkindex') + self.mock_object(self._manager, '_rm_export_file') + self.mock_object(self._manager, '_remove_export_dbus') self.assertRaises(exception.GaneshaCommandFailure, self._manager.add_export, test_name, test_dict_str) self._manager._write_export_file.assert_called_once_with( @@ -424,11 +425,11 @@ class GaneshaManagerTestCase(test.TestCase): self.assertFalse(self._manager._remove_export_dbus.called) def test_remove_export(self): - self.stubs.Set(self._manager, '_read_export_file', - mock.Mock(return_value=test_dict_unicode)) + self.mock_object(self._manager, '_read_export_file', + mock.Mock(return_value=test_dict_unicode)) methods = ('_remove_export_dbus', '_rm_export_file', '_mkindex') for method in methods: - self.stubs.Set(self._manager, method, mock.Mock()) + self.mock_object(self._manager, method) ret = self._manager.remove_export(test_name) self._manager._read_export_file.assert_called_once_with(test_name) self._manager._remove_export_dbus.assert_called_once_with( @@ -438,11 +439,12 @@ class GaneshaManagerTestCase(test.TestCase): self.assertEqual(None, ret) def test_remove_export_error_during_read_export_file(self): - self.stubs.Set(self._manager, '_read_export_file', - mock.Mock(side_effect=exception.GaneshaCommandFailure)) + self.mock_object( + self._manager, '_read_export_file', + mock.Mock(side_effect=exception.GaneshaCommandFailure)) methods = ('_remove_export_dbus', '_rm_export_file', '_mkindex') for method in methods: - self.stubs.Set(self._manager, method, mock.Mock()) + self.mock_object(self._manager, method) self.assertRaises(exception.GaneshaCommandFailure, self._manager.remove_export, test_name) self._manager._read_export_file.assert_called_once_with(test_name) @@ -451,13 +453,14 @@ class GaneshaManagerTestCase(test.TestCase): self._manager._mkindex.assert_called_once_with() def test_remove_export_error_during_remove_export_dbus(self): - self.stubs.Set(self._manager, '_read_export_file', - mock.Mock(return_value=test_dict_unicode)) - self.stubs.Set(self._manager, '_remove_export_dbus', - mock.Mock(side_effect=exception.GaneshaCommandFailure)) + self.mock_object(self._manager, '_read_export_file', + mock.Mock(return_value=test_dict_unicode)) + self.mock_object( + self._manager, '_remove_export_dbus', + mock.Mock(side_effect=exception.GaneshaCommandFailure)) methods = ('_rm_export_file', '_mkindex') for method in methods: - self.stubs.Set(self._manager, method, mock.Mock()) + self.mock_object(self._manager, method) self.assertRaises(exception.GaneshaCommandFailure, self._manager.remove_export, test_name) self._manager._read_export_file.assert_called_once_with(test_name) @@ -467,8 +470,8 @@ class GaneshaManagerTestCase(test.TestCase): self._manager._mkindex.assert_called_once_with() def test_get_export_id(self): - self.stubs.Set(self._manager, 'execute', - mock.Mock(return_value=('exportid|101', ''))) + self.mock_object(self._manager, 'execute', + mock.Mock(return_value=('exportid|101', ''))) ret = self._manager.get_export_id() self._manager.execute.assert_called_once_with( 'sqlite3', self._manager.ganesha_db_path, @@ -478,8 +481,8 @@ class GaneshaManagerTestCase(test.TestCase): self.assertEqual(101, ret) def test_get_export_id_nobump(self): - self.stubs.Set(self._manager, 'execute', - mock.Mock(return_value=('exportid|101', ''))) + self.mock_object(self._manager, 'execute', + mock.Mock(return_value=('exportid|101', ''))) ret = self._manager.get_export_id(bump=False) self._manager.execute.assert_called_once_with( 'sqlite3', self._manager.ganesha_db_path, @@ -488,9 +491,9 @@ class GaneshaManagerTestCase(test.TestCase): self.assertEqual(101, ret) def test_get_export_id_error_invalid_export_db(self): - self.stubs.Set(self._manager, 'execute', - mock.Mock(return_value=('invalid', ''))) - self.stubs.Set(manager.LOG, 'error', mock.Mock()) + self.mock_object(self._manager, 'execute', + mock.Mock(return_value=('invalid', ''))) + self.mock_object(manager.LOG, 'error') self.assertRaises(exception.InvalidSqliteDB, self._manager.get_export_id) manager.LOG.error.assert_called_once_with( @@ -502,15 +505,15 @@ class GaneshaManagerTestCase(test.TestCase): run_as_root=False) def test_restart_service(self): - self.stubs.Set(self._manager, 'execute', mock.Mock()) + self.mock_object(self._manager, 'execute') ret = self._manager.restart_service() self._manager.execute.assert_called_once_with( 'service', 'ganesha.fakeservice', 'restart') self.assertEqual(None, ret) def test_reset_exports(self): - self.stubs.Set(self._manager, 'execute', mock.Mock()) - self.stubs.Set(self._manager, '_mkindex', mock.Mock()) + self.mock_object(self._manager, 'execute') + self.mock_object(self._manager, '_mkindex') ret = self._manager.reset_exports() self._manager.execute.assert_called_once_with( 'sh', '-c', 'rm /fakedir0/export.d/*.conf') diff --git a/manila/tests/share/drivers/ganesha/test_utils.py b/manila/tests/share/drivers/ganesha/test_utils.py index 2cd09bd7..c472d83f 100644 --- a/manila/tests/share/drivers/ganesha/test_utils.py +++ b/manila/tests/share/drivers/ganesha/test_utils.py @@ -45,7 +45,7 @@ class GaneshaUtilsTests(test.TestCase): self.assertEqual(walk_test_list, ret) def test_path_from(self): - self.stubs.Set(os.path, 'abspath', - lambda path: os.path.join('/foo/bar', path)) + self.mock_object(os.path, 'abspath', + lambda path: os.path.join('/foo/bar', path)) ret = utils.path_from('baz.py', '../quux', 'tic/tac/toe') self.assertEqual('/foo/quux/tic/tac/toe', os.path.normpath(ret)) diff --git a/manila/tests/share/drivers/huawei/test_huawei_nas.py b/manila/tests/share/drivers/huawei/test_huawei_nas.py index 952090f6..1947ec6b 100644 --- a/manila/tests/share/drivers/huawei/test_huawei_nas.py +++ b/manila/tests/share/drivers/huawei/test_huawei_nas.py @@ -266,7 +266,7 @@ class HuaweiShareDriverTestCase(test.TestCase): self.configuration.share_backend_name = 'fake_share_backend_name' self.configuration.driver_handles_share_servers = False self.configuration.manila_huawei_conf_file = self.fake_conf_file - self.stubs.Set(time, 'sleep', fake_sleep) + self.mock_object(time, 'sleep', fake_sleep) driver = FakeHuaweiNasDriver(configuration=self.configuration) self.driver = driver self.driver.helper.test_normal = True diff --git a/manila/tests/share/drivers/ibm/test_ganesha_utils.py b/manila/tests/share/drivers/ibm/test_ganesha_utils.py index a43aefc3..b46d5539 100644 --- a/manila/tests/share/drivers/ibm/test_ganesha_utils.py +++ b/manila/tests/share/drivers/ibm/test_ganesha_utils.py @@ -98,9 +98,9 @@ class GaneshaUtilsTestCase(test.TestCase): self.sshlogin = "fake_login" self.sshkey = "fake_sshkey" self.STARTING_EXPORT_ID = 100 - self.stubs.Set(socket, 'gethostname', - mock.Mock(return_value="testserver")) - self.stubs.Set(socket, 'gethostbyname_ex', mock.Mock( + self.mock_object(socket, 'gethostname', + mock.Mock(return_value="testserver")) + self.mock_object(socket, 'gethostbyname_ex', mock.Mock( return_value=('localhost', ['localhost.localdomain', 'testserver'], ['127.0.0.1'] + self.local_ip) @@ -108,8 +108,8 @@ class GaneshaUtilsTestCase(test.TestCase): def test_get_export_by_path(self): fake_export = {'export_id': '100'} - self.stubs.Set(ganesha_utils, '_get_export_by_path', - mock.Mock(return_value=fake_export)) + self.mock_object(ganesha_utils, '_get_export_by_path', + mock.Mock(return_value=fake_export)) export = ganesha_utils.get_export_by_path(self.fake_exports, self.fake_path) self.assertEqual(export, fake_export) @@ -119,8 +119,8 @@ class GaneshaUtilsTestCase(test.TestCase): def test_export_exists(self): fake_export = {'export_id': '100'} - self.stubs.Set(ganesha_utils, '_get_export_by_path', - mock.Mock(return_value=fake_export)) + self.mock_object(ganesha_utils, '_get_export_by_path', + mock.Mock(return_value=fake_export)) result = ganesha_utils.export_exists(self.fake_exports, self.fake_path) self.assertTrue(result) ganesha_utils._get_export_by_path.assert_called_once_with( @@ -184,7 +184,7 @@ class GaneshaUtilsTestCase(test.TestCase): configpath = self.fake_configpath methods = ('_publish_local_config', '_publish_remote_config') for method in methods: - self.stubs.Set(ganesha_utils, method, mock.Mock()) + self.mock_object(ganesha_utils, method) ganesha_utils.publish_ganesha_config(self.servers, self.sshlogin, self.sshkey, configpath, self.fake_pre_lines, @@ -198,7 +198,7 @@ class GaneshaUtilsTestCase(test.TestCase): ) def test_reload_ganesha_config(self): - self.stubs.Set(utils, 'execute', mock.Mock(return_value=True)) + self.mock_object(utils, 'execute', mock.Mock(return_value=True)) service = 'ganesha.nfsd' ganesha_utils.reload_ganesha_config(self.servers, self.sshlogin) reload_cmd = ['service', service, 'restart'] @@ -213,9 +213,9 @@ class GaneshaUtilsTestCase(test.TestCase): @mock.patch('six.moves.builtins.open') def test__publish_local_config(self, mock_open): - self.stubs.Set(utils, 'execute', mock.Mock(return_value=True)) + self.mock_object(utils, 'execute', mock.Mock(return_value=True)) fake_timestamp = 1415506949.75 - self.stubs.Set(time, 'time', mock.Mock(return_value=fake_timestamp)) + self.mock_object(time, 'time', mock.Mock(return_value=fake_timestamp)) configpath = self.fake_configpath tmp_path = '%s.tmp.%s' % (configpath, fake_timestamp) ganesha_utils._publish_local_config(configpath, @@ -231,10 +231,11 @@ class GaneshaUtilsTestCase(test.TestCase): @mock.patch('six.moves.builtins.open') def test__publish_local_config_exception(self, mock_open): - self.stubs.Set(utils, 'execute', - mock.Mock(side_effect=exception.ProcessExecutionError)) + self.mock_object( + utils, 'execute', + mock.Mock(side_effect=exception.ProcessExecutionError)) fake_timestamp = 1415506949.75 - self.stubs.Set(time, 'time', mock.Mock(return_value=fake_timestamp)) + self.mock_object(time, 'time', mock.Mock(return_value=fake_timestamp)) configpath = self.fake_configpath tmp_path = '%s.tmp.%s' % (configpath, fake_timestamp) self.assertRaises(exception.GPFSGaneshaException, @@ -255,8 +256,9 @@ class GaneshaUtilsTestCase(test.TestCase): utils.execute.assert_called_once_with(*scpcmd, run_as_root=False) def test__publish_remote_config_exception(self): - self.stubs.Set(utils, 'execute', - mock.Mock(side_effect=exception.ProcessExecutionError)) + self.mock_object( + utils, 'execute', + mock.Mock(side_effect=exception.ProcessExecutionError)) server = self.remote_ips[1] dest = '%s@%s:%s' % (self.sshlogin, server, self.fake_configpath) scpcmd = ['scp', '-i', self.sshkey, self.fake_configpath, dest] diff --git a/manila/tests/share/drivers/ibm/test_gpfs.py b/manila/tests/share/drivers/ibm/test_gpfs.py index 4a823b07..cbf76eac 100644 --- a/manila/tests/share/drivers/ibm/test_gpfs.py +++ b/manila/tests/share/drivers/ibm/test_gpfs.py @@ -58,7 +58,7 @@ class GPFSShareDriverTestCase(test.TestCase): self.fakefspath = "/gpfs0" self.fakesharepath = "/gpfs0/share-fakeid" self.fakesnapshotpath = "/gpfs0/.snapshots/snapshot-fakesnapshotid" - self.stubs.Set(gpfs.os.path, 'exists', mock.Mock(return_value=True)) + self.mock_object(gpfs.os.path, 'exists', mock.Mock(return_value=True)) self._driver._helpers = { 'KNFS': self._helper_fake } @@ -86,9 +86,9 @@ class GPFSShareDriverTestCase(test.TestCase): self._gnfs_helper.configuration.gpfs_ssh_login = self.sshlogin self._gnfs_helper.configuration.gpfs_ssh_private_key = self.sshkey self._gnfs_helper.configuration.ganesha_service_name = self.gservice - self.stubs.Set(socket, 'gethostname', - mock.Mock(return_value="testserver")) - self.stubs.Set(socket, 'gethostbyname_ex', mock.Mock( + self.mock_object(socket, 'gethostname', + mock.Mock(return_value="testserver")) + self.mock_object(socket, 'gethostbyname_ex', mock.Mock( return_value=('localhost', ['localhost.localdomain', 'testserver'], ['127.0.0.1', self.local_ip]) @@ -100,7 +100,7 @@ class GPFSShareDriverTestCase(test.TestCase): self.assertEqual(self._driver._stats, result) def test_get_share_stats_refresh_true(self): - self.stubs.Set( + self.mock_object( self._driver, '_get_available_capacity', mock.Mock(return_value=(11111.0, 12345.0))) result = self._driver.get_share_stats(True) @@ -118,15 +118,15 @@ class GPFSShareDriverTestCase(test.TestCase): self._driver.configuration.gpfs_mount_point_base) def test_do_setup(self): - self.stubs.Set(self._driver, '_setup_helpers', mock.Mock()) + self.mock_object(self._driver, '_setup_helpers') self._driver.do_setup(self._context) self._driver._setup_helpers.assert_called_any() def test_setup_helpers(self): self._driver._helpers = {} CONF.set_default('gpfs_share_helpers', ['KNFS=fakenfs']) - self.stubs.Set(gpfs.importutils, 'import_class', - mock.Mock(return_value=self._helper_fake)) + self.mock_object(gpfs.importutils, 'import_class', + mock.Mock(return_value=self._helper_fake)) self._driver._setup_helpers() gpfs.importutils.import_class.assert_has_calls( [mock.call('fakenfs')] @@ -143,7 +143,7 @@ class GPFSShareDriverTestCase(test.TestCase): self._helper_fake.create_export.return_value = 'fakelocation' methods = ('_create_share', '_get_share_path') for method in methods: - self.stubs.Set(self._driver, method, mock.Mock()) + self.mock_object(self._driver, method) result = self._driver.create_share(self._context, self.share, share_server=self.server) self._driver._create_share.assert_called_once_with(self.share) @@ -447,7 +447,7 @@ class GPFSShareDriverTestCase(test.TestCase): ) def test__gpfs_local_execute(self): - self.stubs.Set(utils, 'execute', mock.Mock(return_value=True)) + self.mock_object(utils, 'execute', mock.Mock(return_value=True)) cmd = "testcmd" self._driver._gpfs_local_execute(cmd) utils.execute.assert_called_once_with(cmd, run_as_root=True) @@ -467,7 +467,7 @@ class GPFSShareDriverTestCase(test.TestCase): self._knfs_helper._execute = mock.Mock( return_value=['/fs0 ', 0] ) - self.stubs.Set(re, 'search', mock.Mock(return_value=None)) + self.mock_object(re, 'search', mock.Mock(return_value=None)) export_opts = None self._knfs_helper._get_export_options = mock.Mock( return_value=export_opts @@ -488,7 +488,7 @@ class GPFSShareDriverTestCase(test.TestCase): def test_knfs_allow_access_access_exists(self): out = ['/fs0 ', 0] self._knfs_helper._execute = mock.Mock(return_value=out) - self.stubs.Set(re, 'search', mock.Mock(return_value="fake")) + self.mock_object(re, 'search', mock.Mock(return_value="fake")) self._knfs_helper._get_export_options = mock.Mock() access_type = self.access['access_type'] access = self.access['access_to'] @@ -548,7 +548,7 @@ class GPFSShareDriverTestCase(test.TestCase): self._knfs_helper._publish_access.assert_called_once_with(*cmd) def test_knfs__publish_access(self): - self.stubs.Set(utils, 'execute', mock.Mock()) + self.mock_object(utils, 'execute') cmd = ['fakecmd'] self._knfs_helper._publish_access(*cmd) utils.execute.assert_any_call(*cmd, run_as_root=True, @@ -561,8 +561,9 @@ class GPFSShareDriverTestCase(test.TestCase): self.assertTrue(socket.gethostname.called) def test_knfs__publish_access_exception(self): - self.stubs.Set(utils, 'execute', - mock.Mock(side_effect=exception.ProcessExecutionError)) + self.mock_object( + utils, 'execute', + mock.Mock(side_effect=exception.ProcessExecutionError)) cmd = ['fakecmd'] self.assertRaises(exception.ProcessExecutionError, self._knfs_helper._publish_access, *cmd) @@ -621,20 +622,20 @@ class GPFSShareDriverTestCase(test.TestCase): self._gnfs_helper._get_export_options = mock.Mock( return_value=export_opts ) - self.stubs.Set(ganesha_utils, 'parse_ganesha_config', mock.Mock( + self.mock_object(ganesha_utils, 'parse_ganesha_config', mock.Mock( return_value=(pre_lines, exports) )) - self.stubs.Set(ganesha_utils, 'export_exists', mock.Mock( + self.mock_object(ganesha_utils, 'export_exists', mock.Mock( return_value=False )) - self.stubs.Set(ganesha_utils, 'get_next_id', mock.Mock( + self.mock_object(ganesha_utils, 'get_next_id', mock.Mock( return_value=101 )) - self.stubs.Set(ganesha_utils, 'get_export_template', mock.Mock( + self.mock_object(ganesha_utils, 'get_export_template', mock.Mock( return_value={} )) - self.stubs.Set(ganesha_utils, 'publish_ganesha_config', mock.Mock()) - self.stubs.Set(ganesha_utils, 'reload_ganesha_config', mock.Mock()) + self.mock_object(ganesha_utils, 'publish_ganesha_config') + self.mock_object(ganesha_utils, 'reload_ganesha_config') self._gnfs_helper._ganesha_process_request( "allow_access", local_path, self.share, access_type, access ) @@ -661,17 +662,17 @@ class GPFSShareDriverTestCase(test.TestCase): initial_access = "10.0.0.1,10.0.0.2" export = {"rw_access": initial_access} exports = {} - self.stubs.Set(ganesha_utils, 'parse_ganesha_config', mock.Mock( + self.mock_object(ganesha_utils, 'parse_ganesha_config', mock.Mock( return_value=(pre_lines, exports) )) - self.stubs.Set(ganesha_utils, 'get_export_by_path', mock.Mock( + self.mock_object(ganesha_utils, 'get_export_by_path', mock.Mock( return_value=export )) - self.stubs.Set(ganesha_utils, 'format_access_list', mock.Mock( + self.mock_object(ganesha_utils, 'format_access_list', mock.Mock( return_value="10.0.0.1" )) - self.stubs.Set(ganesha_utils, 'publish_ganesha_config', mock.Mock()) - self.stubs.Set(ganesha_utils, 'reload_ganesha_config', mock.Mock()) + self.mock_object(ganesha_utils, 'publish_ganesha_config') + self.mock_object(ganesha_utils, 'reload_ganesha_config') self._gnfs_helper._ganesha_process_request( "deny_access", local_path, self.share, access_type, access ) @@ -694,14 +695,14 @@ class GPFSShareDriverTestCase(test.TestCase): pre_lines = [] exports = {} export = {} - self.stubs.Set(ganesha_utils, 'parse_ganesha_config', mock.Mock( + self.mock_object(ganesha_utils, 'parse_ganesha_config', mock.Mock( return_value=(pre_lines, exports) )) - self.stubs.Set(ganesha_utils, 'get_export_by_path', mock.Mock( + self.mock_object(ganesha_utils, 'get_export_by_path', mock.Mock( return_value=export )) - self.stubs.Set(ganesha_utils, 'publish_ganesha_config', mock.Mock()) - self.stubs.Set(ganesha_utils, 'reload_ganesha_config', mock.Mock()) + self.mock_object(ganesha_utils, 'publish_ganesha_config') + self.mock_object(ganesha_utils, 'reload_ganesha_config') self._gnfs_helper._ganesha_process_request( "remove_export", local_path, self.share ) diff --git a/manila/tests/share/drivers/netapp/test_cluster_mode.py b/manila/tests/share/drivers/netapp/test_cluster_mode.py index 9d8e31f3..0ace2251 100644 --- a/manila/tests/share/drivers/netapp/test_cluster_mode.py +++ b/manila/tests/share/drivers/netapp/test_cluster_mode.py @@ -163,17 +163,16 @@ class NetAppClusteredDrvTestCase(test.TestCase): vserver_name = \ self.driver.configuration.netapp_vserver_name_template % \ self.network_info['server_id'] - self.stubs.Set(self.driver.db, 'share_server_backend_details_set', - mock.Mock()) - self.stubs.Set(self.driver, '_vserver_exists', - mock.Mock(return_value=True)) - self.stubs.Set(self.driver, '_get_cluster_nodes', - mock.Mock(return_value=nodes)) - self.stubs.Set(self.driver, '_get_node_data_port', - mock.Mock(return_value=port)) - self.stubs.Set(self.driver, '_create_lif_if_not_exists', mock.Mock()) - self.stubs.Set(self.driver, '_enable_nfs', mock.Mock()) - self.stubs.Set(self.driver, '_setup_security_services', mock.Mock()) + self.mock_object(self.driver.db, 'share_server_backend_details_set') + self.mock_object(self.driver, '_vserver_exists', + mock.Mock(return_value=True)) + self.mock_object(self.driver, '_get_cluster_nodes', + mock.Mock(return_value=nodes)) + self.mock_object(self.driver, '_get_node_data_port', + mock.Mock(return_value=port)) + self.mock_object(self.driver, '_create_lif_if_not_exists') + self.mock_object(self.driver, '_enable_nfs') + self.mock_object(self.driver, '_setup_security_services') returned_data = self.driver._vserver_create_if_not_exists( self.network_info) @@ -217,17 +216,16 @@ class NetAppClusteredDrvTestCase(test.TestCase): vserver_name = \ self.driver.configuration.netapp_vserver_name_template % \ network_info['server_id'] - self.stubs.Set(self.driver.db, 'share_server_backend_details_set', - mock.Mock()) - self.stubs.Set(self.driver, '_vserver_exists', - mock.Mock(return_value=False)) - self.stubs.Set(self.driver, '_create_vserver', mock.Mock()) - self.stubs.Set(self.driver, '_get_cluster_nodes', - mock.Mock(return_value=nodes)) - self.stubs.Set(self.driver, '_get_node_data_port', - mock.Mock(return_value=port)) - self.stubs.Set(self.driver, '_create_lif_if_not_exists', mock.Mock()) - self.stubs.Set(self.driver, '_enable_nfs', mock.Mock()) + self.mock_object(self.driver.db, 'share_server_backend_details_set') + self.mock_object(self.driver, '_vserver_exists', + mock.Mock(return_value=False)) + self.mock_object(self.driver, '_create_vserver') + self.mock_object(self.driver, '_get_cluster_nodes', + mock.Mock(return_value=nodes)) + self.mock_object(self.driver, '_get_node_data_port', + mock.Mock(return_value=port)) + self.mock_object(self.driver, '_create_lif_if_not_exists') + self.mock_object(self.driver, '_enable_nfs') returned_data = self.driver._vserver_create_if_not_exists(network_info) @@ -268,18 +266,17 @@ class NetAppClusteredDrvTestCase(test.TestCase): vserver_name = \ self.driver.configuration.netapp_vserver_name_template % \ network_info['server_id'] - self.stubs.Set(self.driver.db, 'share_server_backend_details_set', - mock.Mock()) - self.stubs.Set(self.driver, '_vserver_exists', - mock.Mock(return_value=False)) - self.stubs.Set(self.driver, '_create_vserver', mock.Mock()) - self.stubs.Set(self.driver, '_get_cluster_nodes', - mock.Mock(return_value=nodes)) - self.stubs.Set(self.driver, '_get_node_data_port', - mock.Mock(return_value=port)) - self.stubs.Set(self.driver, '_create_lif_if_not_exists', mock.Mock()) - self.stubs.Set(self.driver, '_enable_nfs', mock.Mock()) - self.stubs.Set(self.driver, '_setup_security_services', mock.Mock()) + self.mock_object(self.driver.db, 'share_server_backend_details_set') + self.mock_object(self.driver, '_vserver_exists', + mock.Mock(return_value=False)) + self.mock_object(self.driver, '_create_vserver') + self.mock_object(self.driver, '_get_cluster_nodes', + mock.Mock(return_value=nodes)) + self.mock_object(self.driver, '_get_node_data_port', + mock.Mock(return_value=port)) + self.mock_object(self.driver, '_create_lif_if_not_exists') + self.mock_object(self.driver, '_enable_nfs') + self.mock_object(self.driver, '_setup_security_services') returned_data = self.driver._vserver_create_if_not_exists(network_info) @@ -467,8 +464,9 @@ class NetAppClusteredDrvTestCase(test.TestCase): fake_share.fake_share(share_proto='NFSBOGUS'), fake_share.fake_share(share_proto='CIFSBOGUS')) def test_get_helper_with_wrong_proto(self, share): - self.stubs.Set(self.driver, '_check_licenses', - mock.Mock(return_value=share['share_proto'])) + self.mock_object(self.driver, + '_check_licenses', + mock.Mock(return_value=share['share_proto'])) self.assertRaises(exception.NetAppException, self.driver._get_helper, share) @@ -570,8 +568,8 @@ class NetAppClusteredDrvTestCase(test.TestCase): 'domain': 'FAKE', } self.driver._configure_dns = mock.Mock() - self.stubs.Set(self._vserver_client, 'send_request', - mock.Mock(side_effect=naapi.NaApiError())) + self.mock_object(self._vserver_client, 'send_request', + mock.Mock(side_effect=naapi.NaApiError())) self.assertRaises( exception.NetAppException, @@ -744,9 +742,9 @@ class NetAppClusteredDrvTestCase(test.TestCase): licenses = naapi.NaElement('fake_licenses_as_response') licenses.translate_struct(licenses_dict) - self.stubs.Set(self.driver._client, 'send_request', - mock.Mock(return_value=licenses)) - self.stubs.Set(driver.LOG, 'info', mock.Mock()) + self.mock_object(self.driver._client, 'send_request', + mock.Mock(return_value=licenses)) + self.mock_object(driver.LOG, 'info') response = self.driver._check_licenses() @@ -756,9 +754,9 @@ class NetAppClusteredDrvTestCase(test.TestCase): self.assertEqual(response, ['fake_license_1', 'fake_license_2']) def test_licenses_exception_raise(self): - self.stubs.Set(self.driver._client, 'send_request', - mock.Mock(side_effect=naapi.NaApiError())) - self.stubs.Set(driver.LOG, 'error', mock.Mock()) + self.mock_object(self.driver._client, 'send_request', + mock.Mock(side_effect=naapi.NaApiError())) + self.mock_object(driver.LOG, 'error') self.driver._check_licenses() @@ -786,11 +784,11 @@ class NetAppNFSHelperTestCase(test.TestCase): def test_create_share(self): export_ip = 'fake_export_ip' junction = 'fake-vserver-location' - self.stubs.Set(self.helper._client, 'send_request', mock.Mock()) + self.mock_object(self.helper._client, 'send_request') self.helper._client.send_request().get_child_by_name = mock.Mock() self.helper._client.send_request().get_child_by_name().get_content = ( mock.Mock(side_effect=lambda: junction)) - self.stubs.Set(self.helper, 'add_rules', mock.Mock()) + self.mock_object(self.helper, 'add_rules') location = self.helper.create_share(self.share['name'], export_ip) @@ -825,8 +823,8 @@ class NetAppNFSHelperTestCase(test.TestCase): if pathname.startswith(volume_path): raise naapi.NaApiError('13114') - self.stubs.Set(self.helper._client, 'send_request', - mock.Mock(side_effect=raise_exception_13114)) + self.mock_object(self.helper._client, 'send_request', + mock.Mock(side_effect=raise_exception_13114)) self.helper.add_rules(volume_path, rules) @@ -847,8 +845,8 @@ class NetAppNFSHelperTestCase(test.TestCase): not self.helper.nfs_exports_with_prefix): raise naapi.NaApiError('13114') - self.stubs.Set(self.helper._client, 'send_request', - mock.Mock(side_effect=raise_exception_13114)) + self.mock_object(self.helper._client, 'send_request', + mock.Mock(side_effect=raise_exception_13114)) self.helper.add_rules(volume_path, rules) @@ -912,8 +910,8 @@ class NetAppCIFSHelperTestCase(test.TestCase): name=self.name, export_location=export_location) self.helper = driver.NetAppClusteredCIFSHelper() - self.stubs.Set(self.helper, '_client', mock.Mock()) - self.stubs.Set(self.helper._client, 'send_request', mock.Mock()) + self.mock_object(self.helper, '_client') + self.mock_object(self.helper._client, 'send_request') def test_create_share(self): self.helper.create_share(self.name, '1.1.1.1') @@ -946,8 +944,8 @@ class NetAppCIFSHelperTestCase(test.TestCase): ) def test_allow_access_user_type_rule_already_present(self): - self.stubs.Set(self.helper._client, 'send_request', - mock.Mock(side_effect=naapi.NaApiError('13130'))) + self.mock_object(self.helper._client, 'send_request', + mock.Mock(side_effect=naapi.NaApiError('13130'))) access = {'access_to': 'fake_access', 'access_type': 'user'} self.assertRaises( exception.ShareAccessExists, @@ -993,8 +991,8 @@ class NetAppCIFSHelperTestCase(test.TestCase): ) def test_deny_access_exception_raised(self): - self.stubs.Set(self.helper, '_restrict_access', - mock.Mock(side_effect=naapi.NaApiError())) + self.mock_object(self.helper, '_restrict_access', + mock.Mock(side_effect=naapi.NaApiError())) self.assertRaises( naapi.NaApiError, self.helper.deny_access, diff --git a/manila/tests/share/drivers/test_ganesha.py b/manila/tests/share/drivers/test_ganesha.py index 638b3306..a94ef66f 100644 --- a/manila/tests/share/drivers/test_ganesha.py +++ b/manila/tests/share/drivers/test_ganesha.py @@ -80,14 +80,14 @@ class GaneshaNASHelperTestCase(test.TestCase): copy.deepcopy(tmpl1), copy.deepcopy(tmpl2)) tmpl1.update(tmpl2) - self.stubs.Set(ganesha.os, 'listdir', - mock.Mock(return_value=fake_ls_dir)) - self.stubs.Set(ganesha.LOG, 'info', mock.Mock()) - self.stubs.Set(ganesha.ganesha_manager, 'parseconf', - mock.Mock(side_effect=[fake_template1, - fake_template2])) - self.stubs.Set(ganesha.ganesha_utils, 'patch', - mock.Mock(side_effect=fake_patch_run)) + self.mock_object(ganesha.os, 'listdir', + mock.Mock(return_value=fake_ls_dir)) + self.mock_object(ganesha.LOG, 'info') + self.mock_object(ganesha.ganesha_manager, 'parseconf', + mock.Mock(side_effect=[fake_template1, + fake_template2])) + self.mock_object(ganesha.ganesha_utils, 'patch', + mock.Mock(side_effect=fake_patch_run)) with mock.patch('six.moves.builtins.open', mock.mock_open()) as mockopen: mockopen().read.side_effect = ['fakeconf0', 'fakeconf1'] @@ -108,13 +108,13 @@ class GaneshaNASHelperTestCase(test.TestCase): self.assertEqual(fake_template2, ret) def test_load_conf_dir_no_conf_dir_must_exist_false(self): - self.stubs.Set( + self.mock_object( ganesha.os, 'listdir', mock.Mock(side_effect=OSError(errno.ENOENT, os.strerror(errno.ENOENT)))) - self.stubs.Set(ganesha.LOG, 'info', mock.Mock()) - self.stubs.Set(ganesha.ganesha_manager, 'parseconf', mock.Mock()) - self.stubs.Set(ganesha.ganesha_utils, 'patch', mock.Mock()) + self.mock_object(ganesha.LOG, 'info') + self.mock_object(ganesha.ganesha_manager, 'parseconf') + self.mock_object(ganesha.ganesha_utils, 'patch') with mock.patch('six.moves.builtins.open', mock.mock_open(read_data='fakeconf')) as mockopen: ret = self._helper._load_conf_dir(self.fake_conf_dir_path, @@ -129,7 +129,7 @@ class GaneshaNASHelperTestCase(test.TestCase): self.assertEqual({}, ret) def test_load_conf_dir_error_no_conf_dir_must_exist_true(self): - self.stubs.Set( + self.mock_object( ganesha.os, 'listdir', mock.Mock(side_effect=OSError(errno.ENOENT, os.strerror(errno.ENOENT)))) @@ -138,7 +138,7 @@ class GaneshaNASHelperTestCase(test.TestCase): ganesha.os.listdir.assert_called_once_with(self.fake_conf_dir_path) def test_load_conf_dir_error_conf_dir_present_must_exist_false(self): - self.stubs.Set( + self.mock_object( ganesha.os, 'listdir', mock.Mock(side_effect=OSError(errno.EACCES, os.strerror(errno.EACCES)))) @@ -147,7 +147,7 @@ class GaneshaNASHelperTestCase(test.TestCase): ganesha.os.listdir.assert_called_once_with(self.fake_conf_dir_path) def test_load_conf_dir_error(self): - self.stubs.Set( + self.mock_object( ganesha.os, 'listdir', mock.Mock(side_effect=RuntimeError('fake error'))) self.assertRaises(RuntimeError, self._helper._load_conf_dir, @@ -157,11 +157,11 @@ class GaneshaNASHelperTestCase(test.TestCase): def test_init_helper(self): mock_template = mock.Mock() mock_ganesha_manager = mock.Mock() - self.stubs.Set(ganesha.ganesha_manager, 'GaneshaManager', - mock.Mock(return_value=mock_ganesha_manager)) - self.stubs.Set(self._helper, '_load_conf_dir', - mock.Mock(return_value=mock_template)) - self.stubs.Set(self._helper, '_default_config_hook', mock.Mock()) + self.mock_object(ganesha.ganesha_manager, 'GaneshaManager', + mock.Mock(return_value=mock_ganesha_manager)) + self.mock_object(self._helper, '_load_conf_dir', + mock.Mock(return_value=mock_template)) + self.mock_object(self._helper, '_default_config_hook') ret = self._helper.init_helper() ganesha.ganesha_manager.GaneshaManager.assert_called_once_with( self._execute, 'faketag', @@ -179,12 +179,12 @@ class GaneshaNASHelperTestCase(test.TestCase): def test_init_helper_conf_dir_empty(self): mock_template = mock.Mock() mock_ganesha_manager = mock.Mock() - self.stubs.Set(ganesha.ganesha_manager, 'GaneshaManager', - mock.Mock(return_value=mock_ganesha_manager)) - self.stubs.Set(self._helper, '_load_conf_dir', - mock.Mock(return_value={})) - self.stubs.Set(self._helper, '_default_config_hook', - mock.Mock(return_value=mock_template)) + self.mock_object(ganesha.ganesha_manager, 'GaneshaManager', + mock.Mock(return_value=mock_ganesha_manager)) + self.mock_object(self._helper, '_load_conf_dir', + mock.Mock(return_value={})) + self.mock_object(self._helper, '_default_config_hook', + mock.Mock(return_value=mock_template)) ret = self._helper.init_helper() ganesha.ganesha_manager.GaneshaManager.assert_called_once_with( self._execute, 'faketag', @@ -201,10 +201,10 @@ class GaneshaNASHelperTestCase(test.TestCase): def test_default_config_hook(self): fake_template = {'key': 'value'} - self.stubs.Set(ganesha.ganesha_utils, 'path_from', - mock.Mock(return_value='/fakedir3/fakeconfdir')) - self.stubs.Set(self._helper, '_load_conf_dir', - mock.Mock(return_value=fake_template)) + self.mock_object(ganesha.ganesha_utils, 'path_from', + mock.Mock(return_value='/fakedir3/fakeconfdir')) + self.mock_object(self._helper, '_load_conf_dir', + mock.Mock(return_value=fake_template)) ret = self._helper._default_config_hook() ganesha.ganesha_utils.path_from.assert_called_once_with( ganesha.__file__, 'conf') @@ -223,12 +223,12 @@ class GaneshaNASHelperTestCase(test.TestCase): mock_ganesha_utils_patch(copy.deepcopy(tmpl1), tmpl2, tmpl3) tmpl1.update(tmpl3) - self.stubs.Set(self._helper.ganesha, 'get_export_id', - mock.Mock(return_value=101)) - self.stubs.Set(self._helper, '_fsal_hook', - mock.Mock(return_value='fakefsal')) - self.stubs.Set(ganesha.ganesha_utils, 'patch', - mock.Mock(side_effect=fake_patch_run)) + self.mock_object(self._helper.ganesha, 'get_export_id', + mock.Mock(return_value=101)) + self.mock_object(self._helper, '_fsal_hook', + mock.Mock(return_value='fakefsal')) + self.mock_object(ganesha.ganesha_utils, 'patch', + mock.Mock(side_effect=fake_patch_run)) ret = self._helper.allow_access(fake_basepath, self.share, self.access) self._helper.ganesha.get_export_id.assert_called_once_with() diff --git a/manila/tests/share/drivers/test_generic.py b/manila/tests/share/drivers/test_generic.py index 481d4d1b..c99b1578 100644 --- a/manila/tests/share/drivers/test_generic.py +++ b/manila/tests/share/drivers/test_generic.py @@ -83,9 +83,10 @@ class GenericShareDriverTestCase(test.TestCase): context="fake", instance_name="fake", share_network_id=self.fake_sn["id"], old_server_ip="fake") - self.stubs.Set(utils, 'synchronized', - mock.Mock(return_value=lambda f: f)) - self.stubs.Set(generic.os.path, 'exists', mock.Mock(return_value=True)) + self.mock_object(utils, 'synchronized', + mock.Mock(return_value=lambda f: f)) + self.mock_object(generic.os.path, 'exists', + mock.Mock(return_value=True)) self._driver._helpers = { 'CIFS': self._helper_cifs, 'NFS': self._helper_nfs, @@ -106,9 +107,9 @@ class GenericShareDriverTestCase(test.TestCase): self.snapshot = fake_share.fake_snapshot() def test_do_setup(self): - self.stubs.Set(volume, 'API', mock.Mock()) - self.stubs.Set(compute, 'API', mock.Mock()) - self.stubs.Set(self._driver, '_setup_helpers', mock.Mock()) + self.mock_object(volume, 'API') + self.mock_object(compute, 'API') + self.mock_object(self._driver, '_setup_helpers') self._driver.do_setup(self._context) volume.API.assert_called_once_with() compute.API.assert_called_once_with() @@ -117,8 +118,8 @@ class GenericShareDriverTestCase(test.TestCase): def test_setup_helpers(self): self._driver._helpers = {} CONF.set_default('share_helpers', ['NFS=fakenfs']) - self.stubs.Set(generic.importutils, 'import_class', - mock.Mock(return_value=self._helper_nfs)) + self.mock_object(generic.importutils, 'import_class', + mock.Mock(return_value=self._helper_nfs)) self._driver._setup_helpers() generic.importutils.import_class.assert_has_calls([ mock.call('fakenfs') @@ -134,12 +135,12 @@ class GenericShareDriverTestCase(test.TestCase): volume = 'fake_volume' volume2 = 'fake_volume2' self._helper_nfs.create_export.return_value = 'fakelocation' - self.stubs.Set(self._driver, '_allocate_container', - mock.Mock(return_value=volume)) - self.stubs.Set(self._driver, '_attach_volume', - mock.Mock(return_value=volume2)) - self.stubs.Set(self._driver, '_format_device', mock.Mock()) - self.stubs.Set(self._driver, '_mount_device', mock.Mock()) + self.mock_object(self._driver, '_allocate_container', + mock.Mock(return_value=volume)) + self.mock_object(self._driver, '_attach_volume', + mock.Mock(return_value=volume2)) + self.mock_object(self._driver, '_format_device') + self.mock_object(self._driver, '_mount_device') result = self._driver.create_share( self._context, self.share, share_server=self.server) @@ -163,8 +164,8 @@ class GenericShareDriverTestCase(test.TestCase): def test_format_device(self): volume = {'mountpoint': 'fake_mount_point'} - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(return_value=('', ''))) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(return_value=('', ''))) self._driver._format_device(self.server, volume) self._driver._ssh_exec.assert_called_once_with( self.server, @@ -175,14 +176,13 @@ class GenericShareDriverTestCase(test.TestCase): server = {'instance_id': 'fake_server_id'} mount_path = '/fake/mount/path' volume = {'mountpoint': 'fake_mount_point'} - self.stubs.Set(self._driver, '_is_device_mounted', - mock.Mock(return_value=False)) - self.stubs.Set(self._driver, '_sync_mount_temp_and_perm_files', - mock.Mock()) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(return_value=('', ''))) + self.mock_object(self._driver, '_is_device_mounted', + mock.Mock(return_value=False)) + self.mock_object(self._driver, '_sync_mount_temp_and_perm_files') + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(return_value=('', ''))) self._driver._mount_device(self.share, server, volume) @@ -201,11 +201,11 @@ class GenericShareDriverTestCase(test.TestCase): def test_mount_device_present(self): mount_path = '/fake/mount/path' volume = {'mountpoint': 'fake_mount_point'} - self.stubs.Set(self._driver, '_is_device_mounted', - mock.Mock(return_value=True)) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) - self.stubs.Set(generic.LOG, 'warning', mock.Mock()) + self.mock_object(self._driver, '_is_device_mounted', + mock.Mock(return_value=True)) + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) + self.mock_object(generic.LOG, 'warning') self._driver._mount_device(self.share, self.server, volume) @@ -216,10 +216,11 @@ class GenericShareDriverTestCase(test.TestCase): def test_mount_device_exception_raised(self): volume = {'mountpoint': 'fake_mount_point'} - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value='fake')) - self.stubs.Set(self._driver, '_is_device_mounted', - mock.Mock(side_effect=exception.ProcessExecutionError)) + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value='fake')) + self.mock_object( + self._driver, '_is_device_mounted', + mock.Mock(side_effect=exception.ProcessExecutionError)) self.assertRaises( exception.ShareBackendException, @@ -234,14 +235,13 @@ class GenericShareDriverTestCase(test.TestCase): def test_unmount_device_present(self): mount_path = '/fake/mount/path' - self.stubs.Set(self._driver, '_is_device_mounted', - mock.Mock(return_value=True)) - self.stubs.Set(self._driver, '_sync_mount_temp_and_perm_files', - mock.Mock()) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(return_value=('', ''))) + self.mock_object(self._driver, '_is_device_mounted', + mock.Mock(return_value=True)) + self.mock_object(self._driver, '_sync_mount_temp_and_perm_files') + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(return_value=('', ''))) self._driver._unmount_device(self.share, self.server) @@ -257,11 +257,11 @@ class GenericShareDriverTestCase(test.TestCase): def test_unmount_device_not_present(self): mount_path = '/fake/mount/path' - self.stubs.Set(self._driver, '_is_device_mounted', - mock.Mock(return_value=False)) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) - self.stubs.Set(generic.LOG, 'warning', mock.Mock()) + self.mock_object(self._driver, '_is_device_mounted', + mock.Mock(return_value=False)) + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) + self.mock_object(generic.LOG, 'warning') self._driver._unmount_device(self.share, self.server) @@ -275,10 +275,10 @@ class GenericShareDriverTestCase(test.TestCase): mount_path = '/fake/mount/path' mounts = "%(dev)s on %(path)s" % {'dev': volume['mountpoint'], 'path': mount_path} - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(return_value=(mounts, ''))) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(return_value=(mounts, ''))) + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) result = self._driver._is_device_mounted( self.share, self.server, volume) @@ -291,10 +291,10 @@ class GenericShareDriverTestCase(test.TestCase): def test_is_device_mounted_true_no_volume_provided(self): mount_path = '/fake/mount/path' mounts = "/fake/dev/path on %(path)s type fake" % {'path': mount_path} - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(return_value=(mounts, ''))) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(return_value=(mounts, ''))) + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) result = self._driver._is_device_mounted(self.share, self.server) @@ -308,10 +308,10 @@ class GenericShareDriverTestCase(test.TestCase): volume = {'mountpoint': 'fake_mount_point', 'id': 'fake_id'} mounts = "%(dev)s on %(path)s" % {'dev': '/fake', 'path': mount_path} - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(return_value=(mounts, ''))) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(return_value=(mounts, ''))) + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) result = self._driver._is_device_mounted( self.share, self.server, volume) @@ -324,10 +324,10 @@ class GenericShareDriverTestCase(test.TestCase): def test_is_device_mounted_false_no_volume_provided(self): mount_path = '/fake/mount/path' mounts = "%(path)s" % {'path': 'fake'} - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(return_value=(mounts, ''))) - self.stubs.Set(self._driver, '_get_mount_path', - mock.Mock(return_value=mount_path)) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(return_value=(mounts, ''))) + self.mock_object(self._driver, '_get_mount_path', + mock.Mock(return_value=mount_path)) result = self._driver._is_device_mounted(self.share, self.server) @@ -337,7 +337,7 @@ class GenericShareDriverTestCase(test.TestCase): self.assertEqual(result, False) def test_sync_mount_temp_and_perm_files(self): - self.stubs.Set(self._driver, '_ssh_exec', mock.Mock()) + self.mock_object(self._driver, '_ssh_exec') self._driver._sync_mount_temp_and_perm_files(self.server) self._driver._ssh_exec.has_calls( mock.call( @@ -346,8 +346,9 @@ class GenericShareDriverTestCase(test.TestCase): mock.call(self.server, ['sudo', 'mount', '-a'])) def test_sync_mount_temp_and_perm_files_raise_error_on_copy(self): - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(side_effect=exception.ProcessExecutionError)) + self.mock_object( + self._driver, '_ssh_exec', + mock.Mock(side_effect=exception.ProcessExecutionError)) self.assertRaises( exception.ShareBackendException, self._driver._sync_mount_temp_and_perm_files, @@ -362,8 +363,8 @@ class GenericShareDriverTestCase(test.TestCase): if args[1][1] == 'cp': raise exception.ProcessExecutionError() - self.stubs.Set(self._driver, '_ssh_exec', - mock.Mock(side_effect=raise_error_on_mount)) + self.mock_object(self._driver, '_ssh_exec', + mock.Mock(side_effect=raise_error_on_mount)) self.assertRaises( exception.ShareBackendException, self._driver._sync_mount_temp_and_perm_files, @@ -383,10 +384,9 @@ class GenericShareDriverTestCase(test.TestCase): def test_attach_volume_not_attached(self): availiable_volume = fake_volume.FakeVolume() attached_volume = fake_volume.FakeVolume(status='in-use') - self.stubs.Set(self._driver.compute_api, 'instance_volume_attach', - mock.Mock()) - self.stubs.Set(self._driver.volume_api, 'get', - mock.Mock(return_value=attached_volume)) + self.mock_object(self._driver.compute_api, 'instance_volume_attach') + self.mock_object(self._driver.volume_api, 'get', + mock.Mock(return_value=attached_volume)) result = self._driver._attach_volume(self._context, self.share, 'fake_inst_id', availiable_volume) @@ -401,8 +401,8 @@ class GenericShareDriverTestCase(test.TestCase): def test_attach_volume_attached_correct(self): fake_server = fake_compute.FakeServer() attached_volume = fake_volume.FakeVolume(status='in-use') - self.stubs.Set(self._driver.compute_api, 'instance_volumes_list', - mock.Mock(return_value=[attached_volume])) + self.mock_object(self._driver.compute_api, 'instance_volumes_list', + mock.Mock(return_value=[attached_volume])) result = self._driver._attach_volume(self._context, self.share, fake_server, attached_volume) @@ -413,8 +413,8 @@ class GenericShareDriverTestCase(test.TestCase): fake_server = fake_compute.FakeServer() attached_volume = fake_volume.FakeVolume(status='in-use') anoter_volume = fake_volume.FakeVolume(id='fake_id2', status='in-use') - self.stubs.Set(self._driver.compute_api, 'instance_volumes_list', - mock.Mock(return_value=[anoter_volume])) + self.mock_object(self._driver.compute_api, 'instance_volumes_list', + mock.Mock(return_value=[anoter_volume])) self.assertRaises(exception.ManilaException, self._driver._attach_volume, self._context, self.share, fake_server, attached_volume) @@ -422,8 +422,8 @@ class GenericShareDriverTestCase(test.TestCase): def test_attach_volume_failed_attach(self): fake_server = fake_compute.FakeServer() availiable_volume = fake_volume.FakeVolume() - self.stubs.Set(self._driver.compute_api, 'instance_volume_attach', - mock.Mock(side_effect=exception.ManilaException)) + self.mock_object(self._driver.compute_api, 'instance_volume_attach', + mock.Mock(side_effect=exception.ManilaException)) self.assertRaises(exception.ManilaException, self._driver._attach_volume, self._context, self.share, fake_server, @@ -433,10 +433,9 @@ class GenericShareDriverTestCase(test.TestCase): fake_server = fake_compute.FakeServer() availiable_volume = fake_volume.FakeVolume() error_volume = fake_volume.FakeVolume(status='error') - self.stubs.Set(self._driver.compute_api, 'instance_volume_attach', - mock.Mock()) - self.stubs.Set(self._driver.volume_api, 'get', - mock.Mock(return_value=error_volume)) + self.mock_object(self._driver.compute_api, 'instance_volume_attach') + self.mock_object(self._driver.volume_api, 'get', + mock.Mock(return_value=error_volume)) self.assertRaises(exception.ManilaException, self._driver._attach_volume, self._context, self.share, @@ -445,22 +444,22 @@ class GenericShareDriverTestCase(test.TestCase): def test_get_volume(self): volume = fake_volume.FakeVolume( display_name=CONF.volume_name_template % self.share['id']) - self.stubs.Set(self._driver.volume_api, 'get_all', - mock.Mock(return_value=[volume])) + self.mock_object(self._driver.volume_api, 'get_all', + mock.Mock(return_value=[volume])) result = self._driver._get_volume(self._context, self.share['id']) self.assertEqual(result, volume) def test_get_volume_none(self): - self.stubs.Set(self._driver.volume_api, 'get_all', - mock.Mock(return_value=[])) + self.mock_object(self._driver.volume_api, 'get_all', + mock.Mock(return_value=[])) result = self._driver._get_volume(self._context, self.share['id']) self.assertEqual(result, None) def test_get_volume_error(self): volume = fake_volume.FakeVolume( display_name=CONF.volume_name_template % self.share['id']) - self.stubs.Set(self._driver.volume_api, 'get_all', - mock.Mock(return_value=[volume, volume])) + self.mock_object(self._driver.volume_api, 'get_all', + mock.Mock(return_value=[volume, volume])) self.assertRaises(exception.ManilaException, self._driver._get_volume, self._context, self.share['id']) @@ -469,15 +468,15 @@ class GenericShareDriverTestCase(test.TestCase): volume_snapshot = fake_volume.FakeVolumeSnapshot( display_name=CONF.volume_snapshot_name_template % self.snapshot['id']) - self.stubs.Set(self._driver.volume_api, 'get_all_snapshots', - mock.Mock(return_value=[volume_snapshot])) + self.mock_object(self._driver.volume_api, 'get_all_snapshots', + mock.Mock(return_value=[volume_snapshot])) result = self._driver._get_volume_snapshot(self._context, self.snapshot['id']) self.assertEqual(result, volume_snapshot) def test_get_volume_snapshot_none(self): - self.stubs.Set(self._driver.volume_api, 'get_all_snapshots', - mock.Mock(return_value=[])) + self.mock_object(self._driver.volume_api, 'get_all_snapshots', + mock.Mock(return_value=[])) result = self._driver._get_volume_snapshot(self._context, self.share['id']) self.assertEqual(result, None) @@ -486,9 +485,9 @@ class GenericShareDriverTestCase(test.TestCase): volume_snapshot = fake_volume.FakeVolumeSnapshot( display_name=CONF.volume_snapshot_name_template % self.snapshot['id']) - self.stubs.Set(self._driver.volume_api, 'get_all_snapshots', - mock.Mock(return_value=[volume_snapshot, - volume_snapshot])) + self.mock_object(self._driver.volume_api, 'get_all_snapshots', + mock.Mock(return_value=[volume_snapshot, + volume_snapshot])) self.assertRaises(exception.ManilaException, self._driver._get_volume_snapshot, self._context, self.share['id']) @@ -496,14 +495,13 @@ class GenericShareDriverTestCase(test.TestCase): def test_detach_volume(self): availiable_volume = fake_volume.FakeVolume() attached_volume = fake_volume.FakeVolume(status='in-use') - self.stubs.Set(self._driver, '_get_volume', - mock.Mock(return_value=attached_volume)) - self.stubs.Set(self._driver.compute_api, 'instance_volumes_list', - mock.Mock(return_value=[attached_volume])) - self.stubs.Set(self._driver.compute_api, 'instance_volume_detach', - mock.Mock()) - self.stubs.Set(self._driver.volume_api, 'get', - mock.Mock(return_value=availiable_volume)) + self.mock_object(self._driver, '_get_volume', + mock.Mock(return_value=attached_volume)) + self.mock_object(self._driver.compute_api, 'instance_volumes_list', + mock.Mock(return_value=[attached_volume])) + self.mock_object(self._driver.compute_api, 'instance_volume_detach') + self.mock_object(self._driver.volume_api, 'get', + mock.Mock(return_value=availiable_volume)) self._driver._detach_volume(self._context, self.share, self.server['backend_details']) @@ -519,14 +517,13 @@ class GenericShareDriverTestCase(test.TestCase): def test_detach_volume_detached(self): availiable_volume = fake_volume.FakeVolume() attached_volume = fake_volume.FakeVolume(status='in-use') - self.stubs.Set(self._driver, '_get_volume', - mock.Mock(return_value=attached_volume)) - self.stubs.Set(self._driver.compute_api, 'instance_volumes_list', - mock.Mock(return_value=[])) - self.stubs.Set(self._driver.volume_api, 'get', - mock.Mock(return_value=availiable_volume)) - self.stubs.Set(self._driver.compute_api, 'instance_volume_detach', - mock.Mock()) + self.mock_object(self._driver, '_get_volume', + mock.Mock(return_value=attached_volume)) + self.mock_object(self._driver.compute_api, 'instance_volumes_list', + mock.Mock(return_value=[])) + self.mock_object(self._driver.volume_api, 'get', + mock.Mock(return_value=availiable_volume)) + self.mock_object(self._driver.compute_api, 'instance_volume_detach') self._driver._detach_volume(self._context, self.share, self.server['backend_details']) @@ -538,8 +535,8 @@ class GenericShareDriverTestCase(test.TestCase): def test_allocate_container(self): fake_vol = fake_volume.FakeVolume() self.fake_conf.cinder_volume_type = 'fake_volume_type' - self.stubs.Set(self._driver.volume_api, 'create', - mock.Mock(return_value=fake_vol)) + self.mock_object(self._driver.volume_api, 'create', + mock.Mock(return_value=fake_vol)) result = self._driver._allocate_container(self._context, self.share) self.assertEqual(result, fake_vol) @@ -554,10 +551,10 @@ class GenericShareDriverTestCase(test.TestCase): def test_allocate_container_with_snaphot(self): fake_vol = fake_volume.FakeVolume() fake_vol_snap = fake_volume.FakeVolumeSnapshot() - self.stubs.Set(self._driver, '_get_volume_snapshot', - mock.Mock(return_value=fake_vol_snap)) - self.stubs.Set(self._driver.volume_api, 'create', - mock.Mock(return_value=fake_vol)) + self.mock_object(self._driver, '_get_volume_snapshot', + mock.Mock(return_value=fake_vol_snap)) + self.mock_object(self._driver.volume_api, 'create', + mock.Mock(return_value=fake_vol)) result = self._driver._allocate_container(self._context, self.share, @@ -573,8 +570,8 @@ class GenericShareDriverTestCase(test.TestCase): def test_allocate_container_error(self): fake_vol = fake_volume.FakeVolume(status='error') - self.stubs.Set(self._driver.volume_api, 'create', - mock.Mock(return_value=fake_vol)) + self.mock_object(self._driver.volume_api, 'create', + mock.Mock(return_value=fake_vol)) self.assertRaises(exception.ManilaException, self._driver._allocate_container, @@ -583,10 +580,10 @@ class GenericShareDriverTestCase(test.TestCase): def test_deallocate_container(self): fake_vol = fake_volume.FakeVolume() - self.stubs.Set(self._driver, '_get_volume', - mock.Mock(return_value=fake_vol)) - self.stubs.Set(self._driver.volume_api, 'delete', mock.Mock()) - self.stubs.Set(self._driver.volume_api, 'get', mock.Mock( + self.mock_object(self._driver, '_get_volume', + mock.Mock(return_value=fake_vol)) + self.mock_object(self._driver.volume_api, 'delete') + self.mock_object(self._driver.volume_api, 'get', mock.Mock( side_effect=exception.VolumeNotFound(volume_id=fake_vol['id']))) self._driver._deallocate_container(self._context, self.share) @@ -602,11 +599,11 @@ class GenericShareDriverTestCase(test.TestCase): vol1 = 'fake_vol1' vol2 = 'fake_vol2' self._helper_nfs.create_export.return_value = 'fakelocation' - self.stubs.Set(self._driver, '_allocate_container', - mock.Mock(return_value=vol1)) - self.stubs.Set(self._driver, '_attach_volume', - mock.Mock(return_value=vol2)) - self.stubs.Set(self._driver, '_mount_device', mock.Mock()) + self.mock_object(self._driver, '_allocate_container', + mock.Mock(return_value=vol1)) + self.mock_object(self._driver, '_attach_volume', + mock.Mock(return_value=vol2)) + self.mock_object(self._driver, '_mount_device') result = self._driver.create_share_from_snapshot( self._context, @@ -626,11 +623,11 @@ class GenericShareDriverTestCase(test.TestCase): self.server['backend_details'], self.share['name']) def test_delete_share_no_share_servers_handling(self): - self.stubs.Set(self._driver, '_deallocate_container', mock.Mock()) - self.stubs.Set( + self.mock_object(self._driver, '_deallocate_container') + self.mock_object( self._driver.service_instance_manager, 'get_common_server', mock.Mock(return_value=self.server)) - self.stubs.Set( + self.mock_object( self._driver.service_instance_manager, 'ensure_service_instance', mock.Mock(return_value=False)) @@ -647,9 +644,9 @@ class GenericShareDriverTestCase(test.TestCase): self._context, self.server['backend_details']) def test_delete_share(self): - self.stubs.Set(self._driver, '_unmount_device', mock.Mock()) - self.stubs.Set(self._driver, '_detach_volume', mock.Mock()) - self.stubs.Set(self._driver, '_deallocate_container', mock.Mock()) + self.mock_object(self._driver, '_unmount_device') + self.mock_object(self._driver, '_detach_volume') + self.mock_object(self._driver, '_deallocate_container') self._driver.delete_share( self._context, self.share, share_server=self.server) @@ -668,9 +665,9 @@ class GenericShareDriverTestCase(test.TestCase): self._context, self.server['backend_details']) def test_delete_share_without_share_server(self): - self.stubs.Set(self._driver, '_unmount_device', mock.Mock()) - self.stubs.Set(self._driver, '_detach_volume', mock.Mock()) - self.stubs.Set(self._driver, '_deallocate_container', mock.Mock()) + self.mock_object(self._driver, '_unmount_device') + self.mock_object(self._driver, '_detach_volume') + self.mock_object(self._driver, '_deallocate_container') self._driver.delete_share( self._context, self.share, share_server=None) @@ -682,9 +679,9 @@ class GenericShareDriverTestCase(test.TestCase): self._driver.admin_context, self.share) def test_delete_share_without_server_backend_details(self): - self.stubs.Set(self._driver, '_unmount_device', mock.Mock()) - self.stubs.Set(self._driver, '_detach_volume', mock.Mock()) - self.stubs.Set(self._driver, '_deallocate_container', mock.Mock()) + self.mock_object(self._driver, '_unmount_device') + self.mock_object(self._driver, '_detach_volume') + self.mock_object(self._driver, '_deallocate_container') fake_share_server = { 'instance_id': 'fake_instance_id', @@ -705,11 +702,11 @@ class GenericShareDriverTestCase(test.TestCase): self._driver.admin_context, self.share) def test_delete_share_without_server_availability(self): - self.stubs.Set(self._driver, '_unmount_device', mock.Mock()) - self.stubs.Set(self._driver, '_detach_volume', mock.Mock()) - self.stubs.Set(self._driver, '_deallocate_container', mock.Mock()) + self.mock_object(self._driver, '_unmount_device') + self.mock_object(self._driver, '_detach_volume') + self.mock_object(self._driver, '_deallocate_container') - self.stubs.Set( + self.mock_object( self._driver.service_instance_manager, 'ensure_service_instance', mock.Mock(return_value=False)) self._driver.delete_share( @@ -727,10 +724,10 @@ class GenericShareDriverTestCase(test.TestCase): def test_create_snapshot(self): fake_vol = fake_volume.FakeVolume() fake_vol_snap = fake_volume.FakeVolumeSnapshot(share_id=fake_vol['id']) - self.stubs.Set(self._driver, '_get_volume', - mock.Mock(return_value=fake_vol)) - self.stubs.Set(self._driver.volume_api, 'create_snapshot_force', - mock.Mock(return_value=fake_vol_snap)) + self.mock_object(self._driver, '_get_volume', + mock.Mock(return_value=fake_vol)) + self.mock_object(self._driver.volume_api, 'create_snapshot_force', + mock.Mock(return_value=fake_vol_snap)) self._driver.create_snapshot(self._context, fake_vol_snap, share_server=self.server) @@ -747,12 +744,13 @@ class GenericShareDriverTestCase(test.TestCase): def test_delete_snapshot(self): fake_vol_snap = fake_volume.FakeVolumeSnapshot() fake_vol_snap2 = {'id': 'fake_vol_snap2'} - self.stubs.Set(self._driver, '_get_volume_snapshot', - mock.Mock(return_value=fake_vol_snap2)) - self.stubs.Set(self._driver.volume_api, 'delete_snapshot', mock.Mock()) - self.stubs.Set(self._driver.volume_api, 'get_snapshot', - mock.Mock(side_effect=exception.VolumeSnapshotNotFound( - snapshot_id=fake_vol_snap['id']))) + self.mock_object(self._driver, '_get_volume_snapshot', + mock.Mock(return_value=fake_vol_snap2)) + self.mock_object(self._driver.volume_api, 'delete_snapshot') + self.mock_object( + self._driver.volume_api, 'get_snapshot', + mock.Mock(side_effect=exception.VolumeSnapshotNotFound( + snapshot_id=fake_vol_snap['id']))) self._driver.delete_snapshot(self._context, fake_vol_snap, share_server=self.server) @@ -768,11 +766,11 @@ class GenericShareDriverTestCase(test.TestCase): vol1 = 'fake_vol1' vol2 = 'fake_vol2' self._helper_nfs.create_export.return_value = 'fakelocation' - self.stubs.Set(self._driver, '_get_volume', - mock.Mock(return_value=vol1)) - self.stubs.Set(self._driver, '_attach_volume', - mock.Mock(return_value=vol2)) - self.stubs.Set(self._driver, '_mount_device', mock.Mock()) + self.mock_object(self._driver, '_get_volume', + mock.Mock(return_value=vol1)) + self.mock_object(self._driver, '_attach_volume', + mock.Mock(return_value=vol2)) + self.mock_object(self._driver, '_mount_device') self._driver.ensure_share( self._context, self.share, share_server=self.server) @@ -835,9 +833,9 @@ class GenericShareDriverTestCase(test.TestCase): net_info = {'server_id': 'fake', 'neutron_net_id': 'fake-net-id', 'neutron_subnet_id': 'fake-subnet-id'} - self.stubs.Set(self._driver.service_instance_manager, - 'set_up_service_instance', - mock.Mock(side_effect=raise_exception)) + self.mock_object(self._driver.service_instance_manager, + 'set_up_service_instance', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.ServiceInstanceException, self._driver.setup_server, net_info) @@ -862,9 +860,9 @@ class GenericShareDriverTestCase(test.TestCase): ssh.get_transport().is_active = mock.Mock(return_value=True) ssh_pool = mock.Mock() ssh_pool.create = mock.Mock(return_value=ssh) - self.stubs.Set(utils, 'SSHPool', mock.Mock(return_value=ssh_pool)) - self.stubs.Set(processutils, 'ssh_execute', - mock.Mock(return_value=ssh_output)) + self.mock_object(utils, 'SSHPool', mock.Mock(return_value=ssh_pool)) + self.mock_object(processutils, 'ssh_execute', + mock.Mock(return_value=ssh_output)) self._driver.ssh_connections = {} result = self._driver._ssh_exec(self.server, cmd) @@ -888,8 +886,8 @@ class GenericShareDriverTestCase(test.TestCase): ssh.get_transport = mock.Mock() ssh.get_transport().is_active = mock.Mock(side_effect=lambda: True) ssh_pool = mock.Mock() - self.stubs.Set(processutils, 'ssh_execute', - mock.Mock(return_value=ssh_output)) + self.mock_object(processutils, 'ssh_execute', + mock.Mock(return_value=ssh_output)) self._driver.ssh_connections = { self.server['instance_id']: (ssh_pool, ssh) } @@ -913,8 +911,8 @@ class GenericShareDriverTestCase(test.TestCase): ssh_pool = mock.Mock() ssh_pool.create = mock.Mock(side_effect=lambda: ssh) ssh_pool.remove = mock.Mock() - self.stubs.Set(processutils, 'ssh_execute', - mock.Mock(return_value=ssh_output)) + self.mock_object(processutils, 'ssh_execute', + mock.Mock(return_value=ssh_output)) self._driver.ssh_connections = { self.server['instance_id']: (ssh_pool, ssh) } @@ -1026,7 +1024,7 @@ class NFSHelperTestCase(test.TestCase): def setUp(self): super(NFSHelperTestCase, self).setUp() - fake_utils.stub_out_utils_execute(self.stubs) + fake_utils.stub_out_utils_execute(self) self.fake_conf = manila.share.configuration.Configuration(None) self._ssh_exec = mock.Mock(return_value=('', '')) self._execute = mock.Mock(return_value=('', '')) @@ -1044,8 +1042,7 @@ class NFSHelperTestCase(test.TestCase): self.assertEqual(ret, expected_location) def test_allow_access(self): - self.stubs.Set(self._helper, '_sync_nfs_temp_and_perm_files', - mock.Mock()) + self.mock_object(self._helper, '_sync_nfs_temp_and_perm_files') self._helper.allow_access(self.server, 'fake_share', 'ip', '10.0.0.2') local_path = os.path.join(CONF.share_mount_path, 'fake_share') @@ -1066,8 +1063,7 @@ class NFSHelperTestCase(test.TestCase): ) def test_deny_access(self): - self.stubs.Set(self._helper, '_sync_nfs_temp_and_perm_files', - mock.Mock()) + self.mock_object(self._helper, '_sync_nfs_temp_and_perm_files') local_path = os.path.join(CONF.share_mount_path, 'fake_share') self._helper.deny_access(self.server, 'fake_share', 'ip', '10.0.0.2') export_string = ':'.join(['10.0.0.2', local_path]) @@ -1109,8 +1105,8 @@ class CIFSHelperTestCase(test.TestCase): else: return ('', '') - self.stubs.Set(self._helper, '_ssh_exec', - mock.Mock(side_effect=fake_ssh_exec)) + self.mock_object(self._helper, '_ssh_exec', + mock.Mock(side_effect=fake_ssh_exec)) ret = self._helper.create_export(self.server_details, self.share_name) expected_location = '//%s/%s' % ( @@ -1193,8 +1189,8 @@ class CIFSHelperTestCase(test.TestCase): else: return ('', '') - self.stubs.Set(self._helper, '_ssh_exec', - mock.Mock(side_effect=fake_ssh_exec)) + self.mock_object(self._helper, '_ssh_exec', + mock.Mock(side_effect=fake_ssh_exec)) self._helper.remove_export(self.server_details, self.share_name) @@ -1212,9 +1208,9 @@ class CIFSHelperTestCase(test.TestCase): def test_allow_access_ip_exist(self): ip = '1.1.1.1' hosts = [ip, ] - self.stubs.Set(self._helper, '_get_allow_hosts', - mock.Mock(return_value=hosts)) - self.stubs.Set(self._helper, '_set_allow_hosts', mock.Mock()) + self.mock_object(self._helper, '_get_allow_hosts', + mock.Mock(return_value=hosts)) + self.mock_object(self._helper, '_set_allow_hosts') self.assertRaises( exception.ShareAccessExists, @@ -1232,9 +1228,9 @@ class CIFSHelperTestCase(test.TestCase): def test_allow_access_ip_does_not_exist(self): ip = '1.1.1.1' hosts = [] - self.stubs.Set(self._helper, '_get_allow_hosts', - mock.Mock(return_value=hosts)) - self.stubs.Set(self._helper, '_set_allow_hosts', mock.Mock()) + self.mock_object(self._helper, '_get_allow_hosts', + mock.Mock(return_value=hosts)) + self.mock_object(self._helper, '_set_allow_hosts') self._helper.allow_access( self.server_details, self.share_name, 'ip', ip) @@ -1257,9 +1253,9 @@ class CIFSHelperTestCase(test.TestCase): def test_deny_access_list_has_value(self): ip = '1.1.1.1' hosts = [ip, ] - self.stubs.Set(self._helper, '_get_allow_hosts', - mock.Mock(return_value=hosts)) - self.stubs.Set(self._helper, '_set_allow_hosts', mock.Mock()) + self.mock_object(self._helper, '_get_allow_hosts', + mock.Mock(return_value=hosts)) + self.mock_object(self._helper, '_set_allow_hosts') self._helper.deny_access( self.server_details, self.share_name, 'ip', ip) @@ -1272,9 +1268,9 @@ class CIFSHelperTestCase(test.TestCase): def test_deny_access_list_does_not_have_value(self): ip = '1.1.1.1' hosts = [] - self.stubs.Set(self._helper, '_get_allow_hosts', - mock.Mock(return_value=hosts)) - self.stubs.Set(self._helper, '_set_allow_hosts', mock.Mock()) + self.mock_object(self._helper, '_get_allow_hosts', + mock.Mock(return_value=hosts)) + self.mock_object(self._helper, '_set_allow_hosts') self._helper.deny_access( self.server_details, self.share_name, 'ip', ip) @@ -1284,12 +1280,12 @@ class CIFSHelperTestCase(test.TestCase): self._helper._set_allow_hosts.assert_has_calls([]) def test_deny_access_force(self): - self.stubs.Set( + self.mock_object( self._helper, '_get_allow_hosts', mock.Mock(side_effect=exception.ProcessExecutionError()), ) - self.stubs.Set(self._helper, '_set_allow_hosts', mock.Mock()) + self.mock_object(self._helper, '_set_allow_hosts') self._helper.deny_access( self.server_details, self.share_name, 'ip', '1.1.1.1', force=True) @@ -1302,9 +1298,9 @@ class CIFSHelperTestCase(test.TestCase): def raise_process_execution_error(*args, **kwargs): raise exception.ProcessExecutionError() - self.stubs.Set(self._helper, '_get_allow_hosts', - mock.Mock(side_effect=raise_process_execution_error)) - self.stubs.Set(self._helper, '_set_allow_hosts', mock.Mock()) + self.mock_object(self._helper, '_get_allow_hosts', + mock.Mock(side_effect=raise_process_execution_error)) + self.mock_object(self._helper, '_set_allow_hosts') self.assertRaises( exception.ProcessExecutionError, self._helper.deny_access, diff --git a/manila/tests/share/drivers/test_glusterfs.py b/manila/tests/share/drivers/test_glusterfs.py index a61a0a11..0cd2db02 100644 --- a/manila/tests/share/drivers/test_glusterfs.py +++ b/manila/tests/share/drivers/test_glusterfs.py @@ -122,8 +122,8 @@ class GlusterManagerTestCase(test.TestCase): def test_get_gluster_vol_option_empty_volinfo(self): args = ('--xml', 'volume', 'info', self._gluster_manager.volume) - self.stubs.Set(self._gluster_manager, 'gluster_call', - mock.Mock(return_value=('', {}))) + self.mock_object(self._gluster_manager, 'gluster_call', + mock.Mock(return_value=('', {}))) self.assertRaises(exception.GlusterfsException, self._gluster_manager.get_gluster_vol_option, NFS_EXPORT_DIR) @@ -136,8 +136,8 @@ class GlusterManagerTestCase(test.TestCase): raise RuntimeError('fake error') args = ('--xml', 'volume', 'info', self._gluster_manager.volume) - self.stubs.Set(self._gluster_manager, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(self._gluster_manager, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(RuntimeError, self._gluster_manager.get_gluster_vol_option, NFS_EXPORT_DIR) @@ -157,8 +157,8 @@ class GlusterManagerTestCase(test.TestCase): """, '' args = ('--xml', 'volume', 'info', self._gluster_manager.volume) - self.stubs.Set(self._gluster_manager, 'gluster_call', - mock.Mock(side_effect=xml_output)) + self.mock_object(self._gluster_manager, 'gluster_call', + mock.Mock(side_effect=xml_output)) self.assertRaises(exception.InvalidShare, self._gluster_manager.get_gluster_vol_option, NFS_EXPORT_DIR) @@ -179,8 +179,8 @@ class GlusterManagerTestCase(test.TestCase): """, '' args = ('--xml', 'volume', 'info', self._gluster_manager.volume) - self.stubs.Set(self._gluster_manager, 'gluster_call', - mock.Mock(side_effect=xml_output)) + self.mock_object(self._gluster_manager, 'gluster_call', + mock.Mock(side_effect=xml_output)) ret = self._gluster_manager.get_gluster_vol_option(NFS_EXPORT_DIR) self.assertEqual(None, ret) self._gluster_manager.gluster_call.assert_called_once_with(*args) @@ -206,8 +206,8 @@ class GlusterManagerTestCase(test.TestCase): """, '' args = ('--xml', 'volume', 'info', self._gluster_manager.volume) - self.stubs.Set(self._gluster_manager, 'gluster_call', - mock.Mock(side_effect=xml_output)) + self.mock_object(self._gluster_manager, 'gluster_call', + mock.Mock(side_effect=xml_output)) ret = self._gluster_manager.get_gluster_vol_option(NFS_EXPORT_DIR) self.assertEqual('/foo(10.0.0.1|10.0.0.2),/bar(10.0.0.1)', ret) self._gluster_manager.gluster_call.assert_called_once_with(*args) @@ -218,7 +218,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): def setUp(self): super(GlusterfsShareDriverTestCase, self).setUp() - fake_utils.stub_out_utils_execute(self.stubs) + fake_utils.stub_out_utils_execute(self) self._execute = fake_utils.fake_execute self._context = context.get_admin_context() self.addCleanup(fake_utils.fake_execute_set_repliers, []) @@ -246,9 +246,9 @@ class GlusterfsShareDriverTestCase(test.TestCase): fake_gluster_manager = mock.Mock(**fake_gluster_manager_attrs) methods = ('_ensure_gluster_vol_mounted', '_setup_helpers') for method in methods: - self.stubs.Set(self._driver, method, mock.Mock()) - self.stubs.Set(glusterfs, 'GlusterManager', - mock.Mock(return_value=fake_gluster_manager)) + self.mock_object(self._driver, method) + self.mock_object(glusterfs, 'GlusterManager', + mock.Mock(return_value=fake_gluster_manager)) expected_exec = ['mount.glusterfs'] exec_cmd1 = 'mount.glusterfs' expected_exec = [exec_cmd1] @@ -286,12 +286,12 @@ class GlusterfsShareDriverTestCase(test.TestCase): 'gluster_call.side_effect': exception.ProcessExecutionError, 'get_gluster_vol_option.return_value': 'off'} fake_gluster_manager = mock.Mock(**attrs) - self.stubs.Set(glusterfs.LOG, 'error', mock.Mock()) + self.mock_object(glusterfs.LOG, 'error') methods = ('_ensure_gluster_vol_mounted', '_setup_helpers') for method in methods: - self.stubs.Set(self._driver, method, mock.Mock()) - self.stubs.Set(glusterfs, 'GlusterManager', - mock.Mock(return_value=fake_gluster_manager)) + self.mock_object(self._driver, method) + self.mock_object(glusterfs, 'GlusterManager', + mock.Mock(return_value=fake_gluster_manager)) expected_exec = ['mount.glusterfs'] exec_cmd1 = 'mount.glusterfs' expected_exec = [exec_cmd1] @@ -317,12 +317,12 @@ class GlusterfsShareDriverTestCase(test.TestCase): 'gluster_call.side_effect': exception.ProcessExecutionError, 'get_gluster_vol_option.return_value': 'on'} fake_gluster_manager = mock.Mock(**attrs) - self.stubs.Set(glusterfs.LOG, 'error', mock.Mock()) + self.mock_object(glusterfs.LOG, 'error') methods = ('_ensure_gluster_vol_mounted', '_setup_helpers') for method in methods: - self.stubs.Set(self._driver, method, mock.Mock()) - self.stubs.Set(glusterfs, 'GlusterManager', - mock.Mock(return_value=fake_gluster_manager)) + self.mock_object(self._driver, method) + self.mock_object(glusterfs, 'GlusterManager', + mock.Mock(return_value=fake_gluster_manager)) expected_exec = ['mount.glusterfs'] exec_cmd1 = 'mount.glusterfs' expected_exec = [exec_cmd1] @@ -343,8 +343,8 @@ class GlusterfsShareDriverTestCase(test.TestCase): self._driver._ensure_gluster_vol_mounted.assert_called_once_with() def test_setup_helpers(self): - self.stubs.Set(glusterfs, 'GlusterNFSHelper', - mock.Mock(return_value=self._helper_nfs)) + self.mock_object(glusterfs, 'GlusterNFSHelper', + mock.Mock(return_value=self._helper_nfs)) self._driver._setup_helpers() glusterfs.GlusterNFSHelper.assert_called_once_with( self._execute, self.fake_conf, @@ -479,13 +479,13 @@ class GlusterfsShareDriverTestCase(test.TestCase): self._driver._update_share_stats) def test_create_share(self): - self.stubs.Set(self._driver, '_get_helper', mock.Mock()) + self.mock_object(self._driver, '_get_helper') args = ('volume', 'quota', 'testvol', 'limit-usage', '/fakename', '1GB') exec_cmd1 = 'mkdir %s' % fake_local_share_path expected_exec = [exec_cmd1, ] expected_ret = 'testuser@127.0.0.1:/testvol/fakename' - self.stubs.Set( + self.mock_object( self._driver, '_get_local_share_path', mock.Mock(return_value=fake_local_share_path)) ret = self._driver.create_share(self._context, self.share) @@ -500,14 +500,12 @@ class GlusterfsShareDriverTestCase(test.TestCase): def exec_runner(*ignore_args, **ignore_kw): raise exception.ProcessExecutionError - self.stubs.Set(self._driver, '_get_helper', mock.Mock()) - self.stubs.Set( + self.mock_object(self._driver, '_get_helper') + self.mock_object( self._driver, '_get_local_share_path', mock.Mock(return_value=fake_local_share_path)) - self.stubs.Set( - self._driver, '_cleanup_create_share', mock.Mock()) - self.stubs.Set( - glusterfs.LOG, 'error', mock.Mock()) + self.mock_object(self._driver, '_cleanup_create_share') + self.mock_object(glusterfs.LOG, 'error') expected_exec = ['mkdir %s' % fake_local_share_path] fake_utils.fake_execute_set_repliers([(expected_exec[0], exec_runner)]) @@ -522,7 +520,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): mock.ANY, mock.ANY) def test_create_share_error_unsupported_share_type(self): - self.stubs.Set( + self.mock_object( self._driver, '_get_helper', mock.Mock(side_effect=exception. InvalidShare(reason="Unsupported Share type"))) @@ -533,7 +531,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): def test_create_share_can_be_called_with_extra_arg_share_server(self): share_server = None self._driver._get_local_share_path = mock.Mock() - self.stubs.Set(self._driver, '_get_helper', mock.Mock()) + self.mock_object(self._driver, '_get_helper') with mock.patch.object(os.path, 'join', return_value=None): ret = self._driver.create_share(self._context, self.share, share_server) @@ -546,8 +544,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): def test_cleanup_create_share_local_share_path_exists(self): expected_exec = ['rm -rf %s' % fake_local_share_path] - self.stubs.Set( - os.path, 'exists', mock.Mock(return_value=True)) + self.mock_object(os.path, 'exists', mock.Mock(return_value=True)) ret = self._driver._cleanup_create_share(fake_local_share_path, self.share['name']) os.path.exists.assert_called_once_with(fake_local_share_path) @@ -561,10 +558,8 @@ class GlusterfsShareDriverTestCase(test.TestCase): expected_exec = ['rm -rf %s' % fake_local_share_path] fake_utils.fake_execute_set_repliers([(expected_exec[0], exec_runner)]) - self.stubs.Set( - glusterfs.LOG, 'error', mock.Mock()) - self.stubs.Set( - os.path, 'exists', mock.Mock(return_value=True)) + self.mock_object(glusterfs.LOG, 'error') + self.mock_object(os.path, 'exists', mock.Mock(return_value=True)) self.assertRaises(exception.GlusterfsException, self._driver._cleanup_create_share, fake_local_share_path, self.share['name']) @@ -572,8 +567,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): glusterfs.LOG.error.assert_called_once_with(mock.ANY, mock.ANY) def test_cleanup_create_share_local_share_path_does_not_exist(self): - self.stubs.Set( - os.path, 'exists', mock.Mock(return_value=False)) + self.mock_object(os.path, 'exists', mock.Mock(return_value=False)) ret = self._driver._cleanup_create_share(fake_local_share_path, self.share['name']) os.path.exists.assert_called_once_with(fake_local_share_path) @@ -619,7 +613,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): exception.InvalidShare, self._driver._get_helper, share) def test_allow_access(self): - self.stubs.Set(self._driver, '_get_helper', mock.Mock()) + self.mock_object(self._driver, '_get_helper') ret = self._driver.allow_access(self._context, self.share, fake_share.fake_access) self._driver._get_helper.assert_called_once_with(self.share) @@ -629,7 +623,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): self.assertEqual(None, ret) def test_allow_access_can_be_called_with_extra_arg_share_server(self): - self.stubs.Set(self._driver, '_get_helper', mock.Mock()) + self.mock_object(self._driver, '_get_helper') ret = self._driver.allow_access(self._context, self.share, fake_share.fake_access, share_server=None) @@ -640,7 +634,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): self.assertEqual(None, ret) def test_deny_access(self): - self.stubs.Set(self._driver, '_get_helper', mock.Mock()) + self.mock_object(self._driver, '_get_helper') ret = self._driver.deny_access(self._context, self.share, fake_share.fake_access) self._driver._get_helper.assert_called_once_with(self.share) @@ -650,7 +644,7 @@ class GlusterfsShareDriverTestCase(test.TestCase): self.assertEqual(None, ret) def test_deny_access_can_be_called_with_extra_arg_share_server(self): - self.stubs.Set(self._driver, '_get_helper', mock.Mock()) + self.mock_object(self._driver, '_get_helper') ret = self._driver.deny_access(self._context, self.share, fake_share.fake_access, share_server=None) @@ -666,7 +660,7 @@ class GlusterNFSHelperTestCase(test.TestCase): def setUp(self): super(GlusterNFSHelperTestCase, self).setUp() - fake_utils.stub_out_utils_execute(self.stubs) + fake_utils.stub_out_utils_execute(self) gluster_manager = mock.Mock(**fake_gluster_manager_attrs) self._execute = mock.Mock(return_value=('', '')) self.fake_conf = config.Configuration(None) @@ -687,9 +681,9 @@ class GlusterNFSHelperTestCase(test.TestCase): def raise_exception(*args, **kwargs): raise exception.ProcessExecutionError() - self.stubs.Set(glusterfs.LOG, 'error', mock.Mock()) - self.stubs.Set(self._helper.gluster_manager, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(glusterfs.LOG, 'error') + self.mock_object(self._helper.gluster_manager, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._helper.init_helper) self._helper.gluster_manager.gluster_call.assert_called_once_with( @@ -698,8 +692,9 @@ class GlusterNFSHelperTestCase(test.TestCase): def test_get_export_dir_dict(self): output_str = '/foo(10.0.0.1|10.0.0.2),/bar(10.0.0.1)' - self.stubs.Set(self._helper.gluster_manager, 'get_gluster_vol_option', - mock.Mock(return_value=output_str)) + self.mock_object(self._helper.gluster_manager, + 'get_gluster_vol_option', + mock.Mock(return_value=output_str)) ret = self._helper._get_export_dir_dict() self.assertEqual( {'foo': ['10.0.0.1', '10.0.0.2'], 'bar': ['10.0.0.1']}, ret) @@ -717,8 +712,8 @@ class GlusterNFSHelperTestCase(test.TestCase): cbk = mock.Mock(return_value=True) access = fake_share.fake_access() export_dir_dict = mock.Mock() - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) ret = self._helper._manage_access(fake_share_name, access['access_type'], access['access_to'], cbk) @@ -740,8 +735,8 @@ class GlusterNFSHelperTestCase(test.TestCase): export_str = '/example.com(10.0.0.1),/fakename(10.0.0.2|10.0.0.1)' args = ('volume', 'set', self._helper.gluster_manager.volume, NFS_EXPORT_DIR, export_str) - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) ret = self._helper._manage_access(fake_share_name, access['access_type'], access['access_to'], cbk) @@ -766,11 +761,11 @@ class GlusterNFSHelperTestCase(test.TestCase): export_str = '/example.com(10.0.0.1),/fakename(10.0.0.2|10.0.0.1)' args = ('volume', 'set', self._helper.gluster_manager.volume, NFS_EXPORT_DIR, export_str) - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) - self.stubs.Set(self._helper.gluster_manager, 'gluster_call', - mock.Mock(side_effect=raise_exception)) - self.stubs.Set(glusterfs.LOG, 'error', mock.Mock()) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper.gluster_manager, 'gluster_call', + mock.Mock(side_effect=raise_exception)) + self.mock_object(glusterfs.LOG, 'error') self.assertRaises(exception.ProcessExecutionError, self._helper._manage_access, fake_share_name, access['access_type'], @@ -789,8 +784,8 @@ class GlusterNFSHelperTestCase(test.TestCase): args = ('volume', 'reset', self._helper.gluster_manager.volume, NFS_EXPORT_DIR) export_dir_dict = {'fakename': ['10.0.0.1']} - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) ret = self._helper._manage_access(fake_share_name, access['access_type'], access['access_to'], cbk) @@ -806,8 +801,8 @@ class GlusterNFSHelperTestCase(test.TestCase): export_str = '/example.com(10.0.0.1),/fakename(10.0.0.1)' args = ('volume', 'set', self._helper.gluster_manager.volume, NFS_EXPORT_DIR, export_str) - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) self._helper.allow_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self._helper.gluster_manager.gluster_call.assert_called_once_with( @@ -817,8 +812,8 @@ class GlusterNFSHelperTestCase(test.TestCase): access = fake_share.fake_access() share = fake_share.fake_share() export_dir_dict = {'fakename': ['10.0.0.1']} - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) self._helper.allow_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self.assertFalse(self._helper.gluster_manager.gluster_call.called) @@ -827,8 +822,8 @@ class GlusterNFSHelperTestCase(test.TestCase): access = fake_share.fake_access() share = fake_share.fake_share() export_dir_dict = {} - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) self._helper.deny_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self.assertFalse(self._helper.gluster_manager.gluster_call.called) @@ -843,8 +838,8 @@ class GlusterNFSHelperTestCase(test.TestCase): export_str = '/example.com(10.0.0.1)' args = ('volume', 'set', self._helper.gluster_manager.volume, NFS_EXPORT_DIR, export_str) - self.stubs.Set(self._helper, '_get_export_dir_dict', - mock.Mock(return_value=export_dir_dict)) + self.mock_object(self._helper, '_get_export_dir_dict', + mock.Mock(return_value=export_dir_dict)) self._helper.deny_access(None, share, access) self._helper._get_export_dir_dict.assert_called_once_with() self._helper.gluster_manager.gluster_call.assert_called_once_with( diff --git a/manila/tests/share/drivers/test_glusterfs_native.py b/manila/tests/share/drivers/test_glusterfs_native.py index c3932062..8a03a5e1 100644 --- a/manila/tests/share/drivers/test_glusterfs_native.py +++ b/manila/tests/share/drivers/test_glusterfs_native.py @@ -77,7 +77,7 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): def setUp(self): super(GlusterfsNativeShareDriverTestCase, self).setUp() - fake_utils.stub_out_utils_execute(self.stubs) + fake_utils.stub_out_utils_execute(self) self._execute = fake_utils.fake_execute self._context = context.get_admin_context() @@ -96,10 +96,9 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): self._driver = glusterfs_native.GlusterfsNativeShareDriver( self._db, execute=self._execute, configuration=self.fake_conf) - self.stubs.Set(tempfile, 'mkdtemp', - mock.Mock(return_value='/tmp/tmpKGHKJ')) - self.stubs.Set(glusterfs.GlusterManager, 'make_gluster_call', - mock.Mock()) + self.mock_object(tempfile, 'mkdtemp', + mock.Mock(return_value='/tmp/tmpKGHKJ')) + self.mock_object(glusterfs.GlusterManager, 'make_gluster_call') self.addCleanup(fake_utils.fake_execute_set_repliers, []) self.addCleanup(fake_utils.fake_execute_clear_log) @@ -188,8 +187,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): self._driver.gluster_used_vols_dict = {gmgr1.export: gmgr1} self._driver.gluster_unused_vols_dict = {gmgr2.export: gmgr2} - self.stubs.Set(gmgr2, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr2, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._driver._setup_gluster_vols) @@ -214,8 +213,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): self._driver.gluster_used_vols_dict = {gmgr1.export: gmgr1} self._driver.gluster_unused_vols_dict = {gmgr2.export: gmgr2} - self.stubs.Set(gmgr2, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr2, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._driver._setup_gluster_vols) @@ -242,8 +241,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): self._driver.gluster_used_vols_dict = {gmgr1.export: gmgr1} self._driver.gluster_unused_vols_dict = {gmgr2.export: gmgr2} - self.stubs.Set(gmgr2, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr2, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._driver._setup_gluster_vols) @@ -273,8 +272,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): if(args == test_args): raise exception.ProcessExecutionError() - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._driver._restart_gluster_vol, gmgr1) @@ -292,8 +291,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): if(args == test_args[1]): raise exception.ProcessExecutionError() - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._driver._restart_gluster_vol, gmgr1) @@ -446,8 +445,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): gmgr = glusterfs.GlusterManager gmgr1 = gmgr(self.gluster_target1, self._execute, None, None) - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._driver._wipe_gluster_vol, gmgr1) @@ -474,8 +473,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): gmgr = glusterfs.GlusterManager gmgr1 = gmgr(self.gluster_target1, self._execute, None, None) - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) self.assertRaises(exception.GlusterfsException, self._driver._wipe_gluster_vol, gmgr1) @@ -504,8 +503,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): gmgr = glusterfs.GlusterManager gmgr1 = gmgr(self.gluster_target1, self._execute, None, None) - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) expected_exec = ['find /tmp/tmpKGHKJ -mindepth 1 -delete'] @@ -539,8 +538,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): gmgr = glusterfs.GlusterManager gmgr1 = gmgr(self.gluster_target1, self._execute, None, None) - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) expected_exec = ['find /tmp/tmpKGHKJ -mindepth 1 -delete'] @@ -779,8 +778,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): self._driver.gluster_used_vols_dict = {gmgr1.export: gmgr1} self._driver.gluster_unused_vols_dict = {gmgr2.export: gmgr2} - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) share = fake_db_share1()[0] self.assertRaises(exception.GlusterfsException, @@ -834,8 +833,8 @@ class GlusterfsNativeShareDriverTestCase(test.TestCase): self._driver.gluster_used_vols_dict = {gmgr1.export: gmgr1} self._driver.gluster_unused_vols_dict = {gmgr2.export: gmgr2} - self.stubs.Set(gmgr1, 'gluster_call', - mock.Mock(side_effect=raise_exception)) + self.mock_object(gmgr1, 'gluster_call', + mock.Mock(side_effect=raise_exception)) share = fake_db_share1()[0] diff --git a/manila/tests/share/drivers/test_service_instance.py b/manila/tests/share/drivers/test_service_instance.py index 0aafa4a9..c52d598c 100644 --- a/manila/tests/share/drivers/test_service_instance.py +++ b/manila/tests/share/drivers/test_service_instance.py @@ -83,9 +83,9 @@ class ServiceInstanceManagerTestCase(test.TestCase): self._helper_cifs = mock.Mock() self._helper_nfs = mock.Mock() self._db = mock.Mock() - self.stubs.Set(service_instance.neutron, 'API', fake_network.API) - self.stubs.Set(service_instance.compute, 'API', fake_compute.API) - self.stubs.Set(importutils, 'import_class', mock.Mock()) + self.mock_object(service_instance.neutron, 'API', fake_network.API) + self.mock_object(service_instance.compute, 'API', fake_compute.API) + self.mock_object(importutils, 'import_class') with mock.patch.object(service_instance.ServiceInstanceManager, '_setup_connectivity_with_service_instances', mock.Mock()): @@ -96,10 +96,10 @@ class ServiceInstanceManagerTestCase(test.TestCase): self._manager.admin_context = self._context self._manager._execute = mock.Mock(return_value=('', '')) self._manager.vif_driver = mock.Mock() - self.stubs.Set(utils, 'synchronized', - mock.Mock(return_value=lambda f: f)) - self.stubs.Set(service_instance.os.path, 'exists', - mock.Mock(return_value=True)) + self.mock_object(utils, 'synchronized', + mock.Mock(return_value=lambda f: f)) + self.mock_object(service_instance.os.path, 'exists', + mock.Mock(return_value=True)) self._manager._helpers = { 'CIFS': self._helper_cifs, 'NFS': self._helper_nfs, @@ -112,25 +112,25 @@ class ServiceInstanceManagerTestCase(test.TestCase): net2 = copy.copy(fake_network.API.network) net1['name'] = self._manager.get_config_option('service_network_name') net1['id'] = 'fake service network id' - self.stubs.Set(self._manager.neutron_api, 'get_all_tenant_networks', - mock.Mock(return_value=[net1, net2])) + self.mock_object(self._manager.neutron_api, 'get_all_tenant_networks', + mock.Mock(return_value=[net1, net2])) result = self._manager._get_service_network() self.assertEqual(net1['id'], result) def test_get_service_network_net_does_not_exists(self): net = fake_network.FakeNetwork() - self.stubs.Set(self._manager.neutron_api, 'get_all_tenant_networks', - mock.Mock(return_value=[])) - self.stubs.Set(self._manager.neutron_api, 'network_create', - mock.Mock(return_value=net)) + self.mock_object(self._manager.neutron_api, 'get_all_tenant_networks', + mock.Mock(return_value=[])) + self.mock_object(self._manager.neutron_api, 'network_create', + mock.Mock(return_value=net)) result = self._manager._get_service_network() self.assertEqual(net['id'], result) def test_get_service_network_ambiguos(self): net = fake_network.FakeNetwork( name=self._manager.get_config_option('service_network_name')) - self.stubs.Set(self._manager.neutron_api, 'get_all_tenant_networks', - mock.Mock(return_value=[net, net])) + self.mock_object(self._manager.neutron_api, 'get_all_tenant_networks', + mock.Mock(return_value=[net, net])) self.assertRaises(exception.ManilaException, self._manager._get_service_network) @@ -184,8 +184,8 @@ class ServiceInstanceManagerTestCase(test.TestCase): ) def test_security_group_name_not_specified(self): - self.stubs.Set(self._manager, 'get_config_option', - mock.Mock(return_value=None)) + self.mock_object(self._manager, 'get_config_option', + mock.Mock(return_value=None)) result = self._manager._get_or_create_security_group(self._context) self.assertEqual(result, None) self._manager.get_config_option.assert_called_once_with( @@ -193,10 +193,10 @@ class ServiceInstanceManagerTestCase(test.TestCase): def test_security_group_name_from_config_and_sg_exist(self): fake_secgroup = fake_compute.FakeSecurityGroup(name="fake_sg_name") - self.stubs.Set(self._manager, 'get_config_option', - mock.Mock(return_value="fake_sg_name")) - self.stubs.Set(self._manager.compute_api, 'security_group_list', - mock.Mock(return_value=[fake_secgroup, ])) + self.mock_object(self._manager, 'get_config_option', + mock.Mock(return_value="fake_sg_name")) + self.mock_object(self._manager.compute_api, 'security_group_list', + mock.Mock(return_value=[fake_secgroup, ])) result = self._manager._get_or_create_security_group(self._context) self.assertEqual(result, fake_secgroup) self._manager.get_config_option.assert_has_calls([ @@ -210,14 +210,14 @@ class ServiceInstanceManagerTestCase(test.TestCase): desc = "fake_sg_description" fake_secgroup = fake_compute.FakeSecurityGroup(name=name, description=desc) - self.stubs.Set(self._manager, 'get_config_option', - mock.Mock(return_value=name)) - self.stubs.Set(self._manager.compute_api, 'security_group_list', - mock.Mock(return_value=[])) - self.stubs.Set(self._manager.compute_api, 'security_group_create', - mock.Mock(return_value=fake_secgroup)) - self.stubs.Set(self._manager.compute_api, 'security_group_rule_create', - mock.Mock()) + self.mock_object(self._manager, 'get_config_option', + mock.Mock(return_value=name)) + self.mock_object(self._manager.compute_api, 'security_group_list', + mock.Mock(return_value=[])) + self.mock_object(self._manager.compute_api, 'security_group_create', + mock.Mock(return_value=fake_secgroup)) + self.mock_object(self._manager.compute_api, + 'security_group_rule_create') result = self._manager._get_or_create_security_group( context=self._context, name=None, @@ -237,12 +237,12 @@ class ServiceInstanceManagerTestCase(test.TestCase): desc = "fake_sg_description" fake_secgroup = fake_compute.FakeSecurityGroup(name=name, description=desc) - self.stubs.Set(self._manager.compute_api, 'security_group_list', - mock.Mock(return_value=[])) - self.stubs.Set(self._manager.compute_api, 'security_group_create', - mock.Mock(return_value=fake_secgroup)) - self.stubs.Set(self._manager.compute_api, 'security_group_rule_create', - mock.Mock()) + self.mock_object(self._manager.compute_api, 'security_group_list', + mock.Mock(return_value=[])) + self.mock_object(self._manager.compute_api, 'security_group_create', + mock.Mock(return_value=fake_secgroup)) + self.mock_object(self._manager.compute_api, + 'security_group_rule_create') result = self._manager._get_or_create_security_group( context=self._context, name=name, @@ -258,9 +258,9 @@ class ServiceInstanceManagerTestCase(test.TestCase): name = "fake_name" fake_secgroup1 = fake_compute.FakeSecurityGroup(name=name) fake_secgroup2 = fake_compute.FakeSecurityGroup(name=name) - self.stubs.Set(self._manager.compute_api, 'security_group_list', - mock.Mock(return_value=[fake_secgroup1, - fake_secgroup2])) + self.mock_object(self._manager.compute_api, 'security_group_list', + mock.Mock(return_value=[fake_secgroup1, + fake_secgroup2])) self.assertRaises(exception.ServiceInstanceException, self._manager._get_or_create_security_group, self._context, @@ -282,8 +282,8 @@ class ServiceInstanceManagerTestCase(test.TestCase): expected_details = fake_server.copy() expected_details.pop('pk_path') expected_details['instance_id'] = expected_details.pop('id') - self.stubs.Set(self._manager, '_create_service_instance', - mock.Mock(return_value=fake_server)) + self.mock_object(self._manager, '_create_service_instance', + mock.Mock(return_value=fake_server)) result = self._manager.set_up_service_instance( self._context, 'fake-inst-name', 'fake-net-id', 'fake-subnet-id') @@ -296,10 +296,10 @@ class ServiceInstanceManagerTestCase(test.TestCase): server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'} fake_server = fake_compute.FakeServer() - self.stubs.Set(self._manager, '_check_server_availability', - mock.Mock(return_value=True)) - self.stubs.Set(self._manager.compute_api, 'server_get', - mock.Mock(return_value=fake_server)) + self.mock_object(self._manager, '_check_server_availability', + mock.Mock(return_value=True)) + self.mock_object(self._manager.compute_api, 'server_get', + mock.Mock(return_value=fake_server)) result = self._manager.ensure_service_instance(self._context, server_details) self._manager.compute_api.server_get.assert_called_once_with( @@ -311,11 +311,11 @@ class ServiceInstanceManagerTestCase(test.TestCase): def test_ensure_server_not_exists(self): server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'} - self.stubs.Set(self._manager, '_check_server_availability', - mock.Mock(return_value=True)) - self.stubs.Set(self._manager.compute_api, 'server_get', - mock.Mock(side_effect=exception.InstanceNotFound( - instance_id=server_details['instance_id']))) + self.mock_object(self._manager, '_check_server_availability', + mock.Mock(return_value=True)) + self.mock_object(self._manager.compute_api, 'server_get', + mock.Mock(side_effect=exception.InstanceNotFound( + instance_id=server_details['instance_id']))) result = self._manager.ensure_service_instance(self._context, server_details) self._manager.compute_api.server_get.assert_called_once_with( @@ -326,10 +326,10 @@ class ServiceInstanceManagerTestCase(test.TestCase): def test_ensure_server_exception(self): server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'} - self.stubs.Set(self._manager, '_check_server_availability', - mock.Mock(return_value=True)) - self.stubs.Set(self._manager.compute_api, 'server_get', - mock.Mock(side_effect=exception.ManilaException)) + self.mock_object(self._manager, '_check_server_availability', + mock.Mock(return_value=True)) + self.mock_object(self._manager.compute_api, 'server_get', + mock.Mock(side_effect=exception.ManilaException)) self.assertRaises(exception.ManilaException, self._manager.ensure_service_instance, self._context, @@ -342,10 +342,10 @@ class ServiceInstanceManagerTestCase(test.TestCase): server_details = {'instance_id': 'fake_inst_id', 'ip': '1.2.3.4'} fake_server = fake_compute.FakeServer(status='ERROR') - self.stubs.Set(self._manager.compute_api, 'server_get', - mock.Mock(return_value=fake_server)) - self.stubs.Set(self._manager, '_check_server_availability', - mock.Mock(return_value=True)) + self.mock_object(self._manager.compute_api, 'server_get', + mock.Mock(return_value=fake_server)) + self.mock_object(self._manager, '_check_server_availability', + mock.Mock(return_value=True)) result = self._manager.ensure_service_instance(self._context, server_details) self.assertFalse(self._manager._check_server_availability.called) @@ -355,10 +355,10 @@ class ServiceInstanceManagerTestCase(test.TestCase): keypair_name = self._manager.get_config_option( 'manila_service_keypair_name') fake_keypair = fake_compute.FakeKeypair(name=keypair_name) - self.stubs.Set(self._manager.compute_api, 'keypair_list', - mock.Mock(return_value=[])) - self.stubs.Set(self._manager.compute_api, 'keypair_import', - mock.Mock(return_value=fake_keypair)) + self.mock_object(self._manager.compute_api, 'keypair_list', + mock.Mock(return_value=[])) + self.mock_object(self._manager.compute_api, 'keypair_import', + mock.Mock(return_value=fake_keypair)) result = self._manager._get_key(self._context) @@ -377,12 +377,12 @@ class ServiceInstanceManagerTestCase(test.TestCase): name=self._manager.get_config_option( 'manila_service_keypair_name'), public_key='fake_public_key') - self.stubs.Set(self._manager.compute_api, 'keypair_list', - mock.Mock(return_value=[fake_keypair])) - self.stubs.Set(self._manager.compute_api, 'keypair_import', - mock.Mock(return_value=fake_keypair)) - self.stubs.Set(self._manager, '_execute', - mock.Mock(return_value=('fake_public_key', ''))) + self.mock_object(self._manager.compute_api, 'keypair_list', + mock.Mock(return_value=[fake_keypair])) + self.mock_object(self._manager.compute_api, 'keypair_import', + mock.Mock(return_value=fake_keypair)) + self.mock_object(self._manager, '_execute', + mock.Mock(return_value=('fake_public_key', ''))) result = self._manager._get_key(self._context) @@ -400,14 +400,13 @@ class ServiceInstanceManagerTestCase(test.TestCase): name=self._manager.get_config_option( 'manila_service_keypair_name'), public_key='fake_public_key1') - self.stubs.Set(self._manager.compute_api, 'keypair_list', - mock.Mock(return_value=[fake_keypair])) - self.stubs.Set(self._manager.compute_api, 'keypair_import', - mock.Mock(return_value=fake_keypair)) - self.stubs.Set(self._manager.compute_api, 'keypair_delete', - mock.Mock()) - self.stubs.Set(self._manager, '_execute', - mock.Mock(return_value=('fake_public_key2', ''))) + self.mock_object(self._manager.compute_api, 'keypair_list', + mock.Mock(return_value=[fake_keypair])) + self.mock_object(self._manager.compute_api, 'keypair_import', + mock.Mock(return_value=fake_keypair)) + self.mock_object(self._manager.compute_api, 'keypair_delete') + self.mock_object(self._manager, '_execute', + mock.Mock(return_value=('fake_public_key2', ''))) result = self._manager._get_key(self._context) @@ -467,16 +466,16 @@ class ServiceInstanceManagerTestCase(test.TestCase): fake_image1 = fake_compute.FakeImage( name=self._manager.get_config_option('service_image_name')) fake_image2 = fake_compute.FakeImage(name='another-image') - self.stubs.Set(self._manager.compute_api, 'image_list', - mock.Mock(return_value=[fake_image1, fake_image2])) + self.mock_object(self._manager.compute_api, 'image_list', + mock.Mock(return_value=[fake_image1, fake_image2])) result = self._manager._get_service_image(self._context) self.assertEqual(fake_image1.id, result) def test_get_service_image_not_found(self): - self.stubs.Set(self._manager.compute_api, 'image_list', - mock.Mock(return_value=[])) + self.mock_object(self._manager.compute_api, 'image_list', + mock.Mock(return_value=[])) self.assertRaises(exception.ManilaException, self._manager._get_service_image, @@ -484,8 +483,8 @@ class ServiceInstanceManagerTestCase(test.TestCase): def test_get_service_image_ambiguous(self): fake_image = fake_compute.FakeImage(name=CONF.service_image_name) - self.stubs.Set(self._manager.compute_api, 'image_list', - mock.Mock(return_value=[fake_image, fake_image])) + self.mock_object(self._manager.compute_api, 'image_list', + mock.Mock(return_value=[fake_image, fake_image])) self.assertRaises(exception.ManilaException, self._manager._get_service_image, @@ -506,25 +505,24 @@ class ServiceInstanceManagerTestCase(test.TestCase): 'ports': [fake_port], } - self.stubs.Set(self._manager, '_get_service_image', - mock.Mock(return_value='fake_image_id')) - self.stubs.Set(self._manager, '_get_key', - mock.Mock( - return_value=('fake_key_name', 'fake_key_path'))) - self.stubs.Set(self._manager, '_setup_network_for_instance', - mock.Mock(return_value=fake_network_data)) - self.stubs.Set(self._manager, - '_setup_connectivity_with_service_instances', - mock.Mock()) - self.stubs.Set(self._manager.compute_api, 'server_create', - mock.Mock(return_value=fake_server)) - self.stubs.Set(self._manager, '_get_server_ip', - mock.Mock(return_value='fake_ip')) - self.stubs.Set(self._manager, '_get_or_create_security_group', - mock.Mock(return_value=fake_security_group)) - self.stubs.Set(service_instance.socket, 'socket', mock.Mock()) - self.stubs.Set(self._manager, '_get_service_instance_name', - mock.Mock(return_value=fake_instance_name)) + self.mock_object(self._manager, '_get_service_image', + mock.Mock(return_value='fake_image_id')) + self.mock_object(self._manager, '_get_key', + mock.Mock( + return_value=('fake_key_name', 'fake_key_path'))) + self.mock_object(self._manager, '_setup_network_for_instance', + mock.Mock(return_value=fake_network_data)) + self.mock_object(self._manager, + '_setup_connectivity_with_service_instances') + self.mock_object(self._manager.compute_api, 'server_create', + mock.Mock(return_value=fake_server)) + self.mock_object(self._manager, '_get_server_ip', + mock.Mock(return_value='fake_ip')) + self.mock_object(self._manager, '_get_or_create_security_group', + mock.Mock(return_value=fake_security_group)) + self.mock_object(service_instance.socket, 'socket') + self.mock_object(self._manager, '_get_service_instance_name', + mock.Mock(return_value=fake_instance_name)) result = self._manager._create_service_instance( self._context, @@ -557,23 +555,22 @@ class ServiceInstanceManagerTestCase(test.TestCase): 'ports': [fake_port], } - self.stubs.Set(self._manager, '_get_service_image', - mock.Mock(return_value='fake_image_id')) - self.stubs.Set(self._manager, '_get_key', - mock.Mock( - return_value=('fake_key_name', 'fake_key_path'))) - self.stubs.Set(self._manager, '_get_or_create_security_group', - mock.Mock(return_value=fake_security_group)) - self.stubs.Set(self._manager, '_setup_network_for_instance', - mock.Mock(return_value=fake_network_data)) - self.stubs.Set(self._manager, - '_setup_connectivity_with_service_instances', - mock.Mock()) - self.stubs.Set(self._manager.compute_api, 'server_create', - mock.Mock(return_value=fake_server)) - self.stubs.Set(self._manager.compute_api, 'server_get', - mock.Mock(return_value=fake_server)) - self.stubs.Set(service_instance.socket, 'socket', mock.Mock()) + self.mock_object(self._manager, '_get_service_image', + mock.Mock(return_value='fake_image_id')) + self.mock_object(self._manager, '_get_key', + mock.Mock( + return_value=('fake_key_name', 'fake_key_path'))) + self.mock_object(self._manager, '_get_or_create_security_group', + mock.Mock(return_value=fake_security_group)) + self.mock_object(self._manager, '_setup_network_for_instance', + mock.Mock(return_value=fake_network_data)) + self.mock_object(self._manager, + '_setup_connectivity_with_service_instances') + self.mock_object(self._manager.compute_api, 'server_create', + mock.Mock(return_value=fake_server)) + self.mock_object(self._manager.compute_api, 'server_get', + mock.Mock(return_value=fake_server)) + self.mock_object(service_instance.socket, 'socket') self.assertRaises(exception.ManilaException, self._manager._create_service_instance, @@ -605,24 +602,24 @@ class ServiceInstanceManagerTestCase(test.TestCase): 'ports': [fake_port] } - self.stubs.Set(self._manager, '_get_service_image', - mock.Mock(return_value='fake_image_id')) - self.stubs.Set(self._manager, '_get_key', - mock.Mock( - return_value=('fake_key_name', 'fake_key_path'))) - self.stubs.Set(self._manager, '_get_or_create_security_group', - mock.Mock(return_value=fake_security_group)) - self.stubs.Set(self._manager, '_setup_network_for_instance', - mock.Mock(return_value=fake_network_data)) - self.stubs.Set(self._manager, - '_setup_connectivity_with_service_instances', - mock.Mock(side_effect=exception.ManilaException)) - self.stubs.Set(self._manager.neutron_api, 'delete_port', mock.Mock()) - self.stubs.Set(self._manager.compute_api, 'server_create', - mock.Mock(return_value=fake_server)) - self.stubs.Set(self._manager.compute_api, 'server_get', - mock.Mock(return_value=fake_server)) - self.stubs.Set(service_instance.socket, 'socket', mock.Mock()) + self.mock_object(self._manager, '_get_service_image', + mock.Mock(return_value='fake_image_id')) + self.mock_object(self._manager, '_get_key', + mock.Mock( + return_value=('fake_key_name', 'fake_key_path'))) + self.mock_object(self._manager, '_get_or_create_security_group', + mock.Mock(return_value=fake_security_group)) + self.mock_object(self._manager, '_setup_network_for_instance', + mock.Mock(return_value=fake_network_data)) + self.mock_object(self._manager, + '_setup_connectivity_with_service_instances', + mock.Mock(side_effect=exception.ManilaException)) + self.mock_object(self._manager.neutron_api, 'delete_port') + self.mock_object(self._manager.compute_api, 'server_create', + mock.Mock(return_value=fake_server)) + self.mock_object(self._manager.compute_api, 'server_get', + mock.Mock(return_value=fake_server)) + self.mock_object(service_instance.socket, 'socket') self.assertRaises(exception.ManilaException, self._manager._create_service_instance, @@ -638,10 +635,10 @@ class ServiceInstanceManagerTestCase(test.TestCase): self.assertFalse(service_instance.socket.socket.called) def test_create_service_instance_no_key_and_password(self): - self.stubs.Set(self._manager, '_get_service_image', - mock.Mock(return_value='fake_image_id')) - self.stubs.Set(self._manager, '_get_key', - mock.Mock(return_value=(None, None))) + self.mock_object(self._manager, '_get_service_image', + mock.Mock(return_value='fake_image_id')) + self.mock_object(self._manager, '_get_key', + mock.Mock(return_value=(None, None))) self.assertRaises(exception.ManilaException, self._manager._create_service_instance, self._context, @@ -655,22 +652,20 @@ class ServiceInstanceManagerTestCase(test.TestCase): FakeSubnet(name=self.share['share_network_id']) fake_router = fake_network.FakeRouter() fake_port = fake_network.FakePort() - self.stubs.Set(self._manager, - 'connect_share_server_to_tenant_network', False) - self.stubs.Set(self._manager.neutron_api, 'get_network', - mock.Mock(return_value=fake_service_net)) - self.stubs.Set(self._manager.neutron_api, 'subnet_create', - mock.Mock(return_value=fake_service_subnet)) - self.stubs.Set(self._manager.db, 'share_network_get', - mock.Mock(return_value='fake_share_network')) - self.stubs.Set(self._manager, '_get_private_router', - mock.Mock(return_value=fake_router)) - self.stubs.Set(self._manager.neutron_api, 'router_add_interface', - mock.Mock()) - self.stubs.Set(self._manager.neutron_api, 'create_port', - mock.Mock(return_value=fake_port)) - self.stubs.Set(self._manager, '_get_cidr_for_subnet', - mock.Mock(return_value='fake_cidr')) + self._manager.connect_share_server_to_tenant_network = False + self.mock_object(self._manager.neutron_api, 'get_network', + mock.Mock(return_value=fake_service_net)) + self.mock_object(self._manager.neutron_api, 'subnet_create', + mock.Mock(return_value=fake_service_subnet)) + self.mock_object(self._manager.db, 'share_network_get', + mock.Mock(return_value='fake_share_network')) + self.mock_object(self._manager, '_get_private_router', + mock.Mock(return_value=fake_router)) + self.mock_object(self._manager.neutron_api, 'router_add_interface') + self.mock_object(self._manager.neutron_api, 'create_port', + mock.Mock(return_value=fake_port)) + self.mock_object(self._manager, '_get_cidr_for_subnet', + mock.Mock(return_value='fake_cidr')) network_data = self._manager._setup_network_for_instance( 'fake-net', 'fake-subnet') @@ -706,16 +701,16 @@ class ServiceInstanceManagerTestCase(test.TestCase): fake_network.FakePort(fixed_ips=[{'ip_address': '1.2.3.4'}]), fake_network.FakePort(fixed_ips=[{'ip_address': '5.6.7.8'}]), ] - self.stubs.Set(self._manager, - 'connect_share_server_to_tenant_network', True) - self.stubs.Set(self._manager.neutron_api, 'get_network', - mock.Mock(return_value=fake_service_net)) - self.stubs.Set(self._manager.neutron_api, 'subnet_create', - mock.Mock(return_value=fake_service_subnet)) - self.stubs.Set(self._manager.neutron_api, 'create_port', - mock.Mock(side_effect=fake_ports)) - self.stubs.Set(self._manager, '_get_cidr_for_subnet', - mock.Mock(return_value='fake_cidr')) + self.mock_object(self._manager, + 'connect_share_server_to_tenant_network', True) + self.mock_object(self._manager.neutron_api, 'get_network', + mock.Mock(return_value=fake_service_net)) + self.mock_object(self._manager.neutron_api, 'subnet_create', + mock.Mock(return_value=fake_service_subnet)) + self.mock_object(self._manager.neutron_api, 'create_port', + mock.Mock(side_effect=fake_ports)) + self.mock_object(self._manager, '_get_cidr_for_subnet', + mock.Mock(return_value='fake_cidr')) network_data = self._manager._setup_network_for_instance( 'fake-net', 'fake-subnet') @@ -748,19 +743,19 @@ class ServiceInstanceManagerTestCase(test.TestCase): fake_subnet = fake_network.FakeSubnet(gateway_ip='fake_ip') fake_share_network = {'neutron_net_id': fake_net['id'], 'neutron_subnet_id': fake_subnet['id']} - self.stubs.Set(self._manager.db, 'share_network_get', - mock.Mock(return_value=fake_share_network)) + self.mock_object(self._manager.db, 'share_network_get', + mock.Mock(return_value=fake_share_network)) fake_port = fake_network.FakePort(fixed_ips=[ {'subnet_id': fake_subnet['id'], 'ip_address': fake_subnet['gateway_ip']}], device_id='fake_router_id') fake_router = fake_network.FakeRouter(id='fake_router_id') - self.stubs.Set(self._manager.neutron_api, 'get_subnet', - mock.Mock(return_value=fake_subnet)) - self.stubs.Set(self._manager.neutron_api, 'list_ports', - mock.Mock(return_value=[fake_port])) - self.stubs.Set(self._manager.neutron_api, 'show_router', - mock.Mock(return_value=fake_router)) + self.mock_object(self._manager.neutron_api, 'get_subnet', + mock.Mock(return_value=fake_subnet)) + self.mock_object(self._manager.neutron_api, 'list_ports', + mock.Mock(return_value=[fake_port])) + self.mock_object(self._manager.neutron_api, 'show_router', + mock.Mock(return_value=fake_router)) result = self._manager._get_private_router(fake_net['id'], fake_subnet['id']) @@ -778,12 +773,12 @@ class ServiceInstanceManagerTestCase(test.TestCase): fake_subnet = fake_network.FakeSubnet(gateway_ip='fake_ip') fake_share_network = {'neutron_net_id': fake_net['id'], 'neutron_subnet_id': fake_subnet['id']} - self.stubs.Set(self._manager.db, 'share_network_get', - mock.Mock(return_value=fake_share_network)) - self.stubs.Set(self._manager.neutron_api, 'get_subnet', - mock.Mock(return_value=fake_subnet)) - self.stubs.Set(self._manager.neutron_api, 'list_ports', - mock.Mock(return_value=[])) + self.mock_object(self._manager.db, 'share_network_get', + mock.Mock(return_value=fake_share_network)) + self.mock_object(self._manager.neutron_api, 'get_subnet', + mock.Mock(return_value=fake_subnet)) + self.mock_object(self._manager.neutron_api, 'list_ports', + mock.Mock(return_value=[])) self.assertRaises(exception.ManilaException, self._manager._get_private_router, @@ -799,18 +794,17 @@ class ServiceInstanceManagerTestCase(test.TestCase): {'subnet_id': fake_subnet['id'], 'ip_address': '10.254.0.2'}], mac_address='fake_mac_address') - self.stubs.Set(self._manager, '_get_service_port', - mock.Mock(return_value=fake_port)) - self.stubs.Set(self._manager.vif_driver, 'get_device_name', - mock.Mock(return_value=interface_name)) - self.stubs.Set(self._manager.neutron_api, 'get_subnet', - mock.Mock(return_value=fake_subnet)) - self.stubs.Set(self._manager, '_remove_outdated_interfaces', - mock.Mock()) - self.stubs.Set(self._manager.vif_driver, 'plug', mock.Mock()) + self.mock_object(self._manager, '_get_service_port', + mock.Mock(return_value=fake_port)) + self.mock_object(self._manager.vif_driver, 'get_device_name', + mock.Mock(return_value=interface_name)) + self.mock_object(self._manager.neutron_api, 'get_subnet', + mock.Mock(return_value=fake_subnet)) + self.mock_object(self._manager, '_remove_outdated_interfaces') + self.mock_object(self._manager.vif_driver, 'plug') device_mock = mock.Mock() - self.stubs.Set(service_instance.ip_lib, 'IPDevice', - mock.Mock(return_value=device_mock)) + self.mock_object(service_instance.ip_lib, 'IPDevice', + mock.Mock(return_value=device_mock)) self._manager._setup_connectivity_with_service_instances() @@ -831,14 +825,14 @@ class ServiceInstanceManagerTestCase(test.TestCase): def test_get_service_port(self): fake_service_port = fake_network.FakePort(device_id='manila-share') - self.stubs.Set(self._manager.neutron_api, 'list_ports', - mock.Mock(return_value=[])) - self.stubs.Set(self._manager, '_execute', - mock.Mock(return_value=('fake_host', ''))) - self.stubs.Set(self._manager.neutron_api, 'create_port', - mock.Mock(return_value=fake_service_port)) - self.stubs.Set(self._manager.neutron_api, 'update_port_fixed_ips', - mock.Mock(return_value=fake_service_port)) + self.mock_object(self._manager.neutron_api, 'list_ports', + mock.Mock(return_value=[])) + self.mock_object(self._manager, '_execute', + mock.Mock(return_value=('fake_host', ''))) + self.mock_object(self._manager.neutron_api, 'create_port', + mock.Mock(return_value=fake_service_port)) + self.mock_object(self._manager.neutron_api, 'update_port_fixed_ips', + mock.Mock(return_value=fake_service_port)) result = self._manager._get_service_port() @@ -858,20 +852,20 @@ class ServiceInstanceManagerTestCase(test.TestCase): def test_get_service_port_ambigious_ports(self): fake_service_port = fake_network.FakePort(device_id='manila-share') - self.stubs.Set(self._manager.neutron_api, 'list_ports', - mock.Mock(return_value=[fake_service_port, - fake_service_port])) + self.mock_object(self._manager.neutron_api, 'list_ports', + mock.Mock(return_value=[fake_service_port, + fake_service_port])) self.assertRaises(exception.ManilaException, self._manager._get_service_port) def test_get_service_port_exists(self): fake_service_port = fake_network.FakePort(device_id='manila-share') - self.stubs.Set(self._manager.neutron_api, 'list_ports', - mock.Mock(return_value=[fake_service_port])) - self.stubs.Set(self._manager.neutron_api, 'create_port', - mock.Mock(return_value=fake_service_port)) - self.stubs.Set(self._manager.neutron_api, 'update_port_fixed_ips', - mock.Mock(return_value=fake_service_port)) + self.mock_object(self._manager.neutron_api, 'list_ports', + mock.Mock(return_value=[fake_service_port])) + self.mock_object(self._manager.neutron_api, 'create_port', + mock.Mock(return_value=fake_service_port)) + self.mock_object(self._manager.neutron_api, 'update_port_fixed_ips', + mock.Mock(return_value=fake_service_port)) result = self._manager._get_service_port() @@ -891,20 +885,20 @@ class ServiceInstanceManagerTestCase(test.TestCase): cidrs = serv_cidr.subnet(fake_division_mask) cidr1 = six.text_type(next(cidrs)) cidr2 = six.text_type(next(cidrs)) - self.stubs.Set(self._manager, '_get_all_service_subnets', - mock.Mock(return_value=[])) + self.mock_object(self._manager, '_get_all_service_subnets', + mock.Mock(return_value=[])) result = self._manager._get_cidr_for_subnet() self.assertEqual(result, cidr1) fake_subnet = fake_network.FakeSubnet(cidr=cidr1) - self.stubs.Set(self._manager, '_get_all_service_subnets', - mock.Mock(return_value=[fake_subnet])) + self.mock_object(self._manager, '_get_all_service_subnets', + mock.Mock(return_value=[fake_subnet])) result = self._manager._get_cidr_for_subnet() self.assertEqual(result, cidr2) def test__delete_server_not_found(self): - self.stubs.Set(self._manager.compute_api, 'server_delete', mock.Mock()) - self.stubs.Set( + self.mock_object(self._manager.compute_api, 'server_delete') + self.mock_object( self._manager.compute_api, 'server_get', mock.Mock(side_effect=exception.InstanceNotFound( instance_id=self.instance_id))) @@ -924,9 +918,9 @@ class ServiceInstanceManagerTestCase(test.TestCase): else: raise exception.InstanceNotFound(instance_id=self.instance_id) - self.stubs.Set(self._manager.compute_api, 'server_delete', mock.Mock()) - self.stubs.Set(self._manager.compute_api, 'server_get', - mock.Mock(side_effect=fake_server_get)) + self.mock_object(self._manager.compute_api, 'server_delete') + self.mock_object(self._manager.compute_api, 'server_get', + mock.Mock(side_effect=fake_server_get)) self._manager._delete_server(self._context, self.instance_id) @@ -945,14 +939,14 @@ class ServiceInstanceManagerTestCase(test.TestCase): def fake_sleep(time): self.fake_time += 1 - self.stubs.Set(self._manager.compute_api, 'server_delete', mock.Mock()) - self.stubs.Set(self._manager.compute_api, 'server_get', mock.Mock()) - self.stubs.Set(service_instance, 'time', mock.Mock()) - self.stubs.Set( + self.mock_object(self._manager.compute_api, 'server_delete') + self.mock_object(self._manager.compute_api, 'server_get') + self.mock_object(service_instance, 'time') + self.mock_object( service_instance.time, 'time', mock.Mock(side_effect=fake_time)) - self.stubs.Set( + self.mock_object( service_instance.time, 'sleep', mock.Mock(side_effect=fake_sleep)) - self.stubs.Set(self._manager, 'max_time_to_build_instance', 2) + self.mock_object(self._manager, 'max_time_to_build_instance', 2) self.assertRaises( exception.ServiceInstanceException, self._manager._delete_server, @@ -971,11 +965,9 @@ class ServiceInstanceManagerTestCase(test.TestCase): instance_id = 'fake_instance_id' router_id = 'fake_router_id' subnet_id = 'fake_subnet_id' - self.stubs.Set(self._manager, '_delete_server', mock.Mock()) - self.stubs.Set(self._manager.neutron_api, 'router_remove_interface', - mock.Mock()) - self.stubs.Set(self._manager.neutron_api, 'update_subnet', - mock.Mock()) + self.mock_object(self._manager, '_delete_server') + self.mock_object(self._manager.neutron_api, 'router_remove_interface') + self.mock_object(self._manager.neutron_api, 'update_subnet') self._manager.delete_service_instance( self._context, instance_id, subnet_id, router_id) diff --git a/manila/tests/share/drivers/zfssa/test_zfssarest.py b/manila/tests/share/drivers/zfssa/test_zfssarest.py index 1a1845da..feb754e4 100644 --- a/manila/tests/share/drivers/zfssa/test_zfssarest.py +++ b/manila/tests/share/drivers/zfssa/test_zfssarest.py @@ -49,7 +49,7 @@ class ZFSSAApiTestCase(test.TestCase): return response def test_enable_service(self): - self.stubs.Set(self._zfssa.rclient, 'put', mock.Mock()) + self.mock_object(self._zfssa.rclient, 'put') self._zfssa.rclient.put.return_value = self._create_response( restclient.Status.ACCEPTED) @@ -63,8 +63,8 @@ class ZFSSAApiTestCase(test.TestCase): 'nfs') def test_verify_avail_space(self): - self.stubs.Set(self._zfssa, 'verify_project', mock.Mock()) - self.stubs.Set(self._zfssa, 'get_project_stats', mock.Mock()) + self.mock_object(self._zfssa, 'verify_project') + self.mock_object(self._zfssa, 'get_project_stats') self._zfssa.get_project_stats.return_value = 2000 self._zfssa.verify_avail_space(self.pool, @@ -86,9 +86,9 @@ class ZFSSAApiTestCase(test.TestCase): 1000) def test_create_project(self): - self.stubs.Set(self._zfssa, 'verify_pool', mock.Mock()) - self.stubs.Set(self._zfssa.rclient, 'get', mock.Mock()) - self.stubs.Set(self._zfssa.rclient, 'post', mock.Mock()) + self.mock_object(self._zfssa, 'verify_pool') + self.mock_object(self._zfssa.rclient, 'get') + self.mock_object(self._zfssa.rclient, 'post') arg = { 'name': self.project, 'sharesmb': 'off', @@ -115,9 +115,9 @@ class ZFSSAApiTestCase(test.TestCase): arg) def test_create_share(self): - self.stubs.Set(self._zfssa, 'verify_avail_space', mock.Mock()) - self.stubs.Set(self._zfssa.rclient, 'get', mock.Mock()) - self.stubs.Set(self._zfssa.rclient, 'post', mock.Mock()) + self.mock_object(self._zfssa, 'verify_avail_space') + self.mock_object(self._zfssa.rclient, 'get') + self.mock_object(self._zfssa.rclient, 'post') self._zfssa.rclient.get.return_value = self._create_response( restclient.Status.NOT_FOUND) self._zfssa.rclient.post.return_value = self._create_response( @@ -153,7 +153,7 @@ class ZFSSAApiTestCase(test.TestCase): arg) def test_modify_share(self): - self.stubs.Set(self._zfssa.rclient, 'put', mock.Mock()) + self.mock_object(self._zfssa.rclient, 'put') self._zfssa.rclient.put.return_value = self._create_response( restclient.Status.ACCEPTED) arg = {"name": "dummyname"} @@ -173,7 +173,7 @@ class ZFSSAApiTestCase(test.TestCase): arg) def test_delete_share(self): - self.stubs.Set(self._zfssa.rclient, 'delete', mock.Mock()) + self.mock_object(self._zfssa.rclient, 'delete') self._zfssa.rclient.delete.return_value = self._create_response( restclient.Status.NO_CONTENT) svc = self._zfssa.share_path % (self.pool, self.project, self.share) @@ -183,7 +183,7 @@ class ZFSSAApiTestCase(test.TestCase): self._zfssa.rclient.delete.assert_called_with(svc) def test_create_snapshot(self): - self.stubs.Set(self._zfssa.rclient, 'post', mock.Mock()) + self.mock_object(self._zfssa.rclient, 'post') self._zfssa.rclient.post.return_value = self._create_response( restclient.Status.CREATED) arg = {"name": self.snap} @@ -208,7 +208,7 @@ class ZFSSAApiTestCase(test.TestCase): self.snap) def test_delete_snapshot(self): - self.stubs.Set(self._zfssa.rclient, 'delete', mock.Mock()) + self.mock_object(self._zfssa.rclient, 'delete') self._zfssa.rclient.delete.return_value = self._create_response( restclient.Status.NO_CONTENT) svc = self._zfssa.snapshot_path % (self.pool, @@ -233,8 +233,8 @@ class ZFSSAApiTestCase(test.TestCase): self.snap) def test_clone_snapshot(self): - self.stubs.Set(self._zfssa, 'verify_avail_space', mock.Mock()) - self.stubs.Set(self._zfssa.rclient, 'put', mock.Mock()) + self.mock_object(self._zfssa, 'verify_avail_space') + self.mock_object(self._zfssa.rclient, 'put') self._zfssa.rclient.put.return_value = self._create_response( restclient.Status.CREATED) snapshot = { @@ -282,8 +282,8 @@ class ZFSSAApiTestCase(test.TestCase): return arg def test_allow_access_nfs(self): - self.stubs.Set(self._zfssa, 'get_share', mock.Mock()) - self.stubs.Set(self._zfssa, 'modify_share', mock.Mock()) + self.mock_object(self._zfssa, 'get_share') + self.mock_object(self._zfssa, 'modify_share') details = {"sharenfs": "off"} access = { "access_type": "nonip", @@ -349,8 +349,8 @@ class ZFSSAApiTestCase(test.TestCase): self.assertEqual(2, self._zfssa.modify_share.call_count) def test_deny_access_nfs(self): - self.stubs.Set(self._zfssa, 'get_share', mock.Mock()) - self.stubs.Set(self._zfssa, 'modify_share', mock.Mock()) + self.mock_object(self._zfssa, 'get_share') + self.mock_object(self._zfssa, 'modify_share') data1 = self._create_entry("off", "10.0.0.1") access = { "access_type": "nonip", diff --git a/manila/tests/share/drivers/zfssa/test_zfssashare.py b/manila/tests/share/drivers/zfssa/test_zfssashare.py index 803fe43a..93f985c9 100644 --- a/manila/tests/share/drivers/zfssa/test_zfssashare.py +++ b/manila/tests/share/drivers/zfssa/test_zfssashare.py @@ -93,8 +93,8 @@ class ZFSSAShareDriverTestCase(test.TestCase): self.configuration.driver_handles_share_servers = False def test_create_share(self): - self.stubs.Set(self._driver.zfssa, 'create_share', mock.Mock()) - self.stubs.Set(self._driver, '_export_location', mock.Mock()) + self.mock_object(self._driver.zfssa, 'create_share') + self.mock_object(self._driver, '_export_location') lcfg = self.configuration arg = { 'host': lcfg.zfssa_data_ip, @@ -115,8 +115,8 @@ class ZFSSAShareDriverTestCase(test.TestCase): self.assertEqual(1, self._driver._export_location.call_count) def test_create_share_from_snapshot(self): - self.stubs.Set(self._driver.zfssa, 'clone_snapshot', mock.Mock()) - self.stubs.Set(self._driver, '_export_location', mock.Mock()) + self.mock_object(self._driver.zfssa, 'clone_snapshot') + self.mock_object(self._driver, '_export_location') lcfg = self.configuration arg = { 'host': lcfg.zfssa_data_ip, @@ -145,7 +145,7 @@ class ZFSSAShareDriverTestCase(test.TestCase): arg) def test_delete_share(self): - self.stubs.Set(self._driver.zfssa, 'delete_share', mock.Mock()) + self.mock_object(self._driver.zfssa, 'delete_share') self._driver.delete_share(self._context, self.share) self.assertEqual(1, self._driver.zfssa.delete_share.call_count) lcfg = self.configuration @@ -154,7 +154,7 @@ class ZFSSAShareDriverTestCase(test.TestCase): self.share['id']) def test_create_snapshot(self): - self.stubs.Set(self._driver.zfssa, 'create_snapshot', mock.Mock()) + self.mock_object(self._driver.zfssa, 'create_snapshot') lcfg = self.configuration self._driver.create_snapshot(self._context, self.snapshot) self.assertEqual(1, self._driver.zfssa.create_snapshot.call_count) @@ -165,12 +165,12 @@ class ZFSSAShareDriverTestCase(test.TestCase): self.snapshot['id']) def test_delete_snapshot(self): - self.stubs.Set(self._driver.zfssa, 'delete_snapshot', mock.Mock()) + self.mock_object(self._driver.zfssa, 'delete_snapshot') self._driver.delete_snapshot(self._context, self.snapshot) self.assertEqual(1, self._driver.zfssa.delete_snapshot.call_count) def test_delete_snapshot_negative(self): - self.stubs.Set(self._driver.zfssa, 'has_clones', mock.Mock()) + self.mock_object(self._driver.zfssa, 'has_clones') self._driver.zfssa.has_clones.return_value = True self.assertRaises(exception.ShareSnapshotIsBusy, self._driver.delete_snapshot, @@ -178,7 +178,7 @@ class ZFSSAShareDriverTestCase(test.TestCase): self.snapshot) def test_ensure_share(self): - self.stubs.Set(self._driver.zfssa, 'get_share', mock.Mock()) + self.mock_object(self._driver.zfssa, 'get_share') lcfg = self.configuration self._driver.ensure_share(self._context, self.share) self.assertEqual(1, self._driver.zfssa.get_share.call_count) @@ -194,7 +194,7 @@ class ZFSSAShareDriverTestCase(test.TestCase): self.share) def test_allow_access(self): - self.stubs.Set(self._driver.zfssa, 'allow_access_nfs', mock.Mock()) + self.mock_object(self._driver.zfssa, 'allow_access_nfs') lcfg = self.configuration self._driver.allow_access(self._context, self.share, self.access) self.assertEqual(1, self._driver.zfssa.allow_access_nfs.call_count) @@ -205,7 +205,7 @@ class ZFSSAShareDriverTestCase(test.TestCase): self.access) def test_deny_access(self): - self.stubs.Set(self._driver.zfssa, 'deny_access_nfs', mock.Mock()) + self.mock_object(self._driver.zfssa, 'deny_access_nfs') lcfg = self.configuration self._driver.deny_access(self._context, self.share, self.access) self.assertEqual(1, self._driver.zfssa.deny_access_nfs.call_count) diff --git a/manila/tests/share/test_api.py b/manila/tests/share/test_api.py index fb99aa29..9aaaa319 100644 --- a/manila/tests/share/test_api.py +++ b/manila/tests/share/test_api.py @@ -171,18 +171,20 @@ class ShareAPITestCase(test.TestCase): self.scheduler_rpcapi = mock.Mock() self.share_rpcapi = mock.Mock() self.api = share.API() - self.stubs.Set(self.api, 'scheduler_rpcapi', self.scheduler_rpcapi) - self.stubs.Set(self.api, 'share_rpcapi', self.share_rpcapi) - self.stubs.Set(quota.QUOTAS, 'reserve', lambda *args, **kwargs: None) + self.mock_object(self.api, 'scheduler_rpcapi', self.scheduler_rpcapi) + self.mock_object(self.api, 'share_rpcapi', self.share_rpcapi) + self.mock_object(quota.QUOTAS, 'reserve', + lambda *args, **kwargs: None) dt_utc = datetime.datetime.utcnow() - self.stubs.Set(timeutils, 'utcnow', mock.Mock(return_value=dt_utc)) - self.stubs.Set(timeutils_old, 'utcnow', mock.Mock(return_value=dt_utc)) - self.stubs.Set(share_api.policy, 'check_policy', mock.Mock()) + self.mock_object(timeutils, 'utcnow', mock.Mock(return_value=dt_utc)) + self.mock_object(timeutils_old, 'utcnow', + mock.Mock(return_value=dt_utc)) + self.mock_object(share_api.policy, 'check_policy') def test_get_all_admin_no_filters(self): - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=True) shares = self.api.get_all(ctx) share_api.policy.check_policy.assert_called_once_with( @@ -195,8 +197,8 @@ class ShareAPITestCase(test.TestCase): def test_get_all_admin_filter_by_all_tenants(self): ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=True) - self.stubs.Set(db_driver, 'share_get_all', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES)) + self.mock_object(db_driver, 'share_get_all', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES)) shares = self.api.get_all(ctx, {'all_tenants': 1}) share_api.policy.check_policy.assert_called_once_with( ctx, 'share', 'get_all') @@ -211,8 +213,8 @@ class ShareAPITestCase(test.TestCase): raise exception.NotAuthorized ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) - self.stubs.Set(share_api.policy, 'check_policy', - mock.Mock(side_effect=fake_policy_checker)) + self.mock_object(share_api.policy, 'check_policy', + mock.Mock(side_effect=fake_policy_checker)) self.assertRaises( exception.NotAuthorized, self.api.get_all, @@ -228,10 +230,10 @@ class ShareAPITestCase(test.TestCase): # NOTE(vponomaryov): if share_server_id provided, 'all_tenants' opt # should not make any influence. ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=True) - self.stubs.Set(db_driver, 'share_get_all_by_share_server', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[2:])) - self.stubs.Set(db_driver, 'share_get_all', mock.Mock()) - self.stubs.Set(db_driver, 'share_get_all_by_project', mock.Mock()) + self.mock_object(db_driver, 'share_get_all_by_share_server', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[2:])) + self.mock_object(db_driver, 'share_get_all') + self.mock_object(db_driver, 'share_get_all_by_project') shares = self.api.get_all( ctx, {'share_server_id': 'fake_server_3', 'all_tenants': 1}) share_api.policy.check_policy.assert_has_calls([ @@ -248,8 +250,8 @@ class ShareAPITestCase(test.TestCase): def test_get_all_admin_filter_by_name(self): ctx = context.RequestContext('fake_uid', 'fake_pid_2', is_admin=True) - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) shares = self.api.get_all(ctx, {'name': 'bar'}) share_api.policy.check_policy.assert_has_calls([ mock.call(ctx, 'share', 'get_all'), @@ -262,8 +264,8 @@ class ShareAPITestCase(test.TestCase): def test_get_all_admin_filter_by_name_and_all_tenants(self): ctx = context.RequestContext('fake_uid', 'fake_pid_2', is_admin=True) - self.stubs.Set(db_driver, 'share_get_all', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES)) + self.mock_object(db_driver, 'share_get_all', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES)) shares = self.api.get_all(ctx, {'name': 'foo', 'all_tenants': 1}) share_api.policy.check_policy.assert_has_calls([ mock.call(ctx, 'share', 'get_all'), @@ -274,8 +276,8 @@ class ShareAPITestCase(test.TestCase): def test_get_all_admin_filter_by_status(self): ctx = context.RequestContext('fake_uid', 'fake_pid_2', is_admin=True) - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) shares = self.api.get_all(ctx, {'status': 'active'}) share_api.policy.check_policy.assert_has_calls([ mock.call(ctx, 'share', 'get_all'), @@ -288,8 +290,8 @@ class ShareAPITestCase(test.TestCase): def test_get_all_admin_filter_by_status_and_all_tenants(self): ctx = context.RequestContext('fake_uid', 'fake_pid_2', is_admin=True) - self.stubs.Set(db_driver, 'share_get_all', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES)) + self.mock_object(db_driver, 'share_get_all', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES)) shares = self.api.get_all(ctx, {'status': 'error', 'all_tenants': 1}) share_api.policy.check_policy.assert_has_calls([ mock.call(ctx, 'share', 'get_all'), @@ -301,8 +303,8 @@ class ShareAPITestCase(test.TestCase): def test_get_all_non_admin_filter_by_all_tenants(self): # Expected share list only by project of non-admin user ctx = context.RequestContext('fake_uid', 'fake_pid_2', is_admin=False) - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) shares = self.api.get_all(ctx, {'all_tenants': 1}) share_api.policy.check_policy.assert_has_calls([ mock.call(ctx, 'share', 'get_all'), @@ -315,8 +317,8 @@ class ShareAPITestCase(test.TestCase): def test_get_all_non_admin_with_name_and_status_filters(self): ctx = context.RequestContext('fake_uid', 'fake_pid_2', is_admin=False) - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[1:])) shares = self.api.get_all(ctx, {'name': 'bar', 'status': 'error'}) share_api.policy.check_policy.assert_has_calls([ mock.call(ctx, 'share', 'get_all'), @@ -344,8 +346,8 @@ class ShareAPITestCase(test.TestCase): ]) def test_get_all_with_sorting_valid(self): - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) shares = self.api.get_all(ctx, sort_key='status', sort_dir='asc') share_api.policy.check_policy.assert_called_once_with( @@ -357,8 +359,8 @@ class ShareAPITestCase(test.TestCase): self.assertEqual(_FAKE_LIST_OF_ALL_SHARES[0], shares) def test_get_all_sort_key_invalid(self): - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) self.assertRaises( exception.InvalidInput, @@ -370,8 +372,8 @@ class ShareAPITestCase(test.TestCase): ctx, 'share', 'get_all') def test_get_all_sort_dir_invalid(self): - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) self.assertRaises( exception.InvalidInput, @@ -383,8 +385,8 @@ class ShareAPITestCase(test.TestCase): ctx, 'share', 'get_all') def _get_all_filter_metadata_or_extra_specs_valid(self, key): - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) search_opts = {key: {'foo1': 'bar1', 'foo2': 'bar2'}} shares = self.api.get_all(ctx, search_opts=search_opts.copy()) @@ -402,8 +404,8 @@ class ShareAPITestCase(test.TestCase): self._get_all_filter_metadata_or_extra_specs_valid(key='extra_specs') def _get_all_filter_metadata_or_extra_specs_invalid(self, key): - self.stubs.Set(db_driver, 'share_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) + self.mock_object(db_driver, 'share_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SHARES[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) search_opts = {key: "{'foo': 'bar'}"} self.assertRaises(exception.InvalidInput, self.api.get_all, ctx, @@ -499,8 +501,8 @@ class ShareAPITestCase(test.TestCase): server_returned = { 'id': 'fake_share_server_id', } - self.stubs.Set(db_driver, 'share_server_update', - mock.Mock(return_value=server_returned)) + self.mock_object(db_driver, 'share_server_update', + mock.Mock(return_value=server_returned)) self.api.delete_share_server(self.context, server) db_driver.share_get_all_by_share_server.assert_called_once_with( self.context, server['id']) @@ -586,10 +588,10 @@ class ShareAPITestCase(test.TestCase): 'volume_type': None, 'snapshot_id': share['snapshot_id'], } - self.stubs.Set(db_driver, 'share_create', - mock.Mock(return_value=share)) - self.stubs.Set(db_driver, 'share_update', - mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_create', + mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_update', + mock.Mock(return_value=share)) self.api.create(self.context, 'nfs', '1', 'fakename', 'fakedesc', snapshot=snapshot, availability_zone='fakeaz') @@ -633,10 +635,10 @@ class ShareAPITestCase(test.TestCase): 'volume_type': None, 'snapshot_id': share['snapshot_id'], } - self.stubs.Set(db_driver, 'share_create', - mock.Mock(return_value=share)) - self.stubs.Set(db_driver, 'share_update', - mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_create', + mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_update', + mock.Mock(return_value=share)) self.api.create(self.context, 'nfs', '1', 'fakename', 'fakedesc', snapshot=snapshot, availability_zone='fakeaz') @@ -682,11 +684,12 @@ class ShareAPITestCase(test.TestCase): 'volume_type': volume_type, 'snapshot_id': share['snapshot_id'], } - self.stubs.Set(db_driver, 'share_create', - mock.Mock(return_value=share)) - self.stubs.Set(db_driver, 'share_update', - mock.Mock(return_value=share)) - self.stubs.Set(db_driver, 'share_get', mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_create', + mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_update', + mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_get', + mock.Mock(return_value=share)) # Call tested method self.api.create(self.context, 'nfs', '1', 'fakename', 'fakedesc', @@ -731,9 +734,10 @@ class ShareAPITestCase(test.TestCase): for name in ('id', 'export_location', 'host', 'launched_at', 'terminated_at'): options.pop(name, None) - self.stubs.Set(db_driver, 'share_create', - mock.Mock(return_value=share)) - self.stubs.Set(db_driver, 'share_get', mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_create', + mock.Mock(return_value=share)) + self.mock_object(db_driver, 'share_get', + mock.Mock(return_value=share)) # Call tested method self.assertRaises(exception.InvalidInput, self.api.create, @@ -873,8 +877,8 @@ class ShareAPITestCase(test.TestCase): search_opts = {'size': 'fakesize'} fake_objs = [{'name': 'fakename1'}, search_opts] ctx = context.RequestContext('fakeuid', 'fakepid', is_admin=False) - self.stubs.Set(db_driver, 'share_snapshot_get_all_by_project', - mock.Mock(return_value=fake_objs)) + self.mock_object(db_driver, 'share_snapshot_get_all_by_project', + mock.Mock(return_value=fake_objs)) result = self.api.get_all_snapshots(ctx, search_opts) @@ -886,8 +890,9 @@ class ShareAPITestCase(test.TestCase): filters=search_opts) def test_get_all_snapshots_with_sorting_valid(self): - self.stubs.Set(db_driver, 'share_snapshot_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SNAPSHOTS[0])) + self.mock_object( + db_driver, 'share_snapshot_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SNAPSHOTS[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) snapshots = self.api.get_all_snapshots( ctx, sort_key='status', sort_dir='asc') @@ -898,8 +903,9 @@ class ShareAPITestCase(test.TestCase): self.assertEqual(_FAKE_LIST_OF_ALL_SNAPSHOTS[0], snapshots) def test_get_all_snapshots_sort_key_invalid(self): - self.stubs.Set(db_driver, 'share_snapshot_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SNAPSHOTS[0])) + self.mock_object( + db_driver, 'share_snapshot_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SNAPSHOTS[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) self.assertRaises( exception.InvalidInput, @@ -911,8 +917,9 @@ class ShareAPITestCase(test.TestCase): ctx, 'share', 'get_all_snapshots') def test_get_all_snapshots_sort_dir_invalid(self): - self.stubs.Set(db_driver, 'share_snapshot_get_all_by_project', - mock.Mock(return_value=_FAKE_LIST_OF_ALL_SNAPSHOTS[0])) + self.mock_object( + db_driver, 'share_snapshot_get_all_by_project', + mock.Mock(return_value=_FAKE_LIST_OF_ALL_SNAPSHOTS[0])) ctx = context.RequestContext('fake_uid', 'fake_pid_1', is_admin=False) self.assertRaises( exception.InvalidInput, @@ -932,8 +939,8 @@ class ShareAPITestCase(test.TestCase): 'access_to': 'fakeaccto', 'access_level': level, } - self.stubs.Set(db_driver, 'share_access_create', - mock.Mock(return_value='fakeacc')) + self.mock_object(db_driver, 'share_access_create', + mock.Mock(return_value='fakeacc')) access = self.api.allow_access(self.context, share, 'fakeacctype', 'fakeaccto', level) diff --git a/manila/tests/share/test_driver.py b/manila/tests/share/test_driver.py index 1d21598a..56dc67d0 100644 --- a/manila/tests/share/test_driver.py +++ b/manila/tests/share/test_driver.py @@ -47,10 +47,10 @@ class ShareDriverTestCase(test.TestCase): def setUp(self): super(ShareDriverTestCase, self).setUp() self.utils = utils - self.stubs.Set(self.utils, 'execute', fake_execute_with_raise) + self.mock_object(self.utils, 'execute', fake_execute_with_raise) self.time = time - self.stubs.Set(self.time, 'sleep', fake_sleep) - self.stubs.Set(driver.CONF, 'driver_handles_share_servers', True) + self.mock_object(self.time, 'sleep', fake_sleep) + self.mock_object(driver.CONF, 'driver_handles_share_servers', True) def test__try_execute(self): execute_mixin = ShareDriverWithExecuteMixin( @@ -66,7 +66,7 @@ class ShareDriverTestCase(test.TestCase): def _instantiate_share_driver(self, network_config_group, driver_handles_share_servers): - self.stubs.Set(network, 'API', mock.Mock()) + self.mock_object(network, 'API') config = mock.Mock() config.append_config_values = mock.Mock() config.config_group = 'fake_config_group' @@ -92,7 +92,7 @@ class ShareDriverTestCase(test.TestCase): self._instantiate_share_driver("fake_network_config_group", True) def test_instantiate_share_driver_no_configuration(self): - self.stubs.Set(network, 'API', mock.Mock()) + self.mock_object(network, 'API') share_driver = driver.ShareDriver(True, configuration=None) @@ -138,7 +138,7 @@ class ShareDriverTestCase(test.TestCase): @ddt.unpack def test__verify_share_server_handling_valid_cases(self, opt, allowed): conf = configuration.Configuration(None) - self.stubs.Set(conf, 'safe_get', mock.Mock(return_value=opt)) + self.mock_object(conf, 'safe_get', mock.Mock(return_value=opt)) share_driver = driver.ShareDriver(allowed, configuration=conf) self.assertTrue(conf.safe_get.celled) self.assertEqual(opt, share_driver.driver_handles_share_servers) @@ -156,7 +156,7 @@ class ShareDriverTestCase(test.TestCase): @ddt.unpack def test__verify_share_server_handling_invalid_cases(self, opt, allowed): conf = configuration.Configuration(None) - self.stubs.Set(conf, 'safe_get', mock.Mock(return_value=opt)) + self.mock_object(conf, 'safe_get', mock.Mock(return_value=opt)) self.assertRaises( exception.ManilaException, driver.ShareDriver, allowed, configuration=conf) diff --git a/manila/tests/share/test_manager.py b/manila/tests/share/test_manager.py index ab34c638..081d05d9 100644 --- a/manila/tests/share/test_manager.py +++ b/manila/tests/share/test_manager.py @@ -52,9 +52,8 @@ class ShareManagerTestCase(test.TestCase): # to specific manager. self.share_manager = importutils.import_object( "manila.share.manager.ShareManager") - self.stubs.Set(self.share_manager.driver, 'do_setup', mock.Mock()) - self.stubs.Set(self.share_manager.driver, 'check_for_setup_error', - mock.Mock()) + self.mock_object(self.share_manager.driver, 'do_setup') + self.mock_object(self.share_manager.driver, 'check_for_setup_error') self.context = context.get_admin_context() @staticmethod @@ -136,8 +135,8 @@ class ShareManagerTestCase(test.TestCase): return service_ref def test_init_host_with_no_shares(self): - self.stubs.Set(self.share_manager.db, 'share_get_all_by_host', - mock.Mock(return_value=[])) + self.mock_object(self.share_manager.db, 'share_get_all_by_host', + mock.Mock(return_value=[])) self.share_manager.init_host() @@ -165,18 +164,19 @@ class ShareManagerTestCase(test.TestCase): FakeAccessRule(state='error'), ] share_server = 'fake_share_server_type_does_not_matter' - self.stubs.Set(self.share_manager.db, - 'share_get_all_by_host', - mock.Mock(return_value=shares)) - self.stubs.Set(self.share_manager.driver, 'ensure_share', mock.Mock()) - self.stubs.Set(self.share_manager, '_get_share_server', - mock.Mock(return_value=share_server)) - self.stubs.Set(self.share_manager, 'publish_service_capabilities', - mock.Mock()) - self.stubs.Set(self.share_manager.db, 'share_access_get_all_for_share', - mock.Mock(return_value=rules)) - self.stubs.Set(self.share_manager.driver, 'allow_access', - mock.Mock(side_effect=raise_share_access_exists)) + self.mock_object(self.share_manager.db, + 'share_get_all_by_host', + mock.Mock(return_value=shares)) + self.mock_object(self.share_manager.driver, 'ensure_share') + self.mock_object(self.share_manager, '_get_share_server', + mock.Mock(return_value=share_server)) + self.mock_object(self.share_manager, 'publish_service_capabilities', + mock.Mock()) + self.mock_object(self.share_manager.db, + 'share_access_get_all_for_share', + mock.Mock(return_value=rules)) + self.mock_object(self.share_manager.driver, 'allow_access', + mock.Mock(side_effect=raise_share_access_exists)) # call of 'init_host' method self.share_manager.init_host() @@ -213,17 +213,16 @@ class ShareManagerTestCase(test.TestCase): {'id': 'fake_id_3', 'status': 'available', 'name': 'fake_name_3'}, ] share_server = 'fake_share_server_type_does_not_matter' - self.stubs.Set(self.share_manager.db, - 'share_get_all_by_host', - mock.Mock(return_value=shares)) - self.stubs.Set(self.share_manager.driver, 'ensure_share', - mock.Mock(side_effect=raise_exception)) - self.stubs.Set(self.share_manager, '_get_share_server', - mock.Mock(return_value=share_server)) - self.stubs.Set(self.share_manager, 'publish_service_capabilities', - mock.Mock()) - self.stubs.Set(manager.LOG, 'error', mock.Mock()) - self.stubs.Set(manager.LOG, 'info', mock.Mock()) + self.mock_object(self.share_manager.db, + 'share_get_all_by_host', + mock.Mock(return_value=shares)) + self.mock_object(self.share_manager.driver, 'ensure_share', + mock.Mock(side_effect=raise_exception)) + self.mock_object(self.share_manager, '_get_share_server', + mock.Mock(return_value=share_server)) + self.mock_object(self.share_manager, 'publish_service_capabilities') + self.mock_object(manager.LOG, 'error') + self.mock_object(manager.LOG, 'info') # call of 'init_host' method self.share_manager.init_host() @@ -266,20 +265,20 @@ class ShareManagerTestCase(test.TestCase): FakeAccessRule(state='error'), ] share_server = 'fake_share_server_type_does_not_matter' - self.stubs.Set(self.share_manager.db, - 'share_get_all_by_host', - mock.Mock(return_value=shares)) - self.stubs.Set(self.share_manager.driver, 'ensure_share', mock.Mock()) - self.stubs.Set(self.share_manager, '_get_share_server', - mock.Mock(return_value=share_server)) - self.stubs.Set(self.share_manager, 'publish_service_capabilities', - mock.Mock()) - self.stubs.Set(manager.LOG, 'error', mock.Mock()) - self.stubs.Set(manager.LOG, 'info', mock.Mock()) - self.stubs.Set(self.share_manager.db, 'share_access_get_all_for_share', - mock.Mock(return_value=rules)) - self.stubs.Set(self.share_manager.driver, 'allow_access', - mock.Mock(side_effect=raise_exception)) + self.mock_object(self.share_manager.db, + 'share_get_all_by_host', + mock.Mock(return_value=shares)) + self.mock_object(self.share_manager.driver, 'ensure_share') + self.mock_object(self.share_manager, '_get_share_server', + mock.Mock(return_value=share_server)) + self.mock_object(self.share_manager, 'publish_service_capabilities') + self.mock_object(manager.LOG, 'error') + self.mock_object(manager.LOG, 'info') + self.mock_object(self.share_manager.db, + 'share_access_get_all_for_share', + mock.Mock(return_value=rules)) + self.mock_object(self.share_manager.driver, 'allow_access', + mock.Mock(side_effect=raise_exception)) # call of 'init_host' method self.share_manager.init_host() @@ -380,15 +379,16 @@ class ShareManagerTestCase(test.TestCase): snapshot['progress'] = '99%' return snapshot - self.stubs.Set(self.share_manager.driver, "create_snapshot", - _fake_create_snapshot) + self.mock_object(self.share_manager.driver, "create_snapshot", + _fake_create_snapshot) share = self._create_share() share_id = share['id'] snapshot = self._create_snapshot(share_id=share_id) snapshot_id = snapshot['id'] - self.share_manager.create_snapshot(self.context, share_id, snapshot_id) + self.share_manager.create_snapshot(self.context, share_id, + snapshot_id) self.assertEqual(share_id, db.share_snapshot_get(context.get_admin_context(), snapshot_id).share_id) @@ -408,10 +408,10 @@ class ShareManagerTestCase(test.TestCase): def _raise_not_found(self, *args, **kwargs): raise exception.NotFound() - self.stubs.Set(self.share_manager.driver, "create_snapshot", - mock.Mock(side_effect=_raise_not_found)) - self.stubs.Set(self.share_manager.driver, "delete_snapshot", - mock.Mock(side_effect=_raise_not_found)) + self.mock_object(self.share_manager.driver, "create_snapshot", + mock.Mock(side_effect=_raise_not_found)) + self.mock_object(self.share_manager.driver, "delete_snapshot", + mock.Mock(side_effect=_raise_not_found)) share = self._create_share() share_id = share['id'] @@ -445,8 +445,8 @@ class ShareManagerTestCase(test.TestCase): def _raise_share_snapshot_is_busy(self, *args, **kwargs): raise exception.ShareSnapshotIsBusy(snapshot_name='fakename') - self.stubs.Set(self.share_manager.driver, "delete_snapshot", - mock.Mock(side_effect=_raise_share_snapshot_is_busy)) + self.mock_object(self.share_manager.driver, "delete_snapshot", + mock.Mock(side_effect=_raise_share_snapshot_is_busy)) share = self._create_share(status='ACTIVE') snapshot = self._create_snapshot(share_id=share['id']) snapshot_id = snapshot['id'] @@ -462,16 +462,16 @@ class ShareManagerTestCase(test.TestCase): def test_create_share_with_share_network_driver_not_handles_servers(self): manager.CONF.set_default('driver_handles_share_servers', False) - self.stubs.Set( + self.mock_object( self.share_manager.driver.configuration, 'safe_get', mock.Mock(return_value=False)) share_id = 'fake_share_id' share_network_id = 'fake_sn' - self.stubs.Set( + self.mock_object( self.share_manager.db, 'share_get', mock.Mock(return_value=self._create_share( share_network_id=share_network_id))) - self.stubs.Set(self.share_manager.db, 'share_update', mock.Mock()) + self.mock_object(self.share_manager.db, 'share_update') self.assertRaises( exception.ManilaException, @@ -506,12 +506,12 @@ class ShareManagerTestCase(test.TestCase): def test_create_share_with_share_network_server_creation_failed(self): fake_share = {'id': 'fake_share_id', 'share_network_id': 'fake_sn_id'} fake_server = {'id': 'fake_srv_id'} - self.stubs.Set(db, 'share_server_create', - mock.Mock(return_value=fake_server)) - self.stubs.Set(db, 'share_update', - mock.Mock(return_value=fake_share)) - self.stubs.Set(db, 'share_get', - mock.Mock(return_value=fake_share)) + self.mock_object(db, 'share_server_create', + mock.Mock(return_value=fake_server)) + self.mock_object(db, 'share_update', + mock.Mock(return_value=fake_share)) + self.mock_object(db, 'share_get', + mock.Mock(return_value=fake_share)) def raise_share_server_not_found(*args, **kwargs): raise exception.ShareServerNotFound( @@ -520,10 +520,10 @@ class ShareManagerTestCase(test.TestCase): def raise_manila_exception(*args, **kwargs): raise exception.ManilaException() - self.stubs.Set(db, 'share_server_get_by_host_and_share_net_valid', - mock.Mock(side_effect=raise_share_server_not_found)) - self.stubs.Set(self.share_manager, '_setup_server', - mock.Mock(side_effect=raise_manila_exception)) + self.mock_object(db, 'share_server_get_by_host_and_share_net_valid', + mock.Mock(side_effect=raise_share_server_not_found)) + self.mock_object(self.share_manager, '_setup_server', + mock.Mock(side_effect=raise_manila_exception)) self.assertRaises( exception.ManilaException, @@ -616,10 +616,10 @@ class ShareManagerTestCase(test.TestCase): state='ERROR') share_id = share['id'] fake_server = {'id': 'fake_srv_id'} - self.stubs.Set(db, 'share_server_create', - mock.Mock(return_value=fake_server)) - self.stubs.Set(self.share_manager, '_setup_server', - mock.Mock(return_value=fake_server)) + self.mock_object(db, 'share_server_create', + mock.Mock(return_value=fake_server)) + self.mock_object(self.share_manager, '_setup_server', + mock.Mock(return_value=fake_server)) self.share_manager.create_share(self.context, share_id) @@ -639,10 +639,10 @@ class ShareManagerTestCase(test.TestCase): def _raise_not_found(self, *args, **kwargs): raise exception.NotFound() - self.stubs.Set(self.share_manager.driver, "create_share", - mock.Mock(side_effect=_raise_not_found)) - self.stubs.Set(self.share_manager.driver, "delete_share", - mock.Mock(side_effect=_raise_not_found)) + self.mock_object(self.share_manager.driver, "create_share", + mock.Mock(side_effect=_raise_not_found)) + self.mock_object(self.share_manager.driver, "delete_share", + mock.Mock(side_effect=_raise_not_found)) share = self._create_share() share_id = share['id'] @@ -785,10 +785,10 @@ class ShareManagerTestCase(test.TestCase): def _fake_deny_access(self, *args, **kwargs): raise exception.NotFound() - self.stubs.Set(self.share_manager.driver, "allow_access", - _fake_allow_access) - self.stubs.Set(self.share_manager.driver, "deny_access", - _fake_deny_access) + self.mock_object(self.share_manager.driver, "allow_access", + _fake_allow_access) + self.mock_object(self.share_manager.driver, "deny_access", + _fake_deny_access) share = self._create_share() share_id = share['id'] @@ -823,19 +823,17 @@ class ShareManagerTestCase(test.TestCase): server_info = {'fake_server_info_key': 'fake_server_info_value'} # mock required stuff - self.stubs.Set(self.share_manager.db, 'share_network_get', - mock.Mock(return_value=share_network)) - self.stubs.Set(self.share_manager.driver, 'allocate_network', - mock.Mock()) - self.stubs.Set(self.share_manager, '_form_server_setup_info', - mock.Mock(return_value=network_info)) - self.stubs.Set(self.share_manager.driver, 'setup_server', - mock.Mock(return_value=server_info)) - self.stubs.Set(self.share_manager.db, - 'share_server_backend_details_set', - mock.Mock()) - self.stubs.Set(self.share_manager.db, 'share_server_update', - mock.Mock(return_value=share_server)) + self.mock_object(self.share_manager.db, 'share_network_get', + mock.Mock(return_value=share_network)) + self.mock_object(self.share_manager.driver, 'allocate_network') + self.mock_object(self.share_manager, '_form_server_setup_info', + mock.Mock(return_value=network_info)) + self.mock_object(self.share_manager.driver, 'setup_server', + mock.Mock(return_value=server_info)) + self.mock_object(self.share_manager.db, + 'share_server_backend_details_set') + self.mock_object(self.share_manager.db, 'share_server_update', + mock.Mock(return_value=share_server)) # execute method _setup_server result = self.share_manager._setup_server( @@ -872,16 +870,15 @@ class ShareManagerTestCase(test.TestCase): server_info = {} # mock required stuff - self.stubs.Set(self.share_manager.db, 'share_network_get', - mock.Mock(return_value=share_network)) - self.stubs.Set(self.share_manager, '_form_server_setup_info', - mock.Mock(return_value=network_info)) - self.stubs.Set(self.share_manager.driver, 'setup_server', - mock.Mock(return_value=server_info)) - self.stubs.Set(self.share_manager.db, 'share_server_update', - mock.Mock(return_value=share_server)) - self.stubs.Set(self.share_manager.driver, 'allocate_network', - mock.Mock()) + self.mock_object(self.share_manager.db, 'share_network_get', + mock.Mock(return_value=share_network)) + self.mock_object(self.share_manager, '_form_server_setup_info', + mock.Mock(return_value=network_info)) + self.mock_object(self.share_manager.driver, 'setup_server', + mock.Mock(return_value=server_info)) + self.mock_object(self.share_manager.db, 'share_server_update', + mock.Mock(return_value=share_server)) + self.mock_object(self.share_manager.driver, 'allocate_network') # execute method _setup_server result = self.share_manager._setup_server( @@ -913,27 +910,24 @@ class ShareManagerTestCase(test.TestCase): network_info = {'fake_network_info_key': 'fake_network_info_value'} if detail_data_proper: detail_data = {'server_details': server_info} - self.stubs.Set(self.share_manager.db, - 'share_server_backend_details_set', - mock.Mock()) + self.mock_object(self.share_manager.db, + 'share_server_backend_details_set') else: detail_data = 'not dictionary detail data' # Mock required parameters - self.stubs.Set(self.share_manager.db, 'share_network_get', - mock.Mock(return_value=share_network)) - self.stubs.Set(self.share_manager.db, 'share_server_update', - mock.Mock()) + self.mock_object(self.share_manager.db, 'share_network_get', + mock.Mock(return_value=share_network)) + self.mock_object(self.share_manager.db, 'share_server_update') for m in ['deallocate_network', 'allocate_network']: - self.stubs.Set(self.share_manager.driver, m, mock.Mock()) - self.stubs.Set(self.share_manager, '_form_server_setup_info', - mock.Mock(return_value=network_info)) - self.stubs.Set(self.share_manager.db, - 'share_server_backend_details_set', - mock.Mock()) - self.stubs.Set(self.share_manager.driver, 'setup_server', - mock.Mock(side_effect=exception.ManilaException( - detail_data=detail_data))) + self.mock_object(self.share_manager.driver, m) + self.mock_object(self.share_manager, '_form_server_setup_info', + mock.Mock(return_value=network_info)) + self.mock_object(self.share_manager.db, + 'share_server_backend_details_set') + self.mock_object(self.share_manager.driver, 'setup_server', + mock.Mock(side_effect=exception.ManilaException( + detail_data=detail_data))) # execute method _setup_server self.assertRaises( diff --git a/manila/tests/share/test_rpcapi.py b/manila/tests/share/test_rpcapi.py index 3ec6653d..be11c669 100644 --- a/manila/tests/share/test_rpcapi.py +++ b/manila/tests/share/test_rpcapi.py @@ -106,8 +106,8 @@ class ShareRpcAPITestCase(test.TestCase): if expected_retval: return expected_retval - self.stubs.Set(self.rpcapi.client, "prepare", _fake_prepare_method) - self.stubs.Set(self.rpcapi.client, rpc_method, _fake_rpc_method) + self.mock_object(self.rpcapi.client, "prepare", _fake_prepare_method) + self.mock_object(self.rpcapi.client, rpc_method, _fake_rpc_method) retval = getattr(self.rpcapi, method)(self.ctxt, **kwargs) diff --git a/manila/tests/share/test_volume_types.py b/manila/tests/share/test_volume_types.py index 76e7868a..68d9d151 100644 --- a/manila/tests/share/test_volume_types.py +++ b/manila/tests/share/test_volume_types.py @@ -60,18 +60,18 @@ class VolumeTypesTestCase(test.TestCase): @ddt.data({}, fake_type, fake_type_w_extra, fake_types) def test_get_all_types(self, vol_type): - self.stubs.Set(db, - 'volume_type_get_all', - mock.Mock(return_value=vol_type)) + self.mock_object(db, + 'volume_type_get_all', + mock.Mock(return_value=vol_type)) returned_type = volume_types.get_all_types(self.context) self.assertItemsEqual(vol_type, returned_type) def test_get_all_types_filter(self): vol_type = self.fake_type_w_extra search_filter = {"extra_specs": {"gold": "True"}} - self.stubs.Set(db, - 'volume_type_get_all', - mock.Mock(return_value=vol_type)) + self.mock_object(db, + 'volume_type_get_all', + mock.Mock(return_value=vol_type)) returned_type = volume_types.get_all_types(self.context, search_opts=search_filter) self.assertItemsEqual(vol_type, returned_type) @@ -82,9 +82,9 @@ class VolumeTypesTestCase(test.TestCase): def test_get_volume_type_extra_specs(self): vol_type = self.fake_type_w_extra['test_with_extra'] - self.stubs.Set(db, - 'volume_type_get', - mock.Mock(return_value=vol_type)) + self.mock_object(db, + 'volume_type_get', + mock.Mock(return_value=vol_type)) id = vol_type['id'] extra_spec = volume_types.get_volume_type_extra_specs(id, key='gold') self.assertEqual(vol_type['extra_specs']['gold'], extra_spec) @@ -95,9 +95,9 @@ class VolumeTypesTestCase(test.TestCase): vol_type1 = self.fake_type['test'] vol_type2 = self.fake_type_w_extra['test_with_extra'] expeted_diff = {'extra_specs': {u'gold': (None, u'True')}} - self.stubs.Set(db, - 'volume_type_get', - mock.Mock(side_effect=[vol_type1, vol_type2])) + self.mock_object(db, + 'volume_type_get', + mock.Mock(side_effect=[vol_type1, vol_type2])) (diff, equal) = volume_types.volume_types_diff(self.context, vol_type1['id'], vol_type2['id']) @@ -106,9 +106,9 @@ class VolumeTypesTestCase(test.TestCase): def test_volume_types_diff_equal(self): vol_type = self.fake_type['test'] - self.stubs.Set(db, - 'volume_type_get', - mock.Mock(return_value=vol_type)) + self.mock_object(db, + 'volume_type_get', + mock.Mock(return_value=vol_type)) (diff, equal) = volume_types.volume_types_diff(self.context, vol_type['id'], vol_type['id']) diff --git a/manila/tests/test_context.py b/manila/tests/test_context.py index 4ed87ab2..4db80c66 100644 --- a/manila/tests/test_context.py +++ b/manila/tests/test_context.py @@ -69,7 +69,7 @@ class ContextTestCase(test.TestCase): def fake_warn(log_msg, other_args): info['log_msg'] = log_msg % other_args - self.stubs.Set(context.LOG, 'warn', fake_warn) + self.mock_object(context.LOG, 'warn', fake_warn) c = context.RequestContext('user', 'project', diff --git a/manila/tests/test_quota.py b/manila/tests/test_quota.py index 1ebfc52e..114f99a7 100644 --- a/manila/tests/test_quota.py +++ b/manila/tests/test_quota.py @@ -658,7 +658,7 @@ class DbQuotaDriverTestCase(test.TestCase): self.calls.append('quota_class_get_all_by_name') self.assertEqual(quota_class, 'test_class') return dict(gigabytes=500, shares=10, ) - self.stubs.Set(db, 'quota_class_get_all_by_name', fake_qcgabn) + self.mock_object(db, 'quota_class_get_all_by_name', fake_qcgabn) def test_get_class_quotas(self): self._stub_quota_class_get_all_by_name() @@ -702,10 +702,10 @@ class DbQuotaDriverTestCase(test.TestCase): return dict(shares=dict(in_use=2, reserved=0), gigabytes=dict(in_use=10, reserved=0), ) - self.stubs.Set(db, 'quota_get_all_by_project_and_user', fake_qgabpu) - self.stubs.Set(db, 'quota_get_all_by_project', fake_qgabp) - self.stubs.Set(db, 'quota_usage_get_all_by_project_and_user', - fake_qugabpu) + self.mock_object(db, 'quota_get_all_by_project_and_user', fake_qgabpu) + self.mock_object(db, 'quota_get_all_by_project', fake_qgabp) + self.mock_object(db, 'quota_usage_get_all_by_project_and_user', + fake_qugabpu) self._stub_quota_class_get_all_by_name() @@ -735,8 +735,8 @@ class DbQuotaDriverTestCase(test.TestCase): return dict(shares=dict(in_use=2, reserved=0), gigabytes=dict(in_use=10, reserved=0), ) - self.stubs.Set(db, 'quota_get_all_by_project', fake_qgabp) - self.stubs.Set(db, 'quota_usage_get_all_by_project', fake_qugabp) + self.mock_object(db, 'quota_get_all_by_project', fake_qgabp) + self.mock_object(db, 'quota_usage_get_all_by_project', fake_qugabp) self._stub_quota_class_get_all_by_name() @@ -905,12 +905,12 @@ class DbQuotaDriverTestCase(test.TestCase): self.calls.append('quota_get_all_by_project_and_user') return {'shares': 2} - self.stubs.Set(self.driver, 'get_project_quotas', - fake_get_project_quotas) - self.stubs.Set(self.driver, 'get_user_quotas', - fake_get_user_quotas) - self.stubs.Set(db, 'quota_get_all_by_project_and_user', - fake_qgabpau) + self.mock_object(self.driver, 'get_project_quotas', + fake_get_project_quotas) + self.mock_object(self.driver, 'get_user_quotas', + fake_get_user_quotas) + self.mock_object(db, 'quota_get_all_by_project_and_user', + fake_qgabpau) def test_get_settable_quotas_with_user(self): self._stub_get_settable_quotas() @@ -956,8 +956,8 @@ class DbQuotaDriverTestCase(test.TestCase): return dict((k, dict(limit=v.default)) for k, v in resources.items()) - self.stubs.Set(self.driver, 'get_project_quotas', - fake_get_project_quotas) + self.mock_object(self.driver, 'get_project_quotas', + fake_get_project_quotas) def test_get_quotas_has_sync_unknown(self): self._stub_get_project_quotas() @@ -1009,7 +1009,7 @@ class DbQuotaDriverTestCase(test.TestCase): self.calls.append(('quota_reserve', expire, until_refresh, max_age)) return ['resv-1', 'resv-2', 'resv-3'] - self.stubs.Set(db, 'quota_reserve', fake_quota_reserve) + self.mock_object(db, 'quota_reserve', fake_quota_reserve) def test_reserve_bad_expire(self): self._stub_get_project_quotas() @@ -1100,8 +1100,8 @@ class DbQuotaDriverTestCase(test.TestCase): def fake_quota_delete_all_by_project(context, project_id): self.calls.append(('quota_destroy_all_by_project', project_id)) return None - self.stubs.Set(sqa_api, 'quota_destroy_all_by_project', - fake_quota_delete_all_by_project) + self.mock_object(sqa_api, 'quota_destroy_all_by_project', + fake_quota_delete_all_by_project) def test_delete_by_project(self): self._stub_quota_delete_all_by_project() @@ -1196,13 +1196,15 @@ class QuotaReserveSqlAlchemyTestCase(test.TestCase): return reservation_ref - self.stubs.Set(sqa_api, 'get_session', fake_get_session) - self.stubs.Set(sqa_api, '_get_project_quota_usages', - fake_get_project_quota_usages) - self.stubs.Set(sqa_api, '_get_user_quota_usages', - fake_get_user_quota_usages) - self.stubs.Set(sqa_api, '_quota_usage_create', fake_quota_usage_create) - self.stubs.Set(sqa_api, '_reservation_create', fake_reservation_create) + self.mock_object(sqa_api, 'get_session', fake_get_session) + self.mock_object(sqa_api, '_get_project_quota_usages', + fake_get_project_quota_usages) + self.mock_object(sqa_api, '_get_user_quota_usages', + fake_get_user_quota_usages) + self.mock_object(sqa_api, '_quota_usage_create', + fake_quota_usage_create) + self.mock_object(sqa_api, '_reservation_create', + fake_reservation_create) self.patcher = mock.patch.object(timeutils, 'utcnow') self.mock_utcnow = self.patcher.start() diff --git a/manila/tests/test_utils.py b/manila/tests/test_utils.py index 452a16f2..877c1aad 100644 --- a/manila/tests/test_utils.py +++ b/manila/tests/test_utils.py @@ -233,7 +233,7 @@ class GenericUtilsTestCase(test.TestCase): raise exception.ProcessExecutionError return 'fakecontents', None - self.stubs.Set(utils, 'execute', fake_execute) + self.mock_object(utils, 'execute', fake_execute) contents = utils.read_file_as_root('good') self.assertEqual(contents, 'fakecontents') self.assertRaises(exception.FileNotFound, @@ -243,7 +243,7 @@ class GenericUtilsTestCase(test.TestCase): def fake_execute(*args, **kwargs): if args[0] == 'chown': fake_execute.uid = args[1] - self.stubs.Set(utils, 'execute', fake_execute) + self.mock_object(utils, 'execute', fake_execute) with tempfile.NamedTemporaryFile() as f: with utils.temporary_chown(f.name, owner_uid=2): diff --git a/manila/tests/volume/test_cinder.py b/manila/tests/volume/test_cinder.py index ceeeeccc..27a8d2d6 100644 --- a/manila/tests/volume/test_cinder.py +++ b/manila/tests/volume/test_cinder.py @@ -47,12 +47,12 @@ class CinderApiTestCase(test.TestCase): self.api = cinder.API() self.cinderclient = FakeCinderClient() self.ctx = context.get_admin_context() - self.stubs.Set(cinder, 'cinderclient', - mock.Mock(return_value=self.cinderclient)) - self.stubs.Set(cinder, '_untranslate_volume_summary_view', - lambda ctx, vol: vol) - self.stubs.Set(cinder, '_untranslate_snapshot_summary_view', - lambda ctx, snap: snap) + self.mock_object(cinder, 'cinderclient', + mock.Mock(return_value=self.cinderclient)) + self.mock_object(cinder, '_untranslate_volume_summary_view', + lambda ctx, vol: vol) + self.mock_object(cinder, '_untranslate_snapshot_summary_view', + lambda ctx, snap: snap) def test_get(self): volume_id = 'volume_id1' @@ -133,56 +133,52 @@ class CinderApiTestCase(test.TestCase): self.api.update, self.ctx, '', '') def test_reserve_volume(self): - self.stubs.Set(self.cinderclient.volumes, 'reserve', mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'reserve') self.api.reserve_volume(self.ctx, 'id1') self.cinderclient.volumes.reserve.assert_called_once_with('id1') def test_unreserve_volume(self): - self.stubs.Set(self.cinderclient.volumes, 'unreserve', mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'unreserve') self.api.unreserve_volume(self.ctx, 'id1') self.cinderclient.volumes.unreserve.assert_called_once_with('id1') def test_begin_detaching(self): - self.stubs.Set(self.cinderclient.volumes, 'begin_detaching', - mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'begin_detaching') self.api.begin_detaching(self.ctx, 'id1') self.cinderclient.volumes.begin_detaching.assert_called_once_with( 'id1') def test_roll_detaching(self): - self.stubs.Set(self.cinderclient.volumes, 'roll_detaching', - mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'roll_detaching') self.api.roll_detaching(self.ctx, 'id1') self.cinderclient.volumes.roll_detaching.assert_called_once_with('id1') def test_attach(self): - self.stubs.Set(self.cinderclient.volumes, 'attach', mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'attach') self.api.attach(self.ctx, 'id1', 'uuid', 'point') self.cinderclient.volumes.attach.assert_called_once_with('id1', 'uuid', 'point') def test_detach(self): - self.stubs.Set(self.cinderclient.volumes, 'detach', mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'detach') self.api.detach(self.ctx, 'id1') self.cinderclient.volumes.detach.assert_called_once_with('id1') def test_initialize_connection(self): - self.stubs.Set(self.cinderclient.volumes, 'initialize_connection', - mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'initialize_connection') self.api.initialize_connection(self.ctx, 'id1', 'connector') self.cinderclient.volumes.initialize_connection.\ assert_called_once_with('id1', 'connector') def test_terminate_connection(self): - self.stubs.Set(self.cinderclient.volumes, 'terminate_connection', - mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'terminate_connection') self.api.terminate_connection(self.ctx, 'id1', 'connector') self.cinderclient.volumes.terminate_connection.\ assert_called_once_with('id1', 'connector') def test_delete(self): - self.stubs.Set(self.cinderclient.volumes, 'delete', mock.Mock()) + self.mock_object(self.cinderclient.volumes, 'delete') self.api.delete(self.ctx, 'id1') self.cinderclient.volumes.delete.assert_called_once_with('id1') @@ -212,8 +208,7 @@ class CinderApiTestCase(test.TestCase): self.assertEqual(result['id'], 'created_id') def test_delete_snapshot(self): - self.stubs.Set(self.cinderclient.volume_snapshots, - 'delete', mock.Mock()) + self.mock_object(self.cinderclient.volume_snapshots, 'delete') self.api.delete_snapshot(self.ctx, 'id1') self.cinderclient.volume_snapshots.delete.assert_called_once_with( 'id1')