def test_share_instance_prefer_active_instance(self):
instance_list = [
db_utils.create_share_instance(
status=constants.STATUS_AVAILABLE,
share_id='fake_id',
replica_state=constants.REPLICA_STATE_IN_SYNC),
db_utils.create_share_instance(
status=constants.STATUS_CREATING,
share_id='fake_id',
replica_state=constants.REPLICA_STATE_OUT_OF_SYNC),
db_utils.create_share_instance(
status=constants.STATUS_ERROR, share_id='fake_id',
replica_state=constants.REPLICA_STATE_ACTIVE),
db_utils.create_share_instance(
status=constants.STATUS_MANAGING, share_id='fake_id',
replica_state=constants.REPLICA_STATE_ACTIVE),
]
share1 = db_utils.create_share(instances=instance_list)
share2 = db_utils.create_share(instances=list(reversed(instance_list)))
self.assertEqual(
constants.STATUS_ERROR, share1.instance['status'])
self.assertEqual(
constants.STATUS_ERROR, share2.instance['status'])
def test_share_filter_by_host_with_pools(self):
shares = [[db_api.share_create(self.ctxt, {'host': value})
for value in ('foo', 'foo#pool0')]]
db_utils.create_share()
self._assertEqualListsOfObjects(shares[0],
db_api.share_get_all_by_host(
self.ctxt, 'foo'),
ignored_keys=['share_type',
'share_type_id',
'export_locations'])
def test_share_instance_not_transitional(self, status, trans_status):
instance_list = [
db_utils.create_share_instance(status=status, share_id='fake_id'),
db_utils.create_share_instance(status=trans_status,
share_id='fake_id')
]
share1 = db_utils.create_share(instances=instance_list)
share2 = db_utils.create_share(instances=list(reversed(instance_list)))
self.assertEqual(status, share1.instance['status'])
self.assertEqual(status, share2.instance['status'])
def test_share_instance_available(self, status):
instance_list = [
db_utils.create_share_instance(status=constants.STATUS_AVAILABLE,
share_id='fake_id'),
db_utils.create_share_instance(status=status, share_id='fake_id')
]
share1 = db_utils.create_share(instances=instance_list)
share2 = db_utils.create_share(instances=list(reversed(instance_list)))
self.assertEqual(constants.STATUS_AVAILABLE, share1.instance['status'])
self.assertEqual(constants.STATUS_AVAILABLE, share2.instance['status'])
def test_share_instance_not_transitional(self, status, trans_status):
instance_list = [
db_utils.create_share_instance(status=status,
share_id='fake_id'),
db_utils.create_share_instance(status=trans_status,
share_id='fake_id')
]
share1 = db_utils.create_share(instances=instance_list)
share2 = db_utils.create_share(instances=list(reversed(instance_list)))
self.assertEqual(status, share1.instance['status'])
self.assertEqual(status, share2.instance['status'])
def test_share_instance_available(self, status):
instance_list = [
db_utils.create_share_instance(status=constants.STATUS_AVAILABLE,
share_id='fake_id'),
db_utils.create_share_instance(status=status,
share_id='fake_id')
]
share1 = db_utils.create_share(instances=instance_list)
share2 = db_utils.create_share(instances=list(reversed(instance_list)))
self.assertEqual(constants.STATUS_AVAILABLE, share1.instance['status'])
self.assertEqual(constants.STATUS_AVAILABLE, share2.instance['status'])
def test_share_instance_reverting(self, status):
instance_list = [
db_utils.create_share_instance(status=constants.STATUS_REVERTING,
share_id='fake_id'),
db_utils.create_share_instance(status=status, share_id='fake_id'),
db_utils.create_share_instance(
status=constants.STATUS_ERROR_DELETING, share_id='fake_id'),
]
share1 = db_utils.create_share(instances=instance_list)
share2 = db_utils.create_share(instances=list(reversed(instance_list)))
self.assertEqual(constants.STATUS_REVERTING, share1.instance['status'])
self.assertEqual(constants.STATUS_REVERTING, share2.instance['status'])
def _setup_share_instance_data(self, instance=None):
if instance is None:
instance = db_utils.create_share(status=constants.STATUS_AVAILABLE,
size='1').instance
req = webob.Request.blank(
'/v2/fake/share_instances/%s/action' % instance['id'])
return instance, req
def test_copy_share_data_access_rule_invalid(self):
fake_share = db_utils.create_share(id='fakeid',
status=constants.STATUS_AVAILABLE,
host='fake_host')
share_driver = self._setup_mocks_copy_share_data()
remote = {
'access': {
'access_to': None
},
'mount': 'fake_mount',
'umount': 'fake_umount'
}
local = {
'access': {
'access_to': '192.168.1.1'
},
'mount': 'fake_mount',
'umount': 'fake_umount'
}
driver.CONF.set_default('migration_tmp_location', '/fake/path')
self.assertRaises(exception.ShareMigrationFailed,
share_driver.copy_share_data, 'ctx', None,
fake_share, None, None, None, None, local, remote)
def test_share_access_mapping_state(self, expected_status):
ctxt = context.get_admin_context()
share = db_utils.create_share()
share_instances = [
share.instance,
db_utils.create_share_instance(share_id=share['id']),
db_utils.create_share_instance(share_id=share['id']),
db_utils.create_share_instance(share_id=share['id']),
]
access_rule = db_utils.create_access(share_id=share['id'])
# Update the access mapping states
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[0]['id'],
{'state': constants.ACCESS_STATE_ACTIVE})
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[1]['id'],
{'state': expected_status})
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[2]['id'],
{'state': constants.ACCESS_STATE_ACTIVE})
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[3]['id'],
{'deleted': 'True', 'state': constants.STATUS_DELETED})
access_rule = db_api.share_access_get(ctxt, access_rule['id'])
self.assertEqual(expected_status, access_rule['state'])
def test_index_with_limit(self):
req = self._get_request('/share_instances')
req_context = req.environ['manila.context']
share_instances_count = 3
test_instances = [
db_utils.create_share(size=s + 1).instance
for s in range(0, share_instances_count)
]
expect_links = [
{
'href': (
'http://localhost/v1/fake/share_instances?'
'limit=3&marker=%s' % test_instances[2]['id']),
'rel': 'next',
}
]
url = 'share_instances?limit=3'
req = self._get_request(url)
actual_result = self.controller.index(req)
self._validate_ids_in_share_instances_list(
test_instances, actual_result['share_instances'])
self.assertEqual(expect_links, actual_result['share_instances_links'])
self.mock_policy_check.assert_called_once_with(
req_context, self.resource_name, 'index')
def test_custom_query(self):
share = db_utils.create_share()
share_access = db_utils.create_access(share_id=share['id'])
db_api.share_access_delete(self.ctxt, share_access.id)
self.assertRaises(exception.NotFound, db_api.share_access_get,
self.ctxt, share_access.id)
def setUp(self):
super(ShareRpcAPITestCase, self).setUp()
self.context = context.get_admin_context()
share = db_utils.create_share(
availability_zone=CONF.storage_availability_zone,
status=constants.STATUS_AVAILABLE
)
access = db_utils.create_access(share_id=share['id'])
snapshot = db_utils.create_snapshot(share_id=share['id'])
share_replica = db_utils.create_share_replica(
id='fake_replica',
share_id='fake_share_id',
host='fake_host',
)
share_server = db_utils.create_share_server()
cg = {'id': 'fake_cg_id', 'host': 'fake_host'}
cgsnapshot = {'id': 'fake_cg_id'}
host = {'host': 'fake_host', 'capabilities': 1}
self.fake_share = jsonutils.to_primitive(share)
# mock out the getattr on the share db model object since jsonutils
# doesn't know about those extra attributes to pull in
self.fake_share['instance'] = jsonutils.to_primitive(share.instance)
self.fake_share_replica = jsonutils.to_primitive(share_replica)
self.fake_access = jsonutils.to_primitive(access)
self.fake_snapshot = jsonutils.to_primitive(snapshot)
self.fake_share_server = jsonutils.to_primitive(share_server)
self.fake_cg = jsonutils.to_primitive(cg)
self.fake_cgsnapshot = jsonutils.to_primitive(cgsnapshot)
self.fake_host = jsonutils.to_primitive(host)
self.ctxt = context.RequestContext('fake_user', 'fake_project')
self.rpcapi = share_rpcapi.ShareAPI()
def setUp(self):
super(DataManagerTestCase, self).setUp()
self.manager = manager.DataManager()
self.context = context.get_admin_context()
self.topic = 'fake_topic'
self.share = db_utils.create_share()
manager.CONF.set_default('migration_tmp_location', '/tmp/')
def test_copy_share_data_remote_access_exception(self):
fake_share = db_utils.create_share(
id='fakeid', status=constants.STATUS_AVAILABLE, host='fake_host')
fake_share_instance = {'id': 'fake_id', 'host': 'fake_host'}
share_driver = self._setup_mocks_copy_share_data()
remote = {'access': {'access_to': '192.168.0.1'},
'mount': 'fake_mount',
'umount': 'fake_umount'}
local = {'access': {'access_to': '192.168.1.1'},
'mount': 'fake_mount',
'umount': 'fake_umount'}
helper = migration.ShareMigrationHelper(None, None, None, None, None)
driver.CONF.set_default('migration_tmp_location', '/fake/path')
driver.CONF.set_default('migration_ignore_files', None)
self.mock_object(migration.ShareMigrationHelper,
'deny_migration_access')
self.mock_object(
migration.ShareMigrationHelper,
'allow_migration_access',
mock.Mock(side_effect=[None,
exception.ShareMigrationFailed(
reason='fake')]))
self.mock_object(migration.ShareMigrationHelper,
'cleanup_migration_access')
self.assertRaises(exception.ShareMigrationFailed,
share_driver.copy_share_data, 'ctx', helper,
fake_share, fake_share_instance, None,
fake_share_instance, None, local, remote)
args = ((None, local['access'], False),
(None, remote['access'], False))
migration.ShareMigrationHelper.deny_migration_access.assert_has_calls(
[mock.call(*a) for a in args])
def test_show_access_not_authorized(self):
share = db_utils.create_share(
project_id='c3c5ec1ccc4640d0af1914cbf11f05ad', is_public=False)
access = db_utils.create_access(
id='76699c6b-f3da-47d7-b468-364f1347ba04', share_id=share['id'])
req = fakes.HTTPRequest.blank('/v2/share-access-rules/%s' %
access['id'],
version="2.45")
self.mock_object(
policy, 'check_policy',
mock.Mock(side_effect=[None, None, exception.NotAuthorized]))
self.assertRaises(exception.NotAuthorized, self.controller.show, req,
access['id'])
policy.check_policy.assert_has_calls([
mock.call(req.environ['manila.context'], 'share_access_rule',
'get'),
mock.call(req.environ['manila.context'], 'share', 'access_get'),
mock.call(req.environ['manila.context'], 'share', 'get', mock.ANY)
])
policy_check_call_args_list = policy.check_policy.call_args_list[2][0]
share_being_checked = policy_check_call_args_list[3]
self.assertEqual('c3c5ec1ccc4640d0af1914cbf11f05ad',
share_being_checked['project_id'])
self.assertIs(False, share_being_checked['is_public'])
def test_share_access_mapping_state(self, expected_status):
ctxt = context.get_admin_context()
share = db_utils.create_share()
share_instances = [
share.instance,
db_utils.create_share_instance(share_id=share['id']),
db_utils.create_share_instance(share_id=share['id']),
db_utils.create_share_instance(share_id=share['id']),
]
access_rule = db_utils.create_access(share_id=share['id'])
# Update the access mapping states
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[0]['id'],
{'state': constants.ACCESS_STATE_ACTIVE})
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[1]['id'],
{'state': expected_status})
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[2]['id'],
{'state': constants.ACCESS_STATE_ACTIVE})
db_api.share_instance_access_update(
ctxt, access_rule['id'], share_instances[3]['id'],
{'deleted': 'True', 'state': constants.STATUS_DELETED})
access_rule = db_api.share_access_get(ctxt, access_rule['id'])
self.assertEqual(expected_status, access_rule['state'])
def setUp(self):
super(ShareRpcAPITestCase, self).setUp()
self.context = context.get_admin_context()
share = db_utils.create_share(
availability_zone=CONF.storage_availability_zone,
status=constants.STATUS_AVAILABLE)
access = db_utils.create_access(share_id=share['id'])
snapshot = db_utils.create_snapshot(share_id=share['id'])
share_replica = db_utils.create_share_replica(
id='fake_replica',
share_id='fake_share_id',
)
share_server = db_utils.create_share_server()
cg = {'id': 'fake_cg_id', 'host': 'fake_host'}
cgsnapshot = {'id': 'fake_cg_id'}
host = {'host': 'fake_host', 'capabilities': 1}
self.fake_share = jsonutils.to_primitive(share)
self.fake_share_replica = jsonutils.to_primitive(share_replica)
self.fake_access = jsonutils.to_primitive(access)
self.fake_snapshot = jsonutils.to_primitive(snapshot)
self.fake_share_server = jsonutils.to_primitive(share_server)
self.fake_cg = jsonutils.to_primitive(cg)
self.fake_cgsnapshot = jsonutils.to_primitive(cgsnapshot)
self.fake_host = jsonutils.to_primitive(host)
self.ctxt = context.RequestContext('fake_user', 'fake_project')
self.rpcapi = share_rpcapi.ShareAPI()
def test_show(self):
test_instance = db_utils.create_share(size=1).instance
id = test_instance['id']
actual_result = self.controller.show(self._get_request('fake'), id)
self.assertEqual(id, actual_result['share_instance']['id'])
def test_index(self, version):
url = '/share_instances'
if (api_version_request.APIVersionRequest(version) >=
api_version_request.APIVersionRequest('2.35')):
url += "?export_location_path=/admin/export/location"
req = self._get_request(url, version=version)
req_context = req.environ['manila.context']
share_instances_count = 3
test_instances = [
db_utils.create_share(size=s + 1).instance
for s in range(0, share_instances_count)
]
db.share_export_locations_update(
self.admin_context, test_instances[0]['id'],
'/admin/export/location', False)
actual_result = self.controller.index(req)
if (api_version_request.APIVersionRequest(version) >=
api_version_request.APIVersionRequest('2.35')):
test_instances = test_instances[:1]
self._validate_ids_in_share_instances_list(
test_instances, actual_result['share_instances'])
self.mock_policy_check.assert_called_once_with(
req_context, self.resource_name, 'index')
def setUp(self):
super(ShareRpcAPITestCase, self).setUp()
self.context = context.get_admin_context()
share = db_utils.create_share(
availability_zone=CONF.storage_availability_zone,
status=constants.STATUS_AVAILABLE)
snapshot = db_utils.create_snapshot(share_id=share['id'])
share_replica = db_utils.create_share_replica(
id='fake_replica',
share_id='fake_share_id',
host='fake_host',
)
share_server = db_utils.create_share_server()
share_group = {'id': 'fake_share_group_id', 'host': 'fake_host'}
share_group_snapshot = {'id': 'fake_share_group_id'}
host = 'fake_host'
self.fake_share = jsonutils.to_primitive(share)
# mock out the getattr on the share db model object since jsonutils
# doesn't know about those extra attributes to pull in
self.fake_share['instance'] = jsonutils.to_primitive(share.instance)
self.fake_share_replica = jsonutils.to_primitive(share_replica)
self.fake_snapshot = jsonutils.to_primitive(snapshot)
self.fake_snapshot['share_instance'] = jsonutils.to_primitive(
snapshot.instance)
self.fake_share_server = jsonutils.to_primitive(share_server)
self.fake_share_group = jsonutils.to_primitive(share_group)
self.fake_share_group_snapshot = jsonutils.to_primitive(
share_group_snapshot)
self.fake_host = jsonutils.to_primitive(host)
self.ctxt = context.RequestContext('fake_user', 'fake_project')
self.rpcapi = share_rpcapi.ShareAPI()
def test_deny_access_access_rule_not_found(self):
share = db_utils.create_share(mount_snapshot_support=True)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
access = db_utils.create_snapshot_access(
share_snapshot_id=snapshot['id'])
wrong_access = {
'access_type': 'fake_type',
'access_to': 'fake_IP',
'share_snapshot_id': 'fake_id'
}
get = self.mock_object(share_api.API, 'get',
mock.Mock(return_value=share))
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
access_get = self.mock_object(share_api.API, 'snapshot_access_get',
mock.Mock(return_value=wrong_access))
body = {'deny_access': {'access_id': access.id}}
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.deny_access, req, snapshot['id'],
body)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
access_get.assert_called_once_with(
utils.IsAMatcher(context.RequestContext),
body['deny_access']['access_id'])
def _setup_share_data(self, share=None):
if share is None:
share = db_utils.create_share(status=constants.STATUS_AVAILABLE,
size='1',
override_defaults=True)
req = webob.Request.blank('/v2/fake/shares/%s/action' % share['id'])
return share, req
def test_allow_access_share_without_mount_snap_support(self):
share = db_utils.create_share(mount_snapshot_support=False)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
access = {
'id': 'fake_id',
'access_type': 'ip',
'access_to': '1.1.1.1',
'state': 'new',
}
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
get = self.mock_object(share_api.API, 'get',
mock.Mock(return_value=share))
body = {'allow_access': access}
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.allow_access, req,
snapshot['id'], body)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
def test_allow_access_exists_exception(self):
share = db_utils.create_share(mount_snapshot_support=True)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
access = {
'id': 'fake_id',
'access_type': 'ip',
'access_to': '1.1.1.1',
'state': 'new',
}
msg = "Share snapshot access exists."
get = self.mock_object(share_api.API, 'get', mock.Mock(
return_value=share))
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
allow_access = self.mock_object(
share_api.API, 'snapshot_allow_access', mock.Mock(
side_effect=exception.ShareSnapshotAccessExists(msg)))
body = {'allow_access': access}
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.allow_access, req,
snapshot['id'], body)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
allow_access.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot,
access['access_type'], access['access_to'])
def test_deny_access(self):
share = db_utils.create_share(mount_snapshot_support=True)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
access = db_utils.create_snapshot_access(
share_snapshot_id=snapshot['id'])
get = self.mock_object(share_api.API, 'get',
mock.Mock(return_value=share))
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
access_get = self.mock_object(share_api.API, 'snapshot_access_get',
mock.Mock(return_value=access))
deny_access = self.mock_object(share_api.API, 'snapshot_deny_access')
body = {'deny_access': {'access_id': access.id}}
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
resp = self.controller.deny_access(req, snapshot['id'], body)
self.assertEqual(202, resp.status_int)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
access_get.assert_called_once_with(
utils.IsAMatcher(context.RequestContext),
body['deny_access']['access_id'])
deny_access.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot, access)
def test_migrate_share_to_host(self):
class fake_host(object):
host = 'fake@backend#pool'
share = db_utils.create_share()
host = fake_host()
self.mock_object(db, 'share_get', mock.Mock(return_value=share))
self.mock_object(share_rpcapi.ShareAPI, 'migration_start',
mock.Mock(side_effect=TypeError))
self.mock_object(base.Scheduler,
'host_passes_filters',
mock.Mock(return_value=host))
self.assertRaises(
TypeError, self.manager.migrate_share_to_host,
self.context, share['id'], 'fake@backend#pool', False, True, True,
False, True, 'fake_net_id', 'fake_type_id', {}, None)
db.share_get.assert_called_once_with(self.context, share['id'])
base.Scheduler.host_passes_filters.assert_called_once_with(
self.context, 'fake@backend#pool', {}, None)
share_rpcapi.ShareAPI.migration_start.assert_called_once_with(
self.context, share, host.host, False, True, True, False, True,
'fake_net_id', 'fake_type_id')
def test_get_and_update_access_rules_status_conditionally_change(
self, initial_status, change_allowed):
share = db_utils.create_share(access_rules_status=initial_status,
status=constants.STATUS_AVAILABLE)
share = db.share_get(self.context, share['id'])
self.assertEqual(initial_status, share['access_rules_status'])
conditionally_change = {
constants.SHARE_INSTANCE_RULES_SYNCING: constants.STATUS_ACTIVE,
}
updated_instance = (
self.access_helper.
get_and_update_share_instance_access_rules_status(
self.context, conditionally_change=conditionally_change,
share_instance_id=share['instance']['id'])
)
share = db.share_get(self.context, share['id'])
if change_allowed:
self.assertEqual(constants.STATUS_ACTIVE,
share['access_rules_status'])
self.assertIsNotNone(updated_instance)
else:
self.assertEqual(initial_status, share['access_rules_status'])
self.assertIsNone(updated_instance)
def _setup_share_instance_data(self, instance=None, version='2.7'):
if instance is None:
instance = db_utils.create_share(status=constants.STATUS_AVAILABLE,
size='1').instance
path = '/v2/fake/share_instances/%s/action' % instance['id']
req = fakes.HTTPRequest.blank(path, script_name=path, version=version)
return instance, req
def test_migrate_share_to_host_exception(self, exc):
share = db_utils.create_share(status=constants.STATUS_MIGRATING)
host = 'fake@backend#pool'
request_spec = {'share_id': share['id']}
self.mock_object(db, 'share_get', mock.Mock(return_value=share))
self.mock_object(base.Scheduler, 'host_passes_filters',
mock.Mock(side_effect=exc))
self.mock_object(db, 'share_update')
self.mock_object(db, 'share_instance_update')
capture = (exception.NoValidHost
if isinstance(exc, exception.NoValidHost) else TypeError)
self.assertRaises(capture, self.manager.migrate_share_to_host,
self.context, share['id'], host, False, True, True,
False, True, 'fake_net_id', 'fake_type_id',
request_spec, None)
base.Scheduler.host_passes_filters.assert_called_once_with(
self.context, host, request_spec, None)
db.share_get.assert_called_once_with(self.context, share['id'])
db.share_update.assert_called_once_with(
self.context, share['id'],
{'task_state': constants.TASK_STATE_MIGRATION_ERROR})
db.share_instance_update.assert_called_once_with(
self.context, share.instance['id'],
{'status': constants.STATUS_AVAILABLE})
def test_index(self, version):
url = '/share_instances'
if (api_version_request.APIVersionRequest(version) >=
api_version_request.APIVersionRequest('2.35')):
url += "?export_location_path=/admin/export/location"
req = self._get_request(url, version=version)
req_context = req.environ['manila.context']
share_instances_count = 3
test_instances = [
db_utils.create_share(size=s + 1).instance
for s in range(0, share_instances_count)
]
db.share_export_locations_update(self.admin_context,
test_instances[0]['id'],
'/admin/export/location', False)
actual_result = self.controller.index(req)
if (api_version_request.APIVersionRequest(version) >=
api_version_request.APIVersionRequest('2.35')):
test_instances = test_instances[:1]
self._validate_ids_in_share_instances_list(
test_instances, actual_result['share_instances'])
self.mock_policy_check.assert_called_once_with(req_context,
self.resource_name,
'index')
def test_index_with_limit(self):
req = self._get_request('/v2/fake/share_instances')
req_context = req.environ['manila.context']
share_instances_count = 3
test_instances = [
db_utils.create_share(size=s + 1).instance
for s in range(0, share_instances_count)
]
expect_links = [{
'href': ('http://localhost/share/v2/fake/share_instances?'
'limit=3&marker=%s' % test_instances[2]['id']),
'rel':
'next',
}]
url = '/v2/fake/share_instances?limit=3'
req = self._get_request(url)
actual_result = self.controller.index(req)
self._validate_ids_in_share_instances_list(
test_instances, actual_result['share_instances'])
self.assertEqual(expect_links, actual_result['share_instances_links'])
self.mock_policy_check.assert_called_once_with(req_context,
self.resource_name,
'index')
def _setup_share_instance_data(self, instance=None, version='2.7'):
if instance is None:
instance = db_utils.create_share(status=constants.STATUS_AVAILABLE,
size='1').instance
path = '/v2/fake/share_instances/%s/action' % instance['id']
req = fakes.HTTPRequest.blank(path, script_name=path, version=version)
return instance, req
def test_get_share_instances(self, version):
test_share = db_utils.create_share(size=1)
id = test_share['id']
req = self._get_request('fake', version=version)
req_context = req.environ['manila.context']
share_policy_check_call = mock.call(req_context, 'share', 'get',
mock.ANY)
get_instances_policy_check_call = mock.call(req_context,
'share_instance', 'index')
actual_result = self.controller.get_share_instances(req, id)
self._validate_ids_in_share_instances_list(
[test_share.instance], actual_result['share_instances'])
self.assertEqual(1, len(actual_result.get("share_instances", 0)))
for instance in actual_result["share_instances"]:
if (api_version_request.APIVersionRequest(version) >
api_version_request.APIVersionRequest("2.8")):
assert_method = self.assertNotIn
else:
assert_method = self.assertIn
assert_method("export_location", instance)
assert_method("export_locations", instance)
if (api_version_request.APIVersionRequest(version) >
api_version_request.APIVersionRequest("2.10")):
self.assertIn("replica_state", instance)
self.mock_policy_check.assert_has_calls(
[get_instances_policy_check_call, share_policy_check_call])
def _setup_share_data(self, share=None):
if share is None:
share = db_utils.create_share(status=constants.STATUS_AVAILABLE,
size='1',
override_defaults=True)
req = webob.Request.blank('/v2/fake/shares/%s/action' % share['id'])
return share, req
def test_get_share_instances(self, version):
test_share = db_utils.create_share(size=1)
id = test_share['id']
req = self._get_request('fake', version=version)
req_context = req.environ['manila.context']
share_policy_check_call = mock.call(
req_context, 'share', 'get', mock.ANY)
get_instances_policy_check_call = mock.call(
req_context, 'share_instance', 'index')
actual_result = self.controller.get_share_instances(req, id)
self._validate_ids_in_share_instances_list(
[test_share.instance],
actual_result['share_instances']
)
self.assertEqual(1, len(actual_result.get("share_instances", 0)))
for instance in actual_result["share_instances"]:
if (api_version_request.APIVersionRequest(version) >
api_version_request.APIVersionRequest("2.8")):
assert_method = self.assertNotIn
else:
assert_method = self.assertIn
assert_method("export_location", instance)
assert_method("export_locations", instance)
if (api_version_request.APIVersionRequest(version) >
api_version_request.APIVersionRequest("2.10")):
self.assertIn("replica_state", instance)
self.mock_policy_check.assert_has_calls([
get_instances_policy_check_call, share_policy_check_call])
def test_get_and_update_all_access_rules_updates_conditionally_changed(
self, statuses, changes_allowed):
share = db_utils.create_share(status=constants.STATUS_AVAILABLE)
db_utils.create_access(share_id=share['id'], state=statuses[0])
db_utils.create_access(share_id=share['id'], state=statuses[-1])
self.mock_object(db, 'share_instance_access_update', mock.Mock(
side_effect=db.share_instance_access_update))
updates = {
'access_key': 'renfrow2stars'
}
expected_updates = {
'access_key': 'renfrow2stars',
'state': constants.ACCESS_STATE_QUEUED_TO_DENY,
}
conditionally_change = {
constants.ACCESS_STATE_APPLYING:
constants.ACCESS_STATE_QUEUED_TO_DENY,
constants.ACCESS_STATE_QUEUED_TO_APPLY:
constants.ACCESS_STATE_QUEUED_TO_DENY,
}
rules = self.access_helper.get_and_update_share_instance_access_rules(
self.context, share_instance_id=share['instance']['id'],
updates=updates, conditionally_change=conditionally_change)
state_changed_rules = [
r for r in rules if
r['state'] == constants.ACCESS_STATE_QUEUED_TO_DENY
]
self.assertEqual(changes_allowed, len(state_changed_rules))
self.assertEqual(2, db.share_instance_access_update.call_count)
db.share_instance_access_update.assert_has_calls([
mock.call(self.context, mock.ANY, share['instance']['id'],
expected_updates),
] * changes_allowed)
def test_copy_share_data_remote_access_exception(self):
fake_share = db_utils.create_share(
id='fakeid', status=constants.STATUS_AVAILABLE, host='fake_host')
fake_share_instance = {'id': 'fake_id', 'host': 'fake_host'}
share_driver = self._setup_mocks_copy_share_data()
remote = {'access': {'access_to': '192.168.0.1'},
'mount': 'fake_mount',
'umount': 'fake_umount'}
local = {'access': {'access_to': '192.168.1.1'},
'mount': 'fake_mount',
'umount': 'fake_umount'}
helper = migration.ShareMigrationHelper(None, None, None, None, None)
driver.CONF.set_default('migration_tmp_location', '/fake/path')
driver.CONF.set_default('migration_ignore_files', None)
self.mock_object(migration.ShareMigrationHelper,
'deny_migration_access')
self.mock_object(
migration.ShareMigrationHelper,
'allow_migration_access',
mock.Mock(side_effect=[None,
exception.ShareMigrationFailed(
reason='fake')]))
self.mock_object(migration.ShareMigrationHelper,
'cleanup_migration_access')
self.assertRaises(exception.ShareMigrationFailed,
share_driver.copy_share_data, 'ctx', helper,
fake_share, fake_share_instance, None,
fake_share_instance, None, local, remote)
args = ((None, local['access'], False),
(None, remote['access'], False))
migration.ShareMigrationHelper.deny_migration_access.assert_has_calls(
[mock.call(*a) for a in args])
def test_get_and_update_access_rule_updates_conditionally_changed(
self, initial_state):
mock_debug_log = self.mock_object(access.LOG, 'debug')
share = db_utils.create_share(status=constants.STATUS_AVAILABLE)
rule = db_utils.create_access(share_id=share['id'],
state=initial_state)
self.mock_object(
db, 'share_instance_access_update',
mock.Mock(side_effect=db.share_instance_access_update))
updates = {'access_key': 'renfrow2stars'}
conditionally_change = {
constants.ACCESS_STATE_APPLYING:
constants.ACCESS_STATE_QUEUED_TO_DENY,
constants.ACCESS_STATE_DENYING:
constants.ACCESS_STATE_QUEUED_TO_DENY,
}
actual_rule = (
self.access_helper.get_and_update_share_instance_access_rule(
self.context,
rule['id'],
updates=updates,
share_instance_id=share['instance']['id'],
conditionally_change=conditionally_change))
self.assertEqual(rule['id'], actual_rule['access_id'])
if 'ing' in initial_state:
self.assertEqual(constants.ACCESS_STATE_QUEUED_TO_DENY,
actual_rule['state'])
self.assertFalse(mock_debug_log.called)
else:
self.assertEqual(initial_state, actual_rule['state'])
mock_debug_log.assert_called_once()
def test_get_and_update_access_rule_updates_conditionally_changed(
self, initial_state):
mock_debug_log = self.mock_object(access.LOG, 'debug')
share = db_utils.create_share(status=constants.STATUS_AVAILABLE)
rule = db_utils.create_access(share_id=share['id'],
state=initial_state)
self.mock_object(db, 'share_instance_access_update', mock.Mock(
side_effect=db.share_instance_access_update))
updates = {
'access_key': 'renfrow2stars'
}
conditionally_change = {
constants.ACCESS_STATE_APPLYING:
constants.ACCESS_STATE_QUEUED_TO_DENY,
constants.ACCESS_STATE_DENYING:
constants.ACCESS_STATE_QUEUED_TO_DENY,
}
actual_rule = (
self.access_helper.get_and_update_share_instance_access_rule(
self.context, rule['id'], updates=updates,
share_instance_id=share['instance']['id'],
conditionally_change=conditionally_change)
)
self.assertEqual(rule['id'], actual_rule['access_id'])
if 'ing' in initial_state:
self.assertEqual(constants.ACCESS_STATE_QUEUED_TO_DENY,
actual_rule['state'])
self.assertFalse(mock_debug_log.called)
else:
self.assertEqual(initial_state, actual_rule['state'])
mock_debug_log.assert_called_once()
def test_update_access_rules_an_update_is_in_progress(self, initial_state):
share = db_utils.create_share(status=constants.STATUS_AVAILABLE)
share_instance = share['instance']
db_utils.create_access(share_id=share['id'], state=initial_state)
mock_debug_log = self.mock_object(access.LOG, 'debug')
self.mock_object(self.access_helper, '_update_access_rules')
get_and_update_call = self.mock_object(
self.access_helper, 'get_and_update_share_instance_access_rules',
mock.Mock(side_effect=self.access_helper.
get_and_update_share_instance_access_rules))
retval = self.access_helper.update_access_rules(
self.context, share_instance['id'])
expected_filters = {
'state':
(constants.ACCESS_STATE_APPLYING, constants.ACCESS_STATE_DENYING),
}
self.assertIsNone(retval)
mock_debug_log.assert_called_once()
get_and_update_call.assert_called_once_with(
self.context,
filters=expected_filters,
share_instance_id=share_instance['id'])
self.assertFalse(self.access_helper._update_access_rules.called)
def test_allow_access(self, ip_address, version):
share = db_utils.create_share(mount_snapshot_support=True)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
access = {
'id': 'fake_id',
'access_type': 'ip',
'access_to': ip_address,
'state': 'new',
}
get = self.mock_object(share_api.API, 'get',
mock.Mock(return_value=share))
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
allow_access = self.mock_object(share_api.API, 'snapshot_allow_access',
mock.Mock(return_value=access))
body = {'allow_access': access}
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version=version)
actual = self.controller.allow_access(req, snapshot['id'], body)
self.assertEqual(access, actual['snapshot_access'])
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
allow_access.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot,
access['access_type'], access['access_to'])
def test_update_access_rules_delete_all_rules(self, delete_all_rules):
share = db_utils.create_share(status=constants.STATUS_AVAILABLE)
share_instance = share['instance']
db_utils.create_access(share_id=share['id'],
state=constants.STATUS_ACTIVE)
db_utils.create_access(share_id=share['id'],
state=constants.ACCESS_STATE_QUEUED_TO_APPLY)
db_utils.create_access(share_id=share['id'],
state=constants.ACCESS_STATE_QUEUED_TO_DENY)
mock_debug_log = self.mock_object(access.LOG, 'debug')
self.mock_object(self.access_helper, '_update_access_rules')
get_and_update_call = self.mock_object(
self.access_helper, 'get_and_update_share_instance_access_rules',
mock.Mock(side_effect=self.access_helper.
get_and_update_share_instance_access_rules))
retval = self.access_helper.update_access_rules(
self.context,
share_instance['id'],
delete_all_rules=delete_all_rules)
expected_rule_filter_1 = {
'state':
(constants.ACCESS_STATE_APPLYING, constants.ACCESS_STATE_DENYING),
}
expected_rule_filter_2 = {
'state': (constants.ACCESS_STATE_QUEUED_TO_APPLY,
constants.ACCESS_STATE_QUEUED_TO_DENY),
}
expected_conditionally_change = {
constants.ACCESS_STATE_QUEUED_TO_APPLY:
constants.ACCESS_STATE_APPLYING,
constants.ACCESS_STATE_QUEUED_TO_DENY:
constants.ACCESS_STATE_DENYING,
}
expected_get_and_update_calls = []
if delete_all_rules:
deny_all_updates = {
'state': constants.ACCESS_STATE_QUEUED_TO_DENY,
}
expected_get_and_update_calls = [
mock.call(self.context,
updates=deny_all_updates,
share_instance_id=share_instance['id']),
]
expected_get_and_update_calls.extend([
mock.call(self.context,
filters=expected_rule_filter_1,
share_instance_id=share_instance['id']),
mock.call(self.context,
filters=expected_rule_filter_2,
share_instance_id=share_instance['id'],
conditionally_change=expected_conditionally_change),
])
self.assertIsNone(retval)
mock_debug_log.assert_called_once()
get_and_update_call.assert_has_calls(expected_get_and_update_calls)
self.access_helper._update_access_rules.assert_called_once_with(
self.context, share_instance['id'], share_server=None)
def test_allow_access_share_without_mount_snap_support(self):
share = db_utils.create_share(mount_snapshot_support=False)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
access = {
'id': 'fake_id',
'access_type': 'ip',
'access_to': '1.1.1.1',
'state': 'new',
}
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
get = self.mock_object(share_api.API, 'get',
mock.Mock(return_value=share))
body = {'allow_access': access}
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.allow_access, req,
snapshot['id'], body)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
def test_get_and_update_access_rules_status_conditionally_change(
self, initial_status, change_allowed):
share = db_utils.create_share(access_rules_status=initial_status,
status=constants.STATUS_AVAILABLE)
share = db.share_get(self.context, share['id'])
self.assertEqual(initial_status, share['access_rules_status'])
conditionally_change = {
constants.SHARE_INSTANCE_RULES_SYNCING: constants.STATUS_ACTIVE,
}
updated_instance = (self.access_helper.
get_and_update_share_instance_access_rules_status(
self.context,
conditionally_change=conditionally_change,
share_instance_id=share['instance']['id']))
share = db.share_get(self.context, share['id'])
if change_allowed:
self.assertEqual(constants.STATUS_ACTIVE,
share['access_rules_status'])
self.assertIsNotNone(updated_instance)
else:
self.assertEqual(initial_status, share['access_rules_status'])
self.assertIsNone(updated_instance)
def test_deny_access_access_rule_not_found(self):
share = db_utils.create_share(mount_snapshot_support=True)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
access = db_utils.create_snapshot_access(
share_snapshot_id=snapshot['id'])
wrong_access = {
'access_type': 'fake_type',
'access_to': 'fake_IP',
'share_snapshot_id': 'fake_id'
}
get = self.mock_object(share_api.API, 'get',
mock.Mock(return_value=share))
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
access_get = self.mock_object(share_api.API, 'snapshot_access_get',
mock.Mock(return_value=wrong_access))
body = {'deny_access': {'access_id': access.id}}
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.deny_access, req, snapshot['id'],
body)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
access_get.assert_called_once_with(
utils.IsAMatcher(context.RequestContext),
body['deny_access']['access_id'])
def setUp(self):
super(DataManagerTestCase, self).setUp()
self.manager = manager.DataManager()
self.context = context.get_admin_context()
self.topic = 'fake_topic'
self.share = db_utils.create_share()
manager.CONF.set_default('migration_tmp_location', '/tmp/')
def test_allow_access_exists_exception(self):
share = db_utils.create_share(mount_snapshot_support=True)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
access = {
'id': 'fake_id',
'access_type': 'ip',
'access_to': '1.1.1.1',
'state': 'new',
}
msg = "Share snapshot access exists."
get = self.mock_object(share_api.API, 'get', mock.Mock(
return_value=share))
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
allow_access = self.mock_object(
share_api.API, 'snapshot_allow_access', mock.Mock(
side_effect=exception.ShareSnapshotAccessExists(msg)))
body = {'allow_access': access}
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.allow_access, req,
snapshot['id'], body)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
allow_access.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot,
access['access_type'], access['access_to'])
def setUp(self):
super(DataRpcAPITestCase, self).setUp()
share = db_utils.create_share(
availability_zone=CONF.storage_availability_zone,
status=constants.STATUS_AVAILABLE
)
self.fake_share = jsonutils.to_primitive(share)
def test_deny_access(self):
share = db_utils.create_share(mount_snapshot_support=True)
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
access = db_utils.create_snapshot_access(
share_snapshot_id=snapshot['id'])
get = self.mock_object(share_api.API, 'get',
mock.Mock(return_value=share))
get_snapshot = self.mock_object(share_api.API, 'get_snapshot',
mock.Mock(return_value=snapshot))
access_get = self.mock_object(share_api.API, 'snapshot_access_get',
mock.Mock(return_value=access))
deny_access = self.mock_object(share_api.API, 'snapshot_deny_access')
body = {'deny_access': {'access_id': access.id}}
req = fakes.HTTPRequest.blank('/snapshots/%s/action' % snapshot['id'],
version='2.32')
resp = self.controller.deny_access(req, snapshot['id'], body)
self.assertEqual(202, resp.status_int)
get.assert_called_once_with(utils.IsAMatcher(context.RequestContext),
share['id'])
get_snapshot.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot['id'])
access_get.assert_called_once_with(
utils.IsAMatcher(context.RequestContext),
body['deny_access']['access_id'])
deny_access.assert_called_once_with(
utils.IsAMatcher(context.RequestContext), snapshot, access)
def test_get_and_update_all_access_rules_updates_conditionally_changed(
self, statuses, changes_allowed):
share = db_utils.create_share(status=constants.STATUS_AVAILABLE)
db_utils.create_access(share_id=share['id'], state=statuses[0])
db_utils.create_access(share_id=share['id'], state=statuses[-1])
self.mock_object(db, 'share_instance_access_update', mock.Mock(
side_effect=db.share_instance_access_update))
updates = {
'access_key': 'renfrow2stars'
}
expected_updates = {
'access_key': 'renfrow2stars',
'state': constants.ACCESS_STATE_QUEUED_TO_DENY,
}
conditionally_change = {
constants.ACCESS_STATE_APPLYING:
constants.ACCESS_STATE_QUEUED_TO_DENY,
constants.ACCESS_STATE_QUEUED_TO_APPLY:
constants.ACCESS_STATE_QUEUED_TO_DENY,
}
rules = self.access_helper.get_and_update_share_instance_access_rules(
self.context, share_instance_id=share['instance']['id'],
updates=updates, conditionally_change=conditionally_change)
state_changed_rules = [
r for r in rules if
r['state'] == constants.ACCESS_STATE_QUEUED_TO_DENY
]
self.assertEqual(changes_allowed, len(state_changed_rules))
self.assertEqual(2, db.share_instance_access_update.call_count)
db.share_instance_access_update.assert_has_calls([
mock.call(self.context, mock.ANY, share['instance']['id'],
expected_updates),
] * changes_allowed)
def test_share_instance_delete_with_share(self):
share = db_utils.create_share()
db_api.share_instance_delete(self.ctxt, share.instance['id'])
self.assertRaises(exception.NotFound, db_api.share_get,
self.ctxt, share['id'])
def test_migrate_share_to_host_exception(self, exc):
share = db_utils.create_share(status=constants.STATUS_MIGRATING)
host = 'fake@backend#pool'
request_spec = {'share_id': share['id']}
self.mock_object(db, 'share_get', mock.Mock(return_value=share))
self.mock_object(
base.Scheduler, 'host_passes_filters',
mock.Mock(side_effect=exc))
self.mock_object(db, 'share_update')
self.mock_object(db, 'share_instance_update')
capture = (exception.NoValidHost if
isinstance(exc, exception.NoValidHost) else TypeError)
self.assertRaises(
capture, self.manager.migrate_share_to_host,
self.context, share['id'], host, False, True, True, False, True,
'fake_net_id', 'fake_type_id', request_spec, None)
base.Scheduler.host_passes_filters.assert_called_once_with(
self.context, host, request_spec, None)
db.share_get.assert_called_once_with(self.context, share['id'])
db.share_update.assert_called_once_with(
self.context, share['id'],
{'task_state': constants.TASK_STATE_MIGRATION_ERROR})
db.share_instance_update.assert_called_once_with(
self.context, share.instance['id'],
{'status': constants.STATUS_AVAILABLE})
def setUp(self):
super(DataRpcAPITestCase, self).setUp()
self.context = context.get_admin_context()
share = db_utils.create_share(
availability_zone=CONF.storage_availability_zone,
status=constants.STATUS_AVAILABLE)
self.fake_share = jsonutils.to_primitive(share)
def test_migrate_share_to_host(self):
class fake_host(object):
host = 'fake@backend#pool'
share = db_utils.create_share()
host = fake_host()
self.mock_object(db, 'share_get', mock.Mock(return_value=share))
self.mock_object(share_rpcapi.ShareAPI, 'migration_start',
mock.Mock(side_effect=TypeError))
self.mock_object(base.Scheduler,
'host_passes_filters',
mock.Mock(return_value=host))
self.assertRaises(
TypeError, self.manager.migrate_share_to_host,
self.context, share['id'], 'fake@backend#pool', False, True, True,
False, True, 'fake_net_id', 'fake_type_id', {}, None)
db.share_get.assert_called_once_with(self.context, share['id'])
base.Scheduler.host_passes_filters.assert_called_once_with(
self.context, 'fake@backend#pool', {}, None)
share_rpcapi.ShareAPI.migration_start.assert_called_once_with(
self.context, share, host.host, False, True, True, False, True,
'fake_net_id', 'fake_type_id')
def test_show(self):
test_instance = db_utils.create_share(size=1).instance
id = test_instance["id"]
actual_result = self.controller.show(self._get_request("fake"), id)
self.assertEqual(id, actual_result["share_instance"]["id"])
self.mock_policy_check.assert_called_once_with(self.admin_context, self.resource_name, "show")
def _setup_snapshot_data(self, snapshot=None, version='2.7'):
if snapshot is None:
share = db_utils.create_share()
snapshot = db_utils.create_snapshot(
status=constants.STATUS_AVAILABLE, share_id=share['id'])
req = fakes.HTTPRequest.blank('/v2/fake/snapshots/%s/action' %
snapshot['id'], version=version)
return snapshot, req