385b4b7723
add_tenants logic:
a) allow add tenant only if flavor already assigned to region(s)
b) each tenant in the request will be validated against the
regions assigned to flavor - at least ONE tenant must
pass validation:
i. if NO tenant in tenant list is associated with any of the
regions assigned to the flavor, Ranger will reject the
request entirely and user will be prompted to submit new
request with valid tenants.
ii. only the tenants in tenant list that pass validation will
be kept in flavor tenant list; those that failed
validation will be DROPPED from the tenant list.
delete_region logic (only for flavors with tenants):
a) if a tenant is associated only with the deleted region, the
delete_region logic will delete the tenant from fms table
and the tenant is dropped from the tenant list.
However, if the tenant is associated with other regions still
assigned to the flavor, the tenant stays in the list.
Change-Id: I31935477733c8597741cf7c7c57350ab1e2b4452
771 lines
30 KiB
Python
Executable File
771 lines
30 KiB
Python
Executable File
from orm.common.orm_common.injector import injector
|
|
from orm.common.orm_common.utils import utils
|
|
from orm.services.flavor_manager.fms_rest.data.sql_alchemy import db_models
|
|
from orm.services.flavor_manager.fms_rest.data.wsme import models
|
|
from orm.services.flavor_manager.fms_rest.data.wsme.models import *
|
|
from orm.services.flavor_manager.fms_rest.logic.error_base import NotFoundError
|
|
from orm.services.flavor_manager.fms_rest.logic import flavor_logic
|
|
from orm.tests.unit.fms import FunctionalTest
|
|
|
|
from sqlalchemy.orm import exc
|
|
from mock import MagicMock, patch
|
|
|
|
from oslo_config import cfg
|
|
|
|
|
|
class OES():
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def to_db_model(self):
|
|
return None
|
|
|
|
|
|
error = None
|
|
FLAVOR_MOCK = None
|
|
|
|
|
|
class TestFlavorLogic(FunctionalTest):
|
|
def setUp(self):
|
|
FunctionalTest.setUp(self)
|
|
|
|
global FLAVOR_MOCK
|
|
FLAVOR_MOCK = MagicMock()
|
|
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
injector.override_injected_dependency(('rds_proxy', rds_proxy_mock))
|
|
|
|
def tearDown(self):
|
|
global error
|
|
error = None
|
|
FunctionalTest.tearDown(self)
|
|
|
|
@patch.object(flavor_logic, 'FlavorWrapper')
|
|
def test_create_flavor_duplicate_entry(self, mock_flavorwrapper):
|
|
mock_flavorwrapper.from_db_model.return_value = get_flavor_mock()
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
flavor = get_flavor_mock()
|
|
flavor.flavor.validate_model = MagicMock(
|
|
side_effect=flavor_logic.ErrorStatus(409, 'Duplicate entry'))
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.create_flavor,
|
|
flavor, 'uuid', 'transaction')
|
|
|
|
@patch.object(flavor_logic, 'validate_tenants_regions_list')
|
|
@patch.object(flavor_logic, 'FlavorWrapper')
|
|
def test_create_flavor_success(self, mock_flavorwrapper, mock_validate):
|
|
mock_flavorwrapper.from_db_model.return_value = get_flavor_mock()
|
|
|
|
# Flavor is public - test success
|
|
flavor = get_flavor_mock()
|
|
flavor.flavor.visibility = 'public'
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
res_flavor = flavor_logic.create_flavor(flavor, 'uuid',
|
|
'transaction')
|
|
mock_validate.assert_not_called()
|
|
self.assertEqual(res_flavor.flavor.profile, 'N1')
|
|
self.assertEqual(res_flavor.flavor.ram, '1024')
|
|
self.assertEqual(res_flavor.flavor.vcpus, '1')
|
|
self.assertEqual(res_flavor.flavor.series, cfg.CONF.fms.flavor_series[0])
|
|
self.assertEqual(res_flavor.flavor.id, 'g')
|
|
|
|
# Test that flavor validate model works by passing bad swap value
|
|
flavor = get_flavor_mock()
|
|
flavor.flavor.swap = '1024000'
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.create_flavor,
|
|
flavor, 'uuid', 'transaction')
|
|
|
|
# Flavor is private - test success
|
|
flavor.flavor.validate_model = MagicMock()
|
|
flavor.flavor.visibility = 'private'
|
|
flavor.flavor.tenants = ['1234']
|
|
flavor.flavor.regions = [Region(name='test_region')]
|
|
mock_validate.return_value = [['1234'], ['rgn1']]
|
|
|
|
res_flavor = flavor_logic.create_flavor(flavor, 'uuid',
|
|
'transaction')
|
|
mock_validate.assert_called()
|
|
self.assertEqual(res_flavor.flavor.profile, 'N1')
|
|
self.assertEqual(res_flavor.flavor.ram, '1024')
|
|
self.assertEqual(res_flavor.flavor.vcpus, '1')
|
|
self.assertEqual(res_flavor.flavor.series, cfg.CONF.fms.flavor_series[0])
|
|
self.assertEqual(res_flavor.flavor.id, 'g')
|
|
|
|
#
|
|
# def test_get_flavor_by_uuid_check_statuses_ok(self):
|
|
# flavor_logic.get_flavor_by_uuid("SampleUUId")
|
|
|
|
@patch.object(flavor_logic, 'ExtraSpecsWrapper', return_value=MagicMock())
|
|
def test_get_extra_specs_success(self, extra_spec_wrapper):
|
|
global error
|
|
error = 3
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
extra_spec_wrapper.from_db_model.return_value = {"key", "value"}
|
|
result = flavor_logic.get_extra_specs_uuid(123, "transaction_id")
|
|
self.assertEqual({"key", "value"}, result)
|
|
|
|
@patch.object(flavor_logic, 'ExtraSpecsWrapper', return_value=MagicMock())
|
|
def test_get_extra_specs_not_found(self, extra_spec_wrapper):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(flavor_logic.NotFoundError):
|
|
flavor_logic.get_extra_specs_uuid(123, "transaction_id")
|
|
|
|
@patch.object(flavor_logic, 'ExtraSpecsWrapper', return_value=MagicMock())
|
|
def test_get_extra_specs_general_error(self, extra_spec_wrapper):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(Exception) as cm:
|
|
flavor_logic.get_extra_specs_uuid(123, "transaction_id")
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed', return_value=True)
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
def test_delete_extra_specs_success(self, mock_flavorwrapper,
|
|
mock_send_rds):
|
|
flavor_logic.delete_extra_specs(123, "transaction_id")
|
|
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
def test_delete_extra_specs_not_found(self, mock_flavorwrapper):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(flavor_logic.NotFoundError):
|
|
flavor_logic.delete_extra_specs(123, "transaction_id")
|
|
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
def test_delete_extra_specs_bad_req(self, mock_flavorwrapper):
|
|
global error
|
|
error = 3
|
|
extra_spec_needed = db_models.FlavorExtraSpec("key1", "value")
|
|
get_extra_spec_needed = MagicMock()
|
|
get_extra_spec_needed.get_extra_spec_needed.return_value = [extra_spec_needed]
|
|
mock_flavorwrapper.from_db_model.return_value = get_extra_spec_needed
|
|
with self.assertRaises(ErrorStatus):
|
|
flavor_logic.delete_extra_specs(123, "transaction_id", "key1")
|
|
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
def test_delete_extra_specs_one(self, mock_flavorwrapper):
|
|
global error
|
|
error = 3
|
|
extra_spec_needed = db_models.FlavorExtraSpec("key1", "value")
|
|
get_extra_spec_needed = MagicMock()
|
|
get_extra_spec_needed.get_extra_spec_needed.return_value = [
|
|
extra_spec_needed]
|
|
mock_flavorwrapper.from_db_model.return_value = get_extra_spec_needed
|
|
flavor_logic.delete_extra_specs(123, "transaction_id", "key2")
|
|
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
def test_delete_extra_specs_general_error(self, mock_flavorwrapper):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(Exception) as cm:
|
|
flavor_logic.delete_extra_specs(123, "transaction_id")
|
|
|
|
@patch.object(flavor_logic.ExtraSpecsWrapper, 'from_db_model',
|
|
return_value=True)
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed', return_value=True)
|
|
def test_add_extra_specs_success(self, mock_send_rds, extra_specs_wrapper):
|
|
flavor_logic.add_extra_specs(123, OES(), "transaction_id")
|
|
|
|
def test_add_extra_specs_not_found(self):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(flavor_logic.NotFoundError):
|
|
flavor_logic.add_extra_specs(123, OES(), "transaction_id")
|
|
|
|
def test_add_extra_specs_gen_exp(self):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(Exception):
|
|
flavor_logic.add_extra_specs(123, OES(), "transaction_id")
|
|
|
|
@patch.object(flavor_logic.ExtraSpecsWrapper, 'from_db_model')
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed', return_value=True)
|
|
def test_update_extra_specs_success(self, mock_send_rds,
|
|
flavor_wrapper,
|
|
extra_specs_wrapper):
|
|
extra_specs_wrapper.return_value = extra_specs_json
|
|
result = flavor_logic.update_extra_specs(123, OES(), "transaction_id")
|
|
self.assertEqual(result, extra_specs_json)
|
|
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed', return_value=True)
|
|
def test_update_extra_specs_not_found(self, mock_send_rds,
|
|
extra_specs_wrapper):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(flavor_logic.NotFoundError):
|
|
flavor_logic.update_extra_specs(123, OES(), "transaction_id")
|
|
|
|
@patch.object(flavor_logic, 'FlavorWrapper', return_value=MagicMock())
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed', return_value=True)
|
|
def test_update_extra_specs_any_except(self, mock_send_rds,
|
|
extra_specs_wrapper):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(
|
|
('flavor_logic', get_datamanager_mock()))
|
|
with self.assertRaises(Exception):
|
|
flavor_logic.update_extra_specs(123, OES(), "transaction_id")
|
|
|
|
def test_add_tags_success(self):
|
|
global error
|
|
error = 0
|
|
datamanager = get_datamanager_mock()
|
|
injector.override_injected_dependency(('data_manager', datamanager))
|
|
|
|
tag = TagsWrapper(tags={'a': 'b'})
|
|
ret = flavor_logic.add_tags('some_id', tag, 'trans_id')
|
|
|
|
assert datamanager.return_value.commit.called
|
|
|
|
def test_add_tags_not_found(self):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
|
|
self.assertRaises(NotFoundError, flavor_logic.add_tags, 'a', None, 'a')
|
|
|
|
def test_add_tags_error(self):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
|
|
self.assertRaises(Exception, flavor_logic.add_tags, 'a', None, 'a')
|
|
|
|
@patch.object(flavor_logic.FlavorWrapper, 'from_db_model')
|
|
def test_get_tags_success(self, mock_from_db_model):
|
|
my_flavor = MagicMock()
|
|
my_flavor.flavor.tag = {'test': 'A'}
|
|
mock_from_db_model.return_value = my_flavor
|
|
|
|
global error
|
|
error = 4
|
|
injector.override_injected_dependency(('data_manager',
|
|
get_datamanager_mock))
|
|
|
|
ret = flavor_logic.get_tags('some_id')
|
|
|
|
self.assertEqual(ret, my_flavor.flavor.tag)
|
|
|
|
def test_get_tags_not_found(self):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(('data_manager',
|
|
get_datamanager_mock))
|
|
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.get_tags,
|
|
'some_id')
|
|
|
|
def test_get_tags_error(self):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(('data_manager',
|
|
get_datamanager_mock))
|
|
|
|
self.assertRaises(SystemError, flavor_logic.get_tags, 'some_id')
|
|
|
|
def test_update_tags_success(self):
|
|
global error
|
|
error = 0
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
tag = TagsWrapper(tags={'a': 'b'})
|
|
ret = flavor_logic.update_tags('some_id', tag, 'trans_id')
|
|
|
|
self.assertEqual(ret.tags, tag.tags)
|
|
|
|
def test_update_tags_not_found(self):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
|
|
self.assertRaises(NotFoundError, flavor_logic.update_tags, '', None, '')
|
|
|
|
def test_update_tags_error(self):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
|
|
self.assertRaises(Exception, flavor_logic.update_tags, 'a', None, 'a')
|
|
|
|
def test_delete_tags_success(self):
|
|
tag = TagsWrapper(tags={'a': 'b'})
|
|
flavor_logic.delete_tags('some_id', tag, 'trans_id')
|
|
|
|
def test_delete_all_tags_success(self):
|
|
flavor_logic.delete_tags('some_id', None, 'trans_id')
|
|
|
|
def test_delete_tags_not_found(self):
|
|
global error
|
|
error = 6
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
|
|
# Even when the tag was not found, an exception shouldn't be raised
|
|
flavor_logic.delete_tags('some_id', None, 'trans_id')
|
|
|
|
error = 7
|
|
self.assertRaises(flavor_logic.NotFoundError, flavor_logic.delete_tags,
|
|
'some_id', None, 'trans_id')
|
|
|
|
error = 8
|
|
# assertRaise ErrorStatus on delete_tags when tag not found
|
|
with self.assertRaises(flavor_logic.ErrorStatus):
|
|
flavor_logic.delete_tags('some_id', None, 'trans_id')
|
|
|
|
def test_delete_tags_error(self):
|
|
global error
|
|
error = 2
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
|
|
self.assertRaises(Exception, flavor_logic.delete_tags, 'a', None, 'a')
|
|
|
|
error = 9
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.delete_tags,
|
|
'a', None, 'a')
|
|
|
|
@patch.object(utils, 'get_resource_status_from_db')
|
|
def test_delete_flavor_by_uuid_success(self, mock_get_resource):
|
|
global error
|
|
error = 10
|
|
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
|
|
status_model = MagicMock()
|
|
|
|
# status model has success status
|
|
status_model.status = 'Success'
|
|
resource_status_dict = {'some_id': status_model}
|
|
mock_get_resource.return_value = resource_status_dict
|
|
flavor_logic.delete_flavor_by_uuid('some_uuid')
|
|
|
|
# status model not found
|
|
resource_status_dict = {}
|
|
mock_get_resource.return_value = resource_status_dict
|
|
flavor_logic.delete_flavor_by_uuid('some_id')
|
|
|
|
@patch.object(utils, 'get_resource_status_from_db')
|
|
def test_delete_flavor_by_uuid_bad_status(self, mock_get_resource):
|
|
global error
|
|
error = 10
|
|
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
|
|
status_model = MagicMock()
|
|
|
|
# status model has error status
|
|
status_model.status = 'Error'
|
|
resource_status_dict = {'some_id': status_model}
|
|
mock_get_resource.return_value = resource_status_dict
|
|
|
|
try:
|
|
flavor_logic.delete_flavor_by_uuid('some_uuid')
|
|
self.fail('ErrorStatus not raised!')
|
|
except flavor_logic.ErrorStatus as e:
|
|
self.assertEqual(e.status_code, 409)
|
|
|
|
def test_delete_flavor_by_uuid_flavor_not_found(self):
|
|
global error
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
|
|
# assertRaises NotFoundError when deleting a flavor that doesn't exist
|
|
with self.assertRaises(flavor_logic.NotFoundError):
|
|
flavor_logic.delete_flavor_by_uuid('some_id')
|
|
|
|
def test_delete_flavor_by_uuid_flavor_has_regions(self):
|
|
global error
|
|
error = 3
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
|
|
try:
|
|
flavor_logic.delete_flavor_by_uuid('some_id')
|
|
self.fail('ErrorStatus not raised!')
|
|
except flavor_logic.ErrorStatus as e:
|
|
self.assertEqual(e.status_code, 405)
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
def test_add_regions_success(self, mock_gfbu, mock_strin):
|
|
ret_flavor = MagicMock()
|
|
ret_flavor.flavor.regions = [Region(name='test_region')]
|
|
mock_gfbu.return_value = ret_flavor
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
|
|
res_regions = flavor_logic.add_regions('uuid', RegionWrapper(
|
|
[Region(name='test_region')]), 'transaction')
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
def test_add_regions_errors(self, mock_gfbu, mock_strin):
|
|
ret_flavor = MagicMock()
|
|
ret_flavor.flavor.regions = [Region(name='test_region')]
|
|
mock_gfbu.return_value = ret_flavor
|
|
global error
|
|
|
|
error = 1
|
|
injector.override_injected_dependency(('data_manager', get_datamanager_mock))
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.add_regions,
|
|
'uuid', RegionWrapper([Region(name='test_region')]),
|
|
'transaction')
|
|
|
|
error = 4
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
|
|
mock_strin.side_effect = exc.FlushError()
|
|
self.assertRaises(exc.FlushError, flavor_logic.add_regions,
|
|
'uuid', RegionWrapper([Region(name='test_region')]),
|
|
'transaction')
|
|
mock_strin.side_effect = exc.FlushError(
|
|
'conflicts with persistent instance')
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.add_regions,
|
|
'uuid', RegionWrapper([Region(name='test_region')]),
|
|
'transaction')
|
|
mock_strin.side_effect = ValueError()
|
|
self.assertRaises(ValueError, flavor_logic.add_regions,
|
|
'uuid', RegionWrapper([Region(name='test_region')]),
|
|
'transaction')
|
|
mock_strin.side_effect = ValueError(
|
|
'conflicts with persistent instance')
|
|
self.assertRaises(flavor_logic.ConflictError, flavor_logic.add_regions,
|
|
'uuid', RegionWrapper([Region(name='test_region')]),
|
|
'transaction')
|
|
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.add_regions,
|
|
'uuid', RegionWrapper([Region(name='')]),
|
|
'transaction')
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.add_regions,
|
|
'uuid', RegionWrapper([Region(name='test_region', type='group')]),
|
|
'transaction')
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
def test_delete_region_success(self, mock_gfbu, mock_strin):
|
|
ret_flavor = MagicMock()
|
|
ret_flavor.flavor.regions = [Region(name='test_region')]
|
|
mock_gfbu.return_value = ret_flavor
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
|
|
res_regions = flavor_logic.delete_region('uuid', RegionWrapper(
|
|
[Region(name='test_region')]), 'transaction', False)
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
def test_delete_region_errors(self, mock_gfbu, mock_strin):
|
|
ret_flavor = MagicMock()
|
|
ret_flavor.flavor.regions = [Region(name='test_region')]
|
|
mock_gfbu.return_value = ret_flavor
|
|
global error
|
|
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.delete_region,
|
|
'uuid', 'test_region', 'transaction', False)
|
|
|
|
error = 2
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
self.assertRaises(SystemError, flavor_logic.delete_region,
|
|
'uuid', 'test_region', 'transaction', False)
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
@patch.object(flavor_logic, 'validate_tenants_regions_list')
|
|
def test_add_tenants_success(self, mock_val, mock_gfbu, mock_strin):
|
|
ret_flavor = MagicMock()
|
|
tenants = ['test_tenant']
|
|
ret_flavor.flavor.tenants = tenants
|
|
ret_flavor.flavor.regions = [Region(name='test_region')]
|
|
mock_gfbu.return_value = ret_flavor
|
|
mock_val.return_value = ['test_tenant'], ['test_region']
|
|
global error
|
|
error = 3
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
|
|
res_tenants = flavor_logic.add_tenants('uuid',
|
|
TenantWrapper(tenants),
|
|
'transaction')
|
|
self.assertEqual(res_tenants.tenants, tenants)
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
@patch.object(flavor_logic, 'validate_tenants_regions_list')
|
|
def test_add_tenants_errors(self, mock_val, mock_gfbu, mock_strin):
|
|
ret_flavor = MagicMock()
|
|
tenants = ['test_tenant']
|
|
ret_flavor.flavor.tenants = tenants
|
|
mock_gfbu.return_value = ret_flavor
|
|
mock_val.return_value = ['test_tenant'], ['test_region']
|
|
global error
|
|
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
self.assertRaises(flavor_logic.ErrorStatus,
|
|
flavor_logic.add_tenants, 'uuid',
|
|
TenantWrapper(tenants),
|
|
'transaction')
|
|
|
|
# Flavor is public
|
|
error = 5
|
|
self.assertRaises(flavor_logic.ErrorStatus,
|
|
flavor_logic.add_tenants, 'uuid',
|
|
TenantWrapper(tenants),
|
|
'transaction')
|
|
|
|
error = 31
|
|
mock_val.return_value = [], ['test_region']
|
|
self.assertRaises(ValueError,
|
|
flavor_logic.add_tenants, 'uuid',
|
|
TenantWrapper(tenants),
|
|
'transaction')
|
|
|
|
error = 3
|
|
mock_val.return_value = ['test_tenant'], ['test_region']
|
|
mock_strin.side_effect = exc.FlushError(
|
|
'conflicts with persistent instance')
|
|
self.assertRaises(flavor_logic.ConflictError,
|
|
flavor_logic.add_tenants, 'uuid',
|
|
TenantWrapper(tenants),
|
|
'transaction')
|
|
|
|
mock_strin.side_effect = exc.FlushError('')
|
|
self.assertRaises(exc.FlushError,
|
|
flavor_logic.add_tenants, 'uuid',
|
|
TenantWrapper(tenants),
|
|
'transaction')
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
def test_delete_tenant_success(self, mock_gfbu, mock_strin):
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
|
|
flavor_logic.delete_tenant('uuid', 'tenant_id', 'transaction')
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
def test_delete_tenant_errors(self, mock_gfbu, mock_strin):
|
|
ret_flavor = MagicMock()
|
|
tenants = ['test_tenant']
|
|
ret_flavor.flavor.tenants = tenants
|
|
mock_gfbu.return_value = ret_flavor
|
|
global error
|
|
|
|
error = 1
|
|
injector.override_injected_dependency(
|
|
('data_manager', get_datamanager_mock))
|
|
self.assertRaises(flavor_logic.ErrorStatus,
|
|
flavor_logic.delete_tenant, 'uuid',
|
|
'tenant_id',
|
|
'transaction')
|
|
|
|
# Flavor is public
|
|
error = 5
|
|
self.assertRaises(ValueError,
|
|
flavor_logic.delete_tenant, 'uuid',
|
|
'tenant_id',
|
|
'transaction')
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
@patch.object(models, 'request')
|
|
@patch.object(flavor_logic, 'ExtraSpecsWrapper')
|
|
def test_add_extra_specs_success(self, mock_extra_specs_wrapper,
|
|
mock_request, mock_gfbu, mock_strin):
|
|
extra_specs = ExtraSpecsWrapper({'a': 'b'})
|
|
mock_extra_specs_wrapper.from_db_model.return_value = extra_specs
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
res_extra_specs = flavor_logic.add_extra_specs('uuid',
|
|
extra_specs,
|
|
'transaction')
|
|
self.assertEqual(res_extra_specs.os_extra_specs, {'a': 'b'})
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
@patch.object(models, 'request')
|
|
@patch.object(flavor_logic, 'ExtraSpecsWrapper')
|
|
def test_add_extra_specs_conflict_error(self, mock_extra_specs_wrapper,
|
|
mock_request, mock_gfbu,
|
|
mock_strin):
|
|
mock_strin.side_effect = ValueError(
|
|
'conflicts with persistent instance')
|
|
extra_specs = ExtraSpecsWrapper({'a': 'b'})
|
|
mock_extra_specs_wrapper.from_db_model.return_value = extra_specs
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
self.assertRaises(flavor_logic.ConflictError,
|
|
flavor_logic.add_extra_specs, 'uuid',
|
|
extra_specs,
|
|
'transaction')
|
|
|
|
@patch.object(flavor_logic, 'send_to_rds_if_needed')
|
|
@patch.object(flavor_logic, 'get_flavor_by_uuid')
|
|
@patch.object(models, 'request')
|
|
@patch.object(flavor_logic, 'ExtraSpecsWrapper')
|
|
@patch.object(flavor_logic, 'FlavorWrapper')
|
|
def test_update_extra_specs_success(self, mock_flavor_wrapper,
|
|
mock_extra_specs_wrapper,
|
|
mock_request, mock_gfbu, mock_strin):
|
|
extra_specs = ExtraSpecsWrapper({'a': 'b'})
|
|
mock_extra_specs_wrapper.from_db_model.return_value = extra_specs
|
|
global error
|
|
error = 31
|
|
injector.override_injected_dependency(
|
|
('rds_proxy', get_rds_proxy_mock()))
|
|
res_extra_specs = flavor_logic.update_extra_specs('uuid',
|
|
extra_specs,
|
|
'transaction')
|
|
self.assertEqual(res_extra_specs.os_extra_specs, {'a': 'b'})
|
|
|
|
|
|
def get_datamanager_mock():
|
|
def get_record(record_type):
|
|
global error
|
|
if record_type == 'flavor':
|
|
record = MagicMock()
|
|
db_model = db_models.Flavor()
|
|
db_model.remove_tag = MagicMock()
|
|
db_model.remove_all_tags = MagicMock()
|
|
record.get_flavor_by_id.return_value = db_model
|
|
|
|
if error == 1:
|
|
record.get_flavor_by_id.return_value = None
|
|
elif error == 2:
|
|
record.get_flavor_by_id.side_effect = SystemError()
|
|
elif error == 3:
|
|
moq = MagicMock()
|
|
moq.get_existing_region_names.return_value = ['region']
|
|
record.get_flavor_by_id.return_value = moq
|
|
elif error == 4:
|
|
record.get_flavor_by_id.return_value = db_models.Flavor()
|
|
elif error == 5:
|
|
record.get_flavor_by_id.return_value = db_models.Flavor(
|
|
visibility='public')
|
|
elif error == 6:
|
|
record.get_flavor_by_id.return_value = FLAVOR_MOCK
|
|
elif error == 7:
|
|
record.get_flavor_by_id.side_effect = flavor_logic.NotFoundError()
|
|
elif error == 8:
|
|
record.get_flavor_by_id.side_effect = flavor_logic.ErrorStatus(
|
|
404)
|
|
elif error == 9:
|
|
record.get_flavor_by_id.side_effect = flavor_logic.ErrorStatus(
|
|
500)
|
|
elif error == 10:
|
|
record.get_flavor_by_id.return_value = db_models.Flavor(
|
|
id='some_id')
|
|
else:
|
|
record.get_flavor_by_id.return_value = MagicMock()
|
|
return record
|
|
|
|
mock = MagicMock()
|
|
mock.get_record = get_record
|
|
|
|
return mock
|
|
|
|
|
|
def get_rds_proxy_mock():
|
|
def get_status(resource_id):
|
|
global error
|
|
response = MagicMock()
|
|
|
|
if error == 31:
|
|
response.status_code = 200
|
|
response.json.return_value = {'status': 'Success'}
|
|
elif error == 32:
|
|
response.status_code = 200
|
|
response.json.return_value = {}
|
|
elif error == 33:
|
|
response.status_code = 404
|
|
elif error == 34:
|
|
response.status_code = 200
|
|
response.json.return_value = {'status': 'Error'}
|
|
else:
|
|
response.status_code = 500
|
|
|
|
return response
|
|
|
|
mock = MagicMock()
|
|
mock.get_status = get_status
|
|
|
|
return mock
|
|
|
|
|
|
def get_flavor_mock():
|
|
flavor_mock = FlavorWrapper()
|
|
flavor_mock.flavor = Flavor(ram='1024',
|
|
vcpus='1',
|
|
series=cfg.CONF.fms.flavor_series[0],
|
|
id='g')
|
|
flavor_mock.flavor.profile = 'N1'
|
|
|
|
return flavor_mock
|
|
|
|
|
|
rds_proxy_mock = MagicMock()
|
|
rds_proxy_mock.get_status.return_value = {
|
|
"status": "pending",
|
|
"regions": [
|
|
{
|
|
"region": "dla1",
|
|
"timestamp": "1451599200",
|
|
"ord-transaction-id": "0649c5be323f4792afbc1efdd480847d",
|
|
"resource-id": "12fde398643acbed32f8097c98aec20",
|
|
"ord-notifier-id": "",
|
|
"status": "success",
|
|
"error-code": "200",
|
|
"error-msg": "OK"
|
|
}
|
|
]
|
|
}
|
|
|
|
extra_specs_json = {
|
|
"os_extra_specs": {
|
|
"name357": "region_name1",
|
|
"name4467": "2",
|
|
"name66767": "222234556"
|
|
}
|
|
}
|