openstack
/
manila
Code Issues Proposed changes

Replace legacy StubOutForTesting class 

The Manila test module uses a class called StubOutForTesting, which
is an awkward holdover from when the unit tests were using Mox.
Alex wrote a more elegant and capable mocker method,
manila.test.TestCase.mock_object, in the Cinder project which we
have now added to Manila. So to remove the duplicate functionality
and legacy code, all references to self.stubs.Set() in the Manila
tests should be replaced with self.mock_object() and any related
dead code should be removed.

Resolves-bug: #1415602
Change-Id: Ie5f203c0b2cb57ad00d9ec8db0529075b6fef261
This commit is contained in:
Clinton Knight 2015-01-28 14:35:02 -05:00
parent 77e3087ad0
commit 65d1158526
46 changed files with 1311 additions and 1364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
manila/test.py
View File

@ -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()

14
manila/tests/api/contrib/test_admin_actions.py
View File

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

12
manila/tests/api/contrib/test_services.py
View File

@ -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()

21
manila/tests/api/contrib/test_share_actions.py
View File

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

74
manila/tests/api/contrib/test_types_extra_specs.py
View File

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

16
manila/tests/api/contrib/test_types_manage.py
View File

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

28
manila/tests/api/fakes.py
View File

@ -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

6
manila/tests/api/v1/test_limits.py
View File

@ -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."""

2
manila/tests/api/v1/test_security_service.py
View File

@ -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(

129
manila/tests/api/v1/test_share_metadata.py
View File

@ -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"

52
manila/tests/api/v1/test_share_servers.py
View File

@ -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,

42
manila/tests/api/v1/test_share_snapshots.py
View File

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

67
manila/tests/api/v1/test_shares.py
View File

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

16
manila/tests/api/v1/test_volume_types.py
View File

@ -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,

53
manila/tests/compute/test_nova.py
View File

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

11
manila/tests/fake_notifier.py
View File

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

4
manila/tests/fake_utils.py
View File

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

53
manila/tests/network/neutron/test_neutron_api.py
View File

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

10
manila/tests/network/neutron/test_neutron_plugin.py
View File

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

2
manila/tests/scheduler/test_host_filters.py
View File

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

2
manila/tests/scheduler/test_host_manager.py
View File

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

2
manila/tests/scheduler/test_scheduler.py
View File

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

2
manila/tests/share/drivers/emc/test_driver.py
View File

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

2
manila/tests/share/drivers/emc/test_emc_vnx.py
View File

@ -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()

171
manila/tests/share/drivers/ganesha/test_manager.py
View File

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

4
manila/tests/share/drivers/ganesha/test_utils.py
View File

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

2
manila/tests/share/drivers/huawei/test_huawei_nas.py
View File

@ -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

34
manila/tests/share/drivers/ibm/test_ganesha_utils.py
View File

@ -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]

61
manila/tests/share/drivers/ibm/test_gpfs.py
View File

@ -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 <world>', 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 <world>', 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
)

110
manila/tests/share/drivers/netapp/test_cluster_mode.py
View File

@ -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,

72
manila/tests/share/drivers/test_ganesha.py
View File

@ -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()

384
manila/tests/share/drivers/test_generic.py
View File

@ -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,

137
manila/tests/share/drivers/test_glusterfs.py
View File

@ -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):
</cliOutput>""", ''
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):
</cliOutput>""", ''
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):
</cliOutput>""", ''
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(

53
manila/tests/share/drivers/test_glusterfs_native.py
View File

@ -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]

446
manila/tests/share/drivers/test_service_instance.py
View File

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

38
manila/tests/share/drivers/zfssa/test_zfssarest.py
View File

@ -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",

22
manila/tests/share/drivers/zfssa/test_zfssashare.py
View File

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

139
manila/tests/share/test_api.py
View File

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

14
manila/tests/share/test_driver.py
View File

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

224
manila/tests/share/test_manager.py
View File

@ -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(

4
manila/tests/share/test_rpcapi.py
View File

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

30
manila/tests/share/test_volume_types.py
View File

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

2
manila/tests/test_context.py
View File

@ -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',

52
manila/tests/test_quota.py
View File

@ -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()

4
manila/tests/test_utils.py
View File

@ -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):

37
manila/tests/volume/test_cinder.py
View File

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