openstack/murano
Code Issues Proposed changes

Merge "Replace assertRaisesRegexp with assertRaisesRegex"

Browse Source
This commit is contained in:
Jenkins 2017-05-22 17:44:19 +00:00 committed by Gerrit Code Review
commit b017242c0b
13 changed files with 109 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
murano/tests/unit/api/v1/test_schemas.py
View File

@ -62,7 +62,7 @@ class TestSchemas(test_base.MuranoTestCase):
dummy_error = client.RemoteError(exc_type=exc_type, dummy_error = client.RemoteError(exc_type=exc_type,
value='dummy_value') value='dummy_value')
mock_rpc.engine().generate_schema.side_effect = dummy_error mock_rpc.engine().generate_schema.side_effect = dummy_error
with self.assertRaisesRegexp(exc.HTTPNotFound, with self.assertRaisesRegex(exc.HTTPNotFound,
dummy_error.value): dummy_error.value):
self.controller.get_schema(mock_request, 'test_class') self.controller.get_schema(mock_request, 'test_class')
@ -70,6 +70,6 @@ class TestSchemas(test_base.MuranoTestCase):
dummy_error = client.RemoteError(exc_type='TestExcType', dummy_error = client.RemoteError(exc_type='TestExcType',
value='dummy_value') value='dummy_value')
mock_rpc.engine().generate_schema.side_effect = dummy_error mock_rpc.engine().generate_schema.side_effect = dummy_error
with self.assertRaisesRegexp(client.RemoteError, with self.assertRaisesRegex(client.RemoteError,
dummy_error.value): dummy_error.value):
self.controller.get_schema(mock_request, 'test_class') self.controller.get_schema(mock_request, 'test_class')

14
murano/tests/unit/api/v1/test_sessions.py
View File

@ -214,7 +214,7 @@ class TestSessionsApi(tb.ControllerTest, tb.MuranoApiTestCase):
for state in illegal_states: for state in illegal_states:
mock_envs.EnvironmentServices.get_status.return_value = state mock_envs.EnvironmentServices.get_status.return_value = state
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_msg): expected_error_msg):
self.sessions_controller.configure(mock_request, 'test_env_id') self.sessions_controller.configure(mock_request, 'test_env_id')
@ -229,7 +229,7 @@ class TestSessionsApi(tb.ControllerTest, tb.MuranoApiTestCase):
'access session <SessionId {1}>.'\ 'access session <SessionId {1}>.'\
.format(mock_request.context.user, 'test_sess_id') .format(mock_request.context.user, 'test_sess_id')
with self.assertRaisesRegexp(exc.HTTPUnauthorized, with self.assertRaisesRegex(exc.HTTPUnauthorized,
expected_error_msg): expected_error_msg):
self.sessions_controller.show(mock_request, None, 'test_sess_id') self.sessions_controller.show(mock_request, None, 'test_sess_id')
@ -247,7 +247,7 @@ class TestSessionsApi(tb.ControllerTest, tb.MuranoApiTestCase):
' has been updated or updating right now with'\ ' has been updated or updating right now with'\
' other session'.format('test_sess_id') ' other session'.format('test_sess_id')
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_msg): expected_error_msg):
self.sessions_controller.show(mock_request, None, 'test_sess_id') self.sessions_controller.show(mock_request, None, 'test_sess_id')
@ -262,7 +262,7 @@ class TestSessionsApi(tb.ControllerTest, tb.MuranoApiTestCase):
'access session <SessionId {1}>.'\ 'access session <SessionId {1}>.'\
.format(mock_request.context.user, 'test_sess_id') .format(mock_request.context.user, 'test_sess_id')
with self.assertRaisesRegexp(exc.HTTPUnauthorized, with self.assertRaisesRegex(exc.HTTPUnauthorized,
expected_error_msg): expected_error_msg):
self.sessions_controller.delete(mock_request, None, 'test_sess_id') self.sessions_controller.delete(mock_request, None, 'test_sess_id')
@ -281,7 +281,7 @@ class TestSessionsApi(tb.ControllerTest, tb.MuranoApiTestCase):
'state and could not be deleted'\ 'state and could not be deleted'\
.format('test_sess_id') .format('test_sess_id')
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_msg): expected_error_msg):
self.sessions_controller.delete(mock_request, None, 'test_sess_id') self.sessions_controller.delete(mock_request, None, 'test_sess_id')
@ -297,7 +297,7 @@ class TestSessionsApi(tb.ControllerTest, tb.MuranoApiTestCase):
' has been updated or updating right now with'\ ' has been updated or updating right now with'\
' other session'.format('test_sess_id') ' other session'.format('test_sess_id')
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_msg): expected_error_msg):
self.sessions_controller.deploy(mock_request, None, 'test_sess_id') self.sessions_controller.deploy(mock_request, None, 'test_sess_id')
@ -321,7 +321,7 @@ class TestSessionsApi(tb.ControllerTest, tb.MuranoApiTestCase):
mock_session = mock.MagicMock(state=state) mock_session = mock.MagicMock(state=state)
mock_db_session.get_session().query().get.return_value =\ mock_db_session.get_session().query().get.return_value =\
mock_session mock_session
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_msg): expected_error_msg):
self.sessions_controller.deploy( self.sessions_controller.deploy(
mock_request, None, 'test_sess_id') mock_request, None, 'test_sess_id')

4
murano/tests/unit/cmd/test_manage.py
View File

@ -217,7 +217,7 @@ class TestManage(test_base.MuranoWithDBTestCase):
def test_main_except_runtime_error(self, mock_conf): def test_main_except_runtime_error(self, mock_conf):
mock_conf.side_effect = RuntimeError mock_conf.side_effect = RuntimeError
with self.assertRaisesRegexp(SystemExit, 'ERROR:'): with self.assertRaisesRegex(SystemExit, 'ERROR:'):
manage.main() manage.main()
@mock.patch('murano.cmd.manage.CONF') @mock.patch('murano.cmd.manage.CONF')
@ -226,5 +226,5 @@ class TestManage(test_base.MuranoWithDBTestCase):
expected_err_msg = "murano-manage command failed:" expected_err_msg = "murano-manage command failed:"
with self.assertRaisesRegexp(SystemExit, expected_err_msg): with self.assertRaisesRegex(SystemExit, expected_err_msg):
manage.main() manage.main()

6
murano/tests/unit/common/messaging/test_mqclient.py
View File

@ -194,7 +194,7 @@ class MQClientTest(base.MuranoTestCase):
queue_arguments={}) queue_arguments={})
def test_declare_except_runtime_error(self): def test_declare_except_runtime_error(self):
with self.assertRaisesRegexp(RuntimeError, with self.assertRaisesRegex(RuntimeError,
'Not connected to RabbitMQ'): 'Not connected to RabbitMQ'):
self.ssl_client.declare(None) self.ssl_client.declare(None)
@ -212,7 +212,7 @@ class MQClientTest(base.MuranoTestCase):
body=jsonutils.dumps('test_message'), message_id='3') body=jsonutils.dumps('test_message'), message_id='3')
def test_send_except_runtime_error(self): def test_send_except_runtime_error(self):
with self.assertRaisesRegexp(RuntimeError, with self.assertRaisesRegex(RuntimeError,
'Not connected to RabbitMQ'): 'Not connected to RabbitMQ'):
self.ssl_client.send(None, None) self.ssl_client.send(None, None)
@ -224,6 +224,6 @@ class MQClientTest(base.MuranoTestCase):
self.ssl_client._connection, 'test_queue', 2) self.ssl_client._connection, 'test_queue', 2)
def test_open_except_runtime_error(self): def test_open_except_runtime_error(self):
with self.assertRaisesRegexp(RuntimeError, with self.assertRaisesRegex(RuntimeError,
'Not connected to RabbitMQ'): 'Not connected to RabbitMQ'):
self.ssl_client.open(None) self.ssl_client.open(None)

2
murano/tests/unit/engine/system/test_agent.py
View File

@ -222,7 +222,7 @@ class TestAgent(base.MuranoTestCase):
expected_error_msg = 'The murano-agent did not respond within 1 '\ expected_error_msg = 'The murano-agent did not respond within 1 '\
'seconds' 'seconds'
with self.assertRaisesRegexp(exceptions.TimeoutException, with self.assertRaisesRegex(exceptions.TimeoutException,
expected_error_msg): expected_error_msg):
self.agent.call(template, self.resources, None) self.agent.call(template, self.resources, None)

4
murano/tests/unit/engine/system/test_workflowclient.py
View File

@ -98,7 +98,7 @@ class TestMistralClient(base.MuranoTestCase):
expected_error_msg = 'Mistral execution completed with ERROR.'\ expected_error_msg = 'Mistral execution completed with ERROR.'\
' Execution id: {0}. Output: {1}'\ ' Execution id: {0}. Output: {1}'\
.format(mock_execution.id, mock_execution.output) .format(mock_execution.id, mock_execution.output)
with self.assertRaisesRegexp(workflowclient.MistralError, with self.assertRaisesRegex(workflowclient.MistralError,
expected_error_msg): expected_error_msg):
mc.run(run_name, timeout) mc.run(run_name, timeout)
@ -114,7 +114,7 @@ class TestMistralClient(base.MuranoTestCase):
expected_error_msg = 'Mistral run timed out. Execution id: {0}.'\ expected_error_msg = 'Mistral run timed out. Execution id: {0}.'\
.format(mock_execution.id) .format(mock_execution.id)
with self.assertRaisesRegexp(workflowclient.MistralError, with self.assertRaisesRegex(workflowclient.MistralError,
expected_error_msg): expected_error_msg):
mc.run(run_name, timeout) mc.run(run_name, timeout)

12
murano/tests/unit/engine/test_package_loader.py
View File

@ -190,7 +190,7 @@ class TestPackageCache(base.MuranoTestCase):
self.loader.import_fixation_table({fqn: [test_version]}) self.loader.import_fixation_table({fqn: [test_version]})
self.loader.register_package(package) self.loader.register_package(package)
with self.assertRaisesRegexp(dsl_exceptions.NoPackageFound, with self.assertRaisesRegex(dsl_exceptions.NoPackageFound,
expected_error_msg): expected_error_msg):
for spec in invalid_specs: for spec in invalid_specs:
self.loader.load_package('test_package_name', spec) self.loader.load_package('test_package_name', spec)
@ -324,7 +324,7 @@ class TestPackageCache(base.MuranoTestCase):
for class_ in package.classes: for class_ in package.classes:
expected_error_msg = 'Package for class "{0}" is not found'\ expected_error_msg = 'Package for class "{0}" is not found'\
.format(class_) .format(class_)
with self.assertRaisesRegexp(dsl_exceptions.NoPackageForClassFound, with self.assertRaisesRegex(dsl_exceptions.NoPackageForClassFound,
expected_error_msg): expected_error_msg):
for spec in invalid_specs: for spec in invalid_specs:
self.loader.load_class_package(class_, spec) self.loader.load_class_package(class_, spec)
@ -371,7 +371,7 @@ class TestPackageCache(base.MuranoTestCase):
def test_get_definition_except_lookup_error(self, mock_log): def test_get_definition_except_lookup_error(self, mock_log):
self.loader.client.packages.filter.return_value = [] self.loader.client.packages.filter.return_value = []
with self.assertRaisesRegexp(LookupError, None): with self.assertRaisesRegex(LookupError, None):
self.loader._get_definition({}) self.loader._get_definition({})
mock_log.debug.assert_called_once_with( mock_log.debug.assert_called_once_with(
@ -382,7 +382,7 @@ class TestPackageCache(base.MuranoTestCase):
self.loader.client.packages.filter.side_effect =\ self.loader.client.packages.filter.side_effect =\
muranoclient_exc.HTTPException muranoclient_exc.HTTPException
with self.assertRaisesRegexp(LookupError, None): with self.assertRaisesRegex(LookupError, None):
self.loader._get_definition({}) self.loader._get_definition({})
mock_log.debug.assert_called_once_with( mock_log.debug.assert_called_once_with(
@ -445,7 +445,7 @@ class TestPackageCache(base.MuranoTestCase):
muranoclient_exc.HTTPException muranoclient_exc.HTTPException
expected_error_msg = 'Error loading package id {0}:'.format(package.id) expected_error_msg = 'Error loading package id {0}:'.format(package.id)
with self.assertRaisesRegexp(pkg_exc.PackageLoadError, with self.assertRaisesRegex(pkg_exc.PackageLoadError,
expected_error_msg): expected_error_msg):
self.loader._get_package_by_definition(package) self.loader._get_package_by_definition(package)
@ -475,7 +475,7 @@ class TestPackageCache(base.MuranoTestCase):
expected_error_msg = 'Unable to extract package data for {0}'\ expected_error_msg = 'Unable to extract package data for {0}'\
.format(package.id) .format(package.id)
with self.assertRaisesRegexp(pkg_exc.PackageLoadError, with self.assertRaisesRegex(pkg_exc.PackageLoadError,
expected_error_msg): expected_error_msg):
self.loader._get_package_by_definition(package) self.loader._get_package_by_definition(package)

10
murano/tests/unit/packages/hot_package/test_hot_package.py
View File

@ -133,7 +133,7 @@ class TestHotPackage(test_base.MuranoTestCase):
self.assertEqual(expected_result, result['templateParameters']) self.assertEqual(expected_result, result['templateParameters'])
def test_translate_param_to_contract_with_inappropriate_value(self): def test_translate_param_to_contract_with_inappropriate_value(self):
self.assertRaisesRegexp( self.assertRaisesRegex(
ValueError, ValueError,
'Unsupported parameter type', 'Unsupported parameter type',
murano.packages.hot_package.HotPackage. murano.packages.hot_package.HotPackage.
@ -149,7 +149,7 @@ class TestHotPackage(test_base.MuranoTestCase):
def test_get_class_name_with_invalid_template_name(self): def test_get_class_name_with_invalid_template_name(self):
hot_package = self._get_hot_package(self.test_dirs[0]) hot_package = self._get_hot_package(self.test_dirs[0])
self.assertRaisesRegexp( self.assertRaisesRegex(
exceptions.PackageClassLoadError, exceptions.PackageClassLoadError,
'Class not defined in this package', 'Class not defined in this package',
hot_package.get_class, hot_package.get_class,
@ -157,7 +157,7 @@ class TestHotPackage(test_base.MuranoTestCase):
def test_get_class_name_with_invalid_template_format(self): def test_get_class_name_with_invalid_template_format(self):
hot_package = self._get_hot_package(self.test_dirs[1]) hot_package = self._get_hot_package(self.test_dirs[1])
self.assertRaisesRegexp( self.assertRaisesRegex(
exceptions.PackageFormatError, exceptions.PackageFormatError,
'Not a HOT template', 'Not a HOT template',
hot_package.get_class, hot_package.get_class,
@ -184,14 +184,14 @@ class TestHotPackage(test_base.MuranoTestCase):
def test_translate_ui_with_nonexistent_template(self): def test_translate_ui_with_nonexistent_template(self):
hot_package = self._get_hot_package(self.test_dirs[2]) hot_package = self._get_hot_package(self.test_dirs[2])
self.assertRaisesRegexp( self.assertRaisesRegex(
exceptions.PackageClassLoadError, exceptions.PackageClassLoadError,
'File with class definition not found', 'File with class definition not found',
hot_package._translate_ui) hot_package._translate_ui)
def test_translate_class_with_nonexistent_template(self): def test_translate_class_with_nonexistent_template(self):
hot_package = self._get_hot_package(self.test_dirs[2]) hot_package = self._get_hot_package(self.test_dirs[2])
self.assertRaisesRegexp( self.assertRaisesRegex(
exceptions.PackageClassLoadError, exceptions.PackageClassLoadError,
'File with class definition not found', 'File with class definition not found',
hot_package._translate_class) hot_package._translate_class)

16
murano/tests/unit/packages/test_load_utils.py
View File

@ -132,7 +132,7 @@ class TestLoadUtils(test_base.MuranoTestCase):
self._create_temp_zip_file(zip_path, manifest_path) self._create_temp_zip_file(zip_path, manifest_path)
expected_error_msg = "Unsupported format {0}".format(test_format) expected_error_msg = "Unsupported format {0}".format(test_format)
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
with load_utils.load_from_file(archive_path=zip_path, with load_utils.load_from_file(archive_path=zip_path,
target_dir=target_dir, target_dir=target_dir,
@ -143,7 +143,7 @@ class TestLoadUtils(test_base.MuranoTestCase):
def test_load_from_file_with_invalid_archive_path(self): def test_load_from_file_with_invalid_archive_path(self):
expected_error_msg = "Unable to find package file" expected_error_msg = "Unable to find package file"
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
with load_utils.load_from_file('invalid file path'): with load_utils.load_from_file('invalid file path'):
pass pass
@ -153,7 +153,7 @@ class TestLoadUtils(test_base.MuranoTestCase):
mock_os.listdir = mock.MagicMock(return_value=True) mock_os.listdir = mock.MagicMock(return_value=True)
temp_file = self._create_temp_file() temp_file = self._create_temp_file()
expected_error_msg = "Target directory is not empty" expected_error_msg = "Target directory is not empty"
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
this_dir = os.path.dirname(os.path.realpath(__file__)) this_dir = os.path.dirname(os.path.realpath(__file__))
with load_utils.load_from_file(temp_file.name, with load_utils.load_from_file(temp_file.name,
@ -164,7 +164,7 @@ class TestLoadUtils(test_base.MuranoTestCase):
temp_file = self._create_temp_file() temp_file = self._create_temp_file()
expected_error_msg = "Uploaded file {0} is not a zip archive".\ expected_error_msg = "Uploaded file {0} is not a zip archive".\
format(temp_file.name) format(temp_file.name)
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
with load_utils.load_from_file(temp_file.name): with load_utils.load_from_file(temp_file.name):
pass pass
@ -177,7 +177,7 @@ class TestLoadUtils(test_base.MuranoTestCase):
mock_zipfile.is_zipfile = mock.MagicMock( mock_zipfile.is_zipfile = mock.MagicMock(
side_effect=ValueError(test_error_msg)) side_effect=ValueError(test_error_msg))
temp_file = self._create_temp_file() temp_file = self._create_temp_file()
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
with load_utils.load_from_file(temp_file.name): with load_utils.load_from_file(temp_file.name):
pass pass
@ -186,14 +186,14 @@ class TestLoadUtils(test_base.MuranoTestCase):
def test_load_from_dir_without_source_directory(self): def test_load_from_dir_without_source_directory(self):
expected_error_msg = 'Invalid package directory' expected_error_msg = 'Invalid package directory'
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
load_utils.load_from_dir('random_test_directory') load_utils.load_from_dir('random_test_directory')
def test_load_from_dir_with_invalid_source_directory(self): def test_load_from_dir_with_invalid_source_directory(self):
source_directory = self._create_temp_dir() source_directory = self._create_temp_dir()
expected_error_msg = 'Unable to find package manifest' expected_error_msg = 'Unable to find package manifest'
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
load_utils.load_from_dir(source_directory) load_utils.load_from_dir(source_directory)
@ -204,7 +204,7 @@ class TestLoadUtils(test_base.MuranoTestCase):
random_filename = ''.join(random.choice(string.ascii_lowercase) random_filename = ''.join(random.choice(string.ascii_lowercase)
for i in range(20)) for i in range(20))
expected_error_msg = 'Unable to load due to' expected_error_msg = 'Unable to load due to'
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_msg): expected_error_msg):
load_utils.load_from_dir(source_directory, load_utils.load_from_dir(source_directory,
filename=random_filename) filename=random_filename)

20
murano/tests/unit/packages/test_package_base.py
View File

@ -56,7 +56,7 @@ class TestPackageBase(test_base.MuranoTestCase):
shutil.rmtree(cls.source_directory) shutil.rmtree(cls.source_directory)
def test_create_package_base_without_full_name(self): def test_create_package_base_without_full_name(self):
with self.assertRaisesRegexp(exceptions.PackageFormatError, with self.assertRaisesRegex(exceptions.PackageFormatError,
'FullName is not specified'): 'FullName is not specified'):
package_base.PackageBase('test_format', package_base.PackageBase('test_format',
'test_runtime_version', 'test_runtime_version',
@ -67,7 +67,7 @@ class TestPackageBase(test_base.MuranoTestCase):
full_names = ['.invalid_name_1', 'invalid..name..2', 'invalid name 3'] full_names = ['.invalid_name_1', 'invalid..name..2', 'invalid name 3']
for full_name in full_names: for full_name in full_names:
expected_error_message = 'Invalid FullName {0}'.format(full_name) expected_error_message = 'Invalid FullName {0}'.format(full_name)
with self.assertRaisesRegexp(exceptions.PackageFormatError, with self.assertRaisesRegex(exceptions.PackageFormatError,
expected_error_message): expected_error_message):
package_base.PackageBase('test_format', package_base.PackageBase('test_format',
'test_runtime_version', 'test_runtime_version',
@ -76,7 +76,7 @@ class TestPackageBase(test_base.MuranoTestCase):
def test_create_package_base_with_invalid_type(self): def test_create_package_base_with_invalid_type(self):
package_type = 'Invalid' package_type = 'Invalid'
with self.assertRaisesRegexp(exceptions.PackageFormatError, with self.assertRaisesRegex(exceptions.PackageFormatError,
'Invalid package Type {0}' 'Invalid package Type {0}'
.format(package_type)): .format(package_type)):
package_base.PackageBase('test_format', package_base.PackageBase('test_format',
@ -86,19 +86,19 @@ class TestPackageBase(test_base.MuranoTestCase):
'Type': package_type}) 'Type': package_type})
def test_requirements_negative(self): def test_requirements_negative(self):
with self.assertRaisesRegexp(NotImplementedError, None): with self.assertRaisesRegex(NotImplementedError, None):
self.package_base.requirements self.package_base.requirements
def test_classes_negative(self): def test_classes_negative(self):
with self.assertRaisesRegexp(NotImplementedError, None): with self.assertRaisesRegex(NotImplementedError, None):
self.package_base.classes self.package_base.classes
def test_get_class_negative(self): def test_get_class_negative(self):
with self.assertRaisesRegexp(NotImplementedError, None): with self.assertRaisesRegex(NotImplementedError, None):
self.package_base.get_class(None) self.package_base.get_class(None)
def test_ui_negative(self): def test_ui_negative(self):
with self.assertRaisesRegexp(NotImplementedError, None): with self.assertRaisesRegex(NotImplementedError, None):
self.package_base.ui self.package_base.ui
def test_full_name(self): def test_full_name(self):
@ -144,7 +144,7 @@ class TestPackageBase(test_base.MuranoTestCase):
expected_error_message = 'Unable to load logo' expected_error_message = 'Unable to load logo'
self.package_base._logo = ''.join(random.choice(string.ascii_letters) self.package_base._logo = ''.join(random.choice(string.ascii_letters)
for _ in range(10)) for _ in range(10))
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_message): expected_error_message):
self.package_base.logo self.package_base.logo
self.package_base._logo = self.mock_manifest['Logo'] self.package_base._logo = self.mock_manifest['Logo']
@ -153,7 +153,7 @@ class TestPackageBase(test_base.MuranoTestCase):
what=mock.MagicMock(return_value='xyz')) what=mock.MagicMock(return_value='xyz'))
def test_load_image_with_invalid_extension(self, mock_imghdr): def test_load_image_with_invalid_extension(self, mock_imghdr):
expected_error_message = 'Unsupported Format.' expected_error_message = 'Unsupported Format.'
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_message): expected_error_message):
self.package_base._load_image('logo.xyz', 'logo.xyz', 'logo') self.package_base._load_image('logo.xyz', 'logo.xyz', 'logo')
full_path = os.path.join(self.package_base._source_directory, full_path = os.path.join(self.package_base._source_directory,
@ -167,7 +167,7 @@ class TestPackageBase(test_base.MuranoTestCase):
mock_os.stat.return_value = mock.MagicMock(st_size=5000 * 1024) mock_os.stat.return_value = mock.MagicMock(st_size=5000 * 1024)
mock_os.isfile = mock.MagicMock(return_value=True) mock_os.isfile = mock.MagicMock(return_value=True)
expected_error_message = 'Max allowed size is {0}'.format(500 * 1024) expected_error_message = 'Max allowed size is {0}'.format(500 * 1024)
with self.assertRaisesRegexp(exceptions.PackageLoadError, with self.assertRaisesRegex(exceptions.PackageLoadError,
expected_error_message): expected_error_message):
self.package_base._load_image('logo.xyz', 'logo.xyz', 'logo') self.package_base._load_image('logo.xyz', 'logo.xyz', 'logo')

4
murano/tests/unit/services/test_actions.py
View File

@ -190,7 +190,7 @@ class TestActions(test_base.MuranoTestCase):
test_action_id = 'test_action_id' test_action_id = 'test_action_id'
test_session = mock.MagicMock(description=[]) test_session = mock.MagicMock(description=[])
with self.assertRaisesRegexp(LookupError, 'Action is not found'): with self.assertRaisesRegex(LookupError, 'Action is not found'):
actions.ActionServices.execute(test_action_id, test_session, actions.ActionServices.execute(test_action_id, test_session,
None, None, None) None, None, None)
@ -210,7 +210,7 @@ class TestActions(test_base.MuranoTestCase):
}] }]
test_session = mock.MagicMock(description=test_description) test_session = mock.MagicMock(description=test_description)
with self.assertRaisesRegexp(ValueError, with self.assertRaisesRegex(ValueError,
'Cannot execute disabled action'): 'Cannot execute disabled action'):
actions.ActionServices.execute(test_action_id, test_session, actions.ActionServices.execute(test_action_id, test_session,
None, None, None) None, None, None)

6
murano/tests/unit/test_heat_stack.py
View File

@ -694,7 +694,7 @@ class TestHeatStack(base.MuranoTestCase):
# Else EnvironmentError should be thrown. # Else EnvironmentError should be thrown.
expected_error_msg = "Unexpected stack state {0}"\ expected_error_msg = "Unexpected stack state {0}"\
.format('NOT_FOUND') .format('NOT_FOUND')
with self.assertRaisesRegexp(EnvironmentError, with self.assertRaisesRegex(EnvironmentError,
expected_error_msg): expected_error_msg):
hs._wait_state(lambda status: status == 'CREATE_COMPLETE') hs._wait_state(lambda status: status == 'CREATE_COMPLETE')
@ -705,7 +705,7 @@ class TestHeatStack(base.MuranoTestCase):
hs = heat_stack.HeatStack('test-stack', None) hs = heat_stack.HeatStack('test-stack', None)
hs._client.stacks.get.side_effect = Exception('test_exception_msg') hs._client.stacks.get.side_effect = Exception('test_exception_msg')
with self.assertRaisesRegexp(Exception, with self.assertRaisesRegex(Exception,
'test_exception_msg'): 'test_exception_msg'):
hs._wait_state(lambda status: status == 'CREATE_COMPLETE') hs._wait_state(lambda status: status == 'CREATE_COMPLETE')
@ -725,6 +725,6 @@ class TestHeatStack(base.MuranoTestCase):
expected_error_msg = "Unexpected stack state {0}: {1}"\ expected_error_msg = "Unexpected stack state {0}: {1}"\
.format('UNEXPECTED_STATUS', 'test_reason') .format('UNEXPECTED_STATUS', 'test_reason')
with self.assertRaisesRegexp(EnvironmentError, with self.assertRaisesRegex(EnvironmentError,
expected_error_msg): expected_error_msg):
hs._wait_state(lambda status: status == 'CREATE_COMPLETE') hs._wait_state(lambda status: status == 'CREATE_COMPLETE')

20
murano/tests/unit/test_utils.py
View File

@ -45,7 +45,7 @@ class TestUtils(test_base.MuranoTestCase):
expected_error_message = 'Environment with id {env_id} not found'\ expected_error_message = 'Environment with id {env_id} not found'\
.format(env_id=test_env_id) .format(env_id=test_env_id)
with self.assertRaisesRegexp(exc.HTTPNotFound, with self.assertRaisesRegex(exc.HTTPNotFound,
expected_error_message): expected_error_message):
utils.check_env(mock_request, test_env_id) utils.check_env(mock_request, test_env_id)
@ -60,7 +60,7 @@ class TestUtils(test_base.MuranoTestCase):
expected_error_message = 'User is not authorized to access these '\ expected_error_message = 'User is not authorized to access these '\
'tenant resources' 'tenant resources'
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_message): expected_error_message):
utils.check_env(mock_request, mock_env.environment_id) utils.check_env(mock_request, mock_env.environment_id)
@ -68,7 +68,7 @@ class TestUtils(test_base.MuranoTestCase):
"""Test check session with null session throws exception.""" """Test check session with null session throws exception."""
expected_error_message = 'Session <SessionId {id}> is not found'\ expected_error_message = 'Session <SessionId {id}> is not found'\
.format(id=None) .format(id=None)
with self.assertRaisesRegexp(exc.HTTPNotFound, with self.assertRaisesRegex(exc.HTTPNotFound,
expected_error_message): expected_error_message):
utils.check_session(None, None, None, None) utils.check_session(None, None, None, None)
@ -82,7 +82,7 @@ class TestUtils(test_base.MuranoTestCase):
'with Environment <EnvId {environment_id}>'\ 'with Environment <EnvId {environment_id}>'\
.format(session_id=mock_session.session_id, .format(session_id=mock_session.session_id,
environment_id=environment_id) environment_id=environment_id)
with self.assertRaisesRegexp(exc.HTTPBadRequest, with self.assertRaisesRegex(exc.HTTPBadRequest,
expected_error_msg): expected_error_msg):
utils.check_session(None, environment_id, mock_session, utils.check_session(None, environment_id, mock_session,
mock_session.session_id) mock_session.session_id)
@ -95,7 +95,7 @@ class TestUtils(test_base.MuranoTestCase):
mock_request = mock.MagicMock(context=dummy_context) mock_request = mock.MagicMock(context=dummy_context)
expected_error_message = 'X-Configuration-Session header which '\ expected_error_message = 'X-Configuration-Session header which '\
'indicates to the session is missed' 'indicates to the session is missed'
with self.assertRaisesRegexp(exc.HTTPBadRequest, with self.assertRaisesRegex(exc.HTTPBadRequest,
expected_error_message): expected_error_message):
self._test_verify_session(mock_request) self._test_verify_session(mock_request)
@ -108,7 +108,7 @@ class TestUtils(test_base.MuranoTestCase):
mock_db_session.get_session().query().get.return_value = None mock_db_session.get_session().query().get.return_value = None
expected_error_message = 'Session <SessionId {0}> is not found'\ expected_error_message = 'Session <SessionId {0}> is not found'\
.format(mock_request.context.session) .format(mock_request.context.session)
with self.assertRaisesRegexp(exc.HTTPNotFound, with self.assertRaisesRegex(exc.HTTPNotFound,
expected_error_message): expected_error_message):
self._test_verify_session(mock_request) self._test_verify_session(mock_request)
@ -123,7 +123,7 @@ class TestUtils(test_base.MuranoTestCase):
mock_env_template mock_env_template
expected_error_message = 'User is not authorized to access this'\ expected_error_message = 'User is not authorized to access this'\
' tenant resources' ' tenant resources'
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_message): expected_error_message):
self._test_verify_env_template(mock_request, None) self._test_verify_env_template(mock_request, None)
@ -133,7 +133,7 @@ class TestUtils(test_base.MuranoTestCase):
mock_db_session.get_session().query().get.return_value = None mock_db_session.get_session().query().get.return_value = None
expected_error_message = 'Environment Template with id {id} not found'\ expected_error_message = 'Environment Template with id {id} not found'\
.format(id='test_env_template_id') .format(id='test_env_template_id')
with self.assertRaisesRegexp(exc.HTTPNotFound, with self.assertRaisesRegex(exc.HTTPNotFound,
expected_error_message): expected_error_message):
self._test_verify_env_template(None, 'test_env_template_id') self._test_verify_env_template(None, 'test_env_template_id')
@ -157,7 +157,7 @@ class TestUtils(test_base.MuranoTestCase):
'environment has been updated or '\ 'environment has been updated or '\
'updating right now with other session'\ 'updating right now with other session'\
.format(mock_request.context.session) .format(mock_request.context.session)
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_message): expected_error_message):
self._test_verify_session(mock_request) self._test_verify_session(mock_request)
@ -176,7 +176,7 @@ class TestUtils(test_base.MuranoTestCase):
expected_error_message = 'Session <SessionId {0}> is already in '\ expected_error_message = 'Session <SessionId {0}> is already in '\
'deployment state'\ 'deployment state'\
.format(mock_request.context.session) .format(mock_request.context.session)
with self.assertRaisesRegexp(exc.HTTPForbidden, with self.assertRaisesRegex(exc.HTTPForbidden,
expected_error_message): expected_error_message):
self._test_verify_session(mock_request) self._test_verify_session(mock_request)