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')