68a500b3de
Updated pep8 requirements and fixed resulting codes to fix broken pep8 job. Updated docker image build process to use roles to ensure docker rather than using manual docker install process to fix broken ranger image job. Co-Authored-By: Jeremy Houser <jeremyhouser@protonmail.com> Co-Authored-By: Chi Lo <cl566n@att.com> Change-Id: I28df0a27e4b354dd53c17fbb1a9468cb7ff5bc16
779 lines
31 KiB
Python
Executable File
779 lines
31 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 (
|
|
ExtraSpecsWrapper, Flavor, FlavorWrapper,
|
|
Region, RegionWrapper, TagsWrapper, TenantWrapper)
|
|
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(utils, 'delete_uuid')
|
|
@patch.object(flavor_logic, 'FlavorWrapper')
|
|
def test_create_flavor_invalid_model(self, mock_flavorwrapper,
|
|
mock_delete):
|
|
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(400, 'Invalid model'))
|
|
self.assertRaises(flavor_logic.ErrorStatus, flavor_logic.create_flavor,
|
|
flavor, 'uuid', 'transaction')
|
|
|
|
@patch.object(utils, 'delete_uuid')
|
|
@patch.object(flavor_logic, 'validate_tenants_regions_list')
|
|
@patch.object(flavor_logic, 'FlavorWrapper')
|
|
def test_create_flavor_success(self, mock_flavorwrapper, mock_validate,
|
|
mock_delete):
|
|
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(flavor_logic.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, 'delete_uuid')
|
|
@patch.object(utils, 'get_resource_status_from_db')
|
|
def test_delete_flavor_by_uuid_success(self, mock_get_resource,
|
|
mock_delete):
|
|
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.ErrorStatus):
|
|
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"
|
|
}
|
|
}
|