def test_create_exception_path(self, exception_type):
fake_replica, _ = self._get_fake_replica(replication_type='writable')
mock__view_builder_call = self.mock_object(
share_replicas.replication_view.ReplicationViewBuilder,
'detail_list')
share_network = db_utils.create_share_network()
body = {
'share_replica': {
'share_id': 'FAKE_SHAREID',
'availability_zone': 'FAKE_AZ'
}
}
exc_args = {'id': 'xyz', 'reason': 'abc'}
self.mock_object(share_replicas.db, 'share_get',
mock.Mock(return_value=fake_replica))
self.mock_object(share.API, 'create_share_replica',
mock.Mock(side_effect=exception_type(**exc_args)))
self.mock_object(share_replicas.db, 'share_network_get',
mock.Mock(return_value=share_network))
self.mock_object(common, 'check_share_network_is_active',
mock.Mock(return_value=True))
self.assertRaises(exc.HTTPBadRequest, self.controller.create,
self.replicas_req, body)
self.assertFalse(mock__view_builder_call.called)
self.mock_policy_check.assert_called_once_with(self.member_context,
self.resource_name,
'create')
share_replicas.db.share_network_get.assert_called_once_with(
self.member_context, fake_replica['share_network_id'])
common.check_share_network_is_active.assert_called_once_with(
share_network)
def test_unmanage_share_server_network_not_active(self):
"""Tests unmanaging share servers"""
req = fakes.HTTPRequest.blank(
'/v2/share-servers/fake_server_id/', version="2.63")
context = req.environ['manila.context']
share_server = db_utils.create_share_server()
network_subnet = db_utils.create_share_network_subnet()
share_network = db_utils.create_share_network()
get_mock = self.mock_object(
db_api, 'share_server_get', mock.Mock(return_value=share_server))
get_subnet_mock = self.mock_object(
db_api, 'share_network_subnet_get',
mock.Mock(return_value=network_subnet))
get_network_mock = self.mock_object(
db_api, 'share_network_get',
mock.Mock(return_value=share_network))
is_active_mock = self.mock_object(
common, 'check_share_network_is_active',
mock.Mock(side_effect=webob.exc.HTTPBadRequest()))
body = {'unmanage': {'force': True}}
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.unmanage,
req,
'fake_server_id',
body)
get_mock.assert_called_once_with(context, 'fake_server_id')
get_subnet_mock.assert_called_once_with(
context, share_server.get('share_network_subnet_id'))
get_network_mock.assert_called_once_with(
context, network_subnet['share_network_id'])
is_active_mock.assert_called_once_with(share_network)
def test_manage_invalid(self):
req = fakes.HTTPRequest.blank('/manage_share_server',
use_admin_context=True,
version="2.49")
context = req.environ['manila.context']
share_network = db_utils.create_share_network()
share_net_subnet = db_utils.create_share_network_subnet(
share_network_id=share_network['id'])
body = {'share_server': self._setup_manage_test_request_body()}
self.mock_object(utils, 'validate_service_host')
self.mock_object(db_api, 'share_network_get',
mock.Mock(return_value=share_network))
self.mock_object(db_api, 'share_network_subnet_get_default_subnet',
mock.Mock(return_value=share_net_subnet))
manage_share_server_mock = self.mock_object(
share_api.API, 'manage_share_server',
mock.Mock(side_effect=exception.InvalidInput('foobar')))
self.assertRaises(webob.exc.HTTPBadRequest, self.controller.manage,
req, body)
req_params = body['share_server']
manage_share_server_mock.assert_called_once_with(
context, req_params['identifier'], req_params['host'],
share_net_subnet, req_params['driver_options'])
def test__validate_manage_share_server_validate_service_host(
self, exception_to_raise, side_effect_exception):
req = fakes.HTTPRequest.blank('/manage', version="2.49")
context = req.environ['manila.context']
error = mock.Mock(side_effect=side_effect_exception)
self.mock_object(utils, 'validate_service_host', error)
share_network = db_utils.create_share_network()
share_net_subnet = db_utils.create_share_network_subnet(
share_network_id=share_network['id'])
self.mock_object(db_api, 'share_network_get', mock.Mock(
return_value=share_network))
self.mock_object(db_api, 'share_network_subnet_get_default_subnet',
mock.Mock(return_value=share_net_subnet))
self.mock_object(common, 'check_share_network_is_active',
mock.Mock(return_value=True))
self.assertRaises(
exception_to_raise, self.controller.manage, req,
{'share_server': self._setup_manage_test_request_body()})
common.check_share_network_is_active.assert_called_once_with(
share_net_subnet['share_network'])
policy.check_policy.assert_called_once_with(
context, self.resource_name, 'manage_share_server')
def test_list_subnet(self):
share_network_id = 'fake_id'
subnet = db_utils.create_share_network_subnet(
share_network_id=share_network_id, id='fake_id')
fake_sn = db_utils.create_share_network(id=share_network_id)
expected_result = {
'share_network_subnets': [{
"created_at": subnet['created_at'],
"id": subnet['id'],
"share_network_id": subnet['id'],
"share_network_name": fake_sn["name"],
"availability_zone": subnet['availability_zone'],
"segmentation_id": subnet['segmentation_id'],
"neutron_subnet_id": subnet['neutron_subnet_id'],
"updated_at": subnet['updated_at'],
"neutron_net_id": subnet['neutron_net_id'],
"ip_version": subnet['ip_version'],
"cidr": subnet['cidr'],
"network_type": subnet['network_type'],
"gateway": subnet['gateway'],
"mtu": subnet['mtu'],
}]
}
req = fakes.HTTPRequest.blank('/subnets/', version="2.51")
context = req.environ['manila.context']
mock_sn_get = self.mock_object(
db_api, 'share_network_get', mock.Mock(
return_value=fake_sn))
result = self.controller.index(req, self.share_network['id'])
self.assertEqual(expected_result, result)
mock_sn_get.assert_called_once_with(context, self.share_network['id'])
def test__validate_manage_share_server_error_subnet_not_found(
self, body_contains_subnet):
req = fakes.HTTPRequest.blank('/manage', version="2.51")
context = req.environ['manila.context']
share_network = db_utils.create_share_network()
body = {'share_server': self._setup_manage_test_request_body()}
share_net_subnet = db_utils.create_share_network_subnet(
share_network_id=share_network['id'])
body['share_server']['share_network_subnet_id'] = (
share_net_subnet['id'] if body_contains_subnet else None)
self.mock_object(
db_api, 'share_network_subnet_get',
mock.Mock(side_effect=exception.ShareNetworkSubnetNotFound(
share_network_subnet_id='fake')))
self.mock_object(db_api, 'share_network_subnet_get_default_subnet',
mock.Mock(return_value=None))
self.assertRaises(webob.exc.HTTPBadRequest, self.controller.manage,
req, body)
policy.check_policy.assert_called_once_with(context,
self.resource_name,
'manage_share_server')
if body_contains_subnet:
db_api.share_network_subnet_get.assert_called_once_with(
context, share_net_subnet['id'])
else:
(db_api.share_network_subnet_get_default_subnet.
assert_called_once_with(context,
body['share_server']['share_network_id']))
def test_share_server_migration_check(self):
fake_id = 'fake_server_id'
fake_share_server = db_utils.create_share_server(id=fake_id)
fake_share_network = db_utils.create_share_network()
req = self._get_server_migration_request(fake_id)
context = req.environ['manila.context']
requested_writable = False
requested_nondisruptive = False
requested_preserve_snapshots = False
fake_host = 'fakehost@fakebackend'
body = {
'migration_check': {
'writable': requested_writable,
'nondisruptive': requested_nondisruptive,
'preserve_snapshots': requested_preserve_snapshots,
'new_share_network_id': fake_share_network['id'],
'host': fake_host
}
}
driver_result = {
'compatible': False,
'writable': False,
'nondisruptive': True,
'preserve_snapshots': False,
'share_network_id': 'fake_network_uuid',
'migration_cancel': False,
'migration_get_progress': False,
}
mock_server_get = self.mock_object(
db_api, 'share_server_get',
mock.Mock(return_value=fake_share_server))
mock_network_get = self.mock_object(
db_api, 'share_network_get',
mock.Mock(return_value=fake_share_network))
mock_migration_check = self.mock_object(
share_api.API, 'share_server_migration_check',
mock.Mock(return_value=driver_result))
result = self.controller.share_server_migration_check(
req, fake_id, body)
expected_result_keys = [
'compatible', 'requested_capabilities', 'supported_capabilities'
]
[self.assertIn(key, result) for key in expected_result_keys]
mock_server_get.assert_called_once_with(context,
fake_share_server['id'])
mock_network_get.assert_called_once_with(context,
fake_share_network['id'])
mock_migration_check.assert_called_once_with(
context,
fake_share_server,
fake_host,
requested_writable,
requested_nondisruptive,
requested_preserve_snapshots,
new_share_network=fake_share_network)
def test_manage(self, share_net_name):
"""Tests share server manage"""
req = fakes.HTTPRequest.blank('/v2/share-servers/',
use_admin_context=True,
version="2.49")
context = req.environ['manila.context']
share_network = db_utils.create_share_network(name=share_net_name)
share_server = db_utils.create_share_server(
share_network_id=share_network['id'],
host='fake_host',
identifier='fake_identifier',
is_auto_deletable=False)
self.mock_object(db_api, 'share_network_get', mock.Mock(
return_value=share_network))
self.mock_object(utils, 'validate_service_host')
body = {
'share_server': self._setup_manage_test_request_body()
}
manage_share_server_mock = self.mock_object(
share_api.API, 'manage_share_server',
mock.Mock(return_value=share_server))
result = self.controller.manage(req, body)
expected_result = {
'share_server': {
'id': share_server['id'],
'project_id': 'fake',
'updated_at': None,
'status': constants.STATUS_ACTIVE,
'host': 'fake_host',
'share_network_id': share_server['share_network_id'],
'created_at': share_server['created_at'],
'backend_details': {},
'identifier': share_server['identifier'],
'is_auto_deletable': share_server['is_auto_deletable'],
}
}
if share_net_name != '':
expected_result['share_server']['share_network_name'] = (
'fake_net_name')
else:
expected_result['share_server']['share_network_name'] = (
share_server['share_network_id'])
req_params = body['share_server']
manage_share_server_mock.assert_called_once_with(
context, req_params['identifier'], req_params['host'],
share_network, req_params['driver_options'])
self.assertEqual(expected_result, result)
self.mock_policy_check.assert_called_once_with(
context, self.resource_name, 'manage_share_server')
def test_manage(self, share_net_name):
"""Tests share server manage"""
req = fakes.HTTPRequest.blank('/v2/share-servers/',
use_admin_context=True,
version="2.49")
context = req.environ['manila.context']
share_network = db_utils.create_share_network(name=share_net_name)
share_server = db_utils.create_share_server(
share_network_id=share_network['id'],
host='fake_host',
identifier='fake_identifier',
is_auto_deletable=False)
self.mock_object(db_api, 'share_network_get',
mock.Mock(return_value=share_network))
self.mock_object(utils, 'validate_service_host')
body = {'share_server': self._setup_manage_test_request_body()}
manage_share_server_mock = self.mock_object(
share_api.API, 'manage_share_server',
mock.Mock(return_value=share_server))
result = self.controller.manage(req, body)
expected_result = {
'share_server': {
'id': share_server['id'],
'project_id': 'fake',
'updated_at': None,
'status': constants.STATUS_ACTIVE,
'host': 'fake_host',
'share_network_id': share_server['share_network_id'],
'created_at': share_server['created_at'],
'backend_details': {},
'identifier': share_server['identifier'],
'is_auto_deletable': share_server['is_auto_deletable'],
}
}
if share_net_name != '':
expected_result['share_server']['share_network_name'] = (
'fake_net_name')
else:
expected_result['share_server']['share_network_name'] = (
share_server['share_network_id'])
req_params = body['share_server']
manage_share_server_mock.assert_called_once_with(
context, req_params['identifier'], req_params['host'],
share_network, req_params['driver_options'])
self.assertEqual(expected_result, result)
self.mock_policy_check.assert_called_once_with(context,
self.resource_name,
'manage_share_server')
def test_share_filter_all_by_share_server(self):
share_network = db_utils.create_share_network()
share_server = db_utils.create_share_server(
share_network_id=share_network['id'])
share = db_utils.create_share(share_server_id=share_server['id'],
share_network_id=share_network['id'])
actual_result = db_api.share_get_all_by_share_server(
self.ctxt, share_server['id'])
self.assertEqual(1, len(actual_result))
self.assertEqual(share['id'], actual_result[0].id)
def _setup_unmanage_tests(self, status=constants.STATUS_ACTIVE):
server = db_utils.create_share_server(
id='fake_server_id', status=status)
share_network = db_utils.create_share_network()
network_subnet = db_utils.create_share_network_subnet(
share_network_id=share_network['id'])
self.mock_object(db_api, 'share_server_get',
mock.Mock(return_value=server))
self.mock_object(db_api, 'share_network_get',
mock.Mock(return_value=share_network))
self.mock_object(db_api, 'share_network_subnet_get',
mock.Mock(return_value=network_subnet))
return server
def setUp(self):
super(ShareNetworkSubnetControllerTest, self).setUp()
self.controller = share_network_subnets.ShareNetworkSubnetController()
self.mock_policy_check = self.mock_object(
policy, 'check_policy', mock.Mock(return_value=True))
self.resource_name = self.controller.resource_name
self.mock_az_get = self.mock_object(db_api, 'availability_zone_get',
mock.Mock(return_value=fake_az))
self.share_network = db_utils.create_share_network(
name='fake_network', id='fake_sn_id')
self.share_server = db_utils.create_share_server(
share_network_subnet_id='fake_sns_id')
self.subnet = db_utils.create_share_network_subnet(
share_network_id=self.share_network['id'])
self.share = db_utils.create_share()
def test_build_share_network_subnets(self):
req = fakes.HTTPRequest.blank('/subnets', version='2.51')
share_network = db_utils.create_share_network(
name='fake_network', id='fake_sn_id_1')
subnet = db_utils.create_share_network_subnet(
share_network_id=share_network['id'])
result = self.builder.build_share_network_subnets(req, [subnet])
self.assertIn('share_network_subnets', result)
self.assertEqual(1, len(result['share_network_subnets']))
subnet_list = result['share_network_subnets']
for subnet in subnet_list:
self._validate_is_detail_return(subnet)
def test_share_server_migration_start_conflict(self, api_exception,
expected_exception):
share_network = db_utils.create_share_network()
share_network_subnet = db_utils.create_share_network_subnet(
share_network_id=share_network['id'])
server = db_utils.create_share_server(
id='fake_server_id', status=constants.STATUS_ACTIVE,
share_network_subnet_id=share_network_subnet['id'])
req = self._get_server_migration_request(server['id'])
context = req.environ['manila.context']
body = {
'migration_start': {
'host': 'fake_host',
'preserve_snapshots': True,
'writable': True,
'nondisruptive': True,
}
}
self.mock_object(share_api.API, 'share_server_migration_start',
mock.Mock(side_effect=api_exception))
self.mock_object(db_api, 'share_server_get',
mock.Mock(return_value=server))
self.mock_object(common, 'check_share_network_is_active',
mock.Mock(return_value=True))
self.mock_object(db_api, 'share_network_get',
mock.Mock(return_value=share_network))
self.assertRaises(expected_exception,
self.controller.share_server_migration_start,
req, server['id'], body)
db_api.share_server_get.assert_called_once_with(context,
server['id'])
migration_start_params = body['migration_start']
common.check_share_network_is_active.assert_called_once_with(
share_network)
db_api.share_network_get.assert_called_once_with(
context, share_network['id'])
share_api.API.share_server_migration_start.assert_called_once_with(
context, server, migration_start_params['host'],
migration_start_params['writable'],
migration_start_params['nondisruptive'],
migration_start_params['preserve_snapshots'],
new_share_network=None)
def test_manage_forbidden(self):
"""Tests share server manage without admin privileges"""
req = fakes.HTTPRequest.blank('/manage_share_server', version="2.49")
error = mock.Mock(side_effect=exception.PolicyNotAuthorized(action=''))
self.mock_object(share_api.API, 'manage_share_server', error)
share_network = db_utils.create_share_network()
share_net_subnet = db_utils.create_share_network_subnet(
share_network_id=share_network['id'])
self.mock_object(db_api, 'share_network_get',
mock.Mock(return_value=share_network))
self.mock_object(db_api, 'share_network_subnet_get_default_subnet',
mock.Mock(return_value=share_net_subnet))
self.mock_object(utils, 'validate_service_host')
body = {'share_server': self._setup_manage_test_request_body()}
self.assertRaises(webob.exc.HTTPForbidden, self.controller.manage, req,
body)
def test_create(self, is_admin, microversion):
fake_replica, expected_replica = self._get_fake_replica(
replication_type='writable',
admin=is_admin,
microversion=microversion)
share_network = db_utils.create_share_network()
body = {
'share_replica': {
'share_id': 'FAKE_SHAREID',
'availability_zone': 'FAKE_AZ'
}
}
self.mock_object(share_replicas.db, 'share_get',
mock.Mock(return_value=fake_replica))
self.mock_object(share.API, 'create_share_replica',
mock.Mock(return_value=fake_replica))
self.mock_object(share_replicas.db,
'share_replicas_get_available_active_replica',
mock.Mock(return_value=[{
'id': 'active1'
}]))
self.mock_object(share_replicas.db, 'share_network_get',
mock.Mock(return_value=share_network))
self.mock_object(common, 'check_share_network_is_active',
mock.Mock(return_value=True))
req = self._get_request(microversion, is_admin)
req_context = req.environ['manila.context']
res_dict = self.controller.create(req, body)
self.assertEqual(expected_replica, res_dict['share_replica'])
self.mock_policy_check.assert_called_once_with(req_context,
self.resource_name,
'create')
share_replicas.db.share_network_get.assert_called_once_with(
req_context, fake_replica['share_network_id'])
common.check_share_network_is_active.assert_called_once_with(
share_network)
def test_share_server_migration_start(self):
server = db_utils.create_share_server(id='fake_server_id',
status=constants.STATUS_ACTIVE)
share_network = db_utils.create_share_network()
req = self._get_server_migration_request(server['id'])
context = req.environ['manila.context']
self.mock_object(db_api, 'share_network_get', mock.Mock(
return_value=share_network))
self.mock_object(db_api, 'share_server_get',
mock.Mock(return_value=server))
self.mock_object(common, 'check_share_network_is_active',
mock.Mock(return_value=True))
self.mock_object(share_api.API, 'share_server_migration_start')
body = {
'migration_start': {
'host': 'fake_host',
'preserve_snapshots': True,
'writable': True,
'nondisruptive': True,
'new_share_network_id': 'fake_net_id',
}
}
self.controller.share_server_migration_start(req, server['id'], body)
db_api.share_server_get.assert_called_once_with(
context, server['id'])
share_api.API.share_server_migration_start.assert_called_once_with(
context, server, 'fake_host', True, True, True,
new_share_network=share_network)
db_api.share_network_get.assert_called_once_with(
context, 'fake_net_id')
common.check_share_network_is_active.assert_called_once_with(
share_network)
def test_manage_invalid(self):
req = fakes.HTTPRequest.blank('/manage_share_server',
use_admin_context=True)
context = req.environ['manila.context']
share_network = db_utils.create_share_network()
body = {
'share_server': self._setup_manage_test_request_body()
}
self.mock_object(utils, 'validate_service_host')
self.mock_object(db_api, 'share_network_get',
mock.Mock(return_value=share_network))
manage_share_server_mock = self.mock_object(
share_api.API, 'manage_share_server',
mock.Mock(side_effect=exception.InvalidInput('foobar')))
self.assertRaises(webob.exc.HTTPBadRequest,
self.controller.manage, req, body)
req_params = body['share_server']
manage_share_server_mock.assert_called_once_with(
context, req_params['identifier'], req_params['host'],
share_network, req_params['driver_options'])
def setUp(self):
super(ViewBuilderTestCase, self).setUp()
self.builder = share_network_subnets.ViewBuilder()
self.share_network = db_utils.create_share_network(
name='fake_network', id='fake_sn_id')
