openstack
/
murano-dashboard
Code Issues Proposed changes

Increase unit test coverage for environments, helpers, and yaql expression 

Implements bp: murano-unit-test-coverage

Change-Id: If7445310d6a345e15da764e116d1f712c8967c4e
This commit is contained in:
Samantha Blanco 2016-10-25 18:20:33 -04:00
parent 43e265eee9
commit 870030005a
5 changed files with 350 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
muranodashboard/tests/unit/dynamic_ui/test_helpers.py
View File

@ -11,6 +11,7 @@
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import testtools
from muranodashboard.dynamic_ui import helpers
@ -28,3 +29,30 @@ class TestHelper(testtools.TestCase):
self.assertEqual("{0:b}".format(x), helpers.int2base(x, 2))
self.assertEqual("{0:o}".format(x), helpers.int2base(x, 8))
self.assertEqual("{0:x}".format(x), helpers.int2base(x, 16))
def test_camelize(self):
snake_name = "snake_case_name"
camel_name = helpers.camelize(snake_name)
self.assertEqual("SnakeCaseName", camel_name)
def test_explode(self):
not_string = 123456
explode_int = helpers.explode(not_string)
self.assertEqual(123456, explode_int)
string = "test"
explode_str = helpers.explode(string)
self.assertEqual(['t', 'e', 's', 't'], explode_str)
def test_insert_hidden_ids(self):
app_dict = {'?': {
'type': 'test.App',
'id': '123'
}
}
app_list = [1, 2, 3, 4]
dict_result = helpers.insert_hidden_ids(app_dict)
list_result = helpers.insert_hidden_ids(app_list)
self.assertEqual('test.App', dict_result['?']['type'])
self.assertEqual(app_list, list_result)

51
muranodashboard/tests/unit/dynamic_ui/test_yaql_expression.py Normal file
View File

@ -0,0 +1,51 @@
# Copyright (c) 2016 AT&T
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import testtools
import unittest
from muranodashboard.dynamic_ui import yaql_expression
class TestYaqlExpression(testtools.TestCase):
def setUp(self):
super(TestYaqlExpression, self).setUp()
yaql = "$foo"
string = "test"
self.yaql_expr = yaql_expression.YaqlExpression(yaql)
self.str_expr = yaql_expression.YaqlExpression(string)
def test_overloading(self):
self.assertEqual("test", self.str_expr.__str__())
self.assertEqual("$foo", self.yaql_expr.__str__())
self.assertEqual("YAQL(test)", self.str_expr.__repr__())
self.assertEqual("YAQL($foo)", self.yaql_expr.__repr__())
def test_expression(self):
self.assertEqual("$foo", self.yaql_expr.expression())
self.assertEqual("test", self.str_expr.expression())
@unittest.skip('Skipping until bug #1636639 resolved.')
def test_match(self):
self.assertFalse(self.str_expr.match(12345))
self.assertFalse(self.str_expr.match(self.str_expr._expression))
self.assertTrue(self.yaql_expr.match(self.yaql_expr._expression))
self.assertFalse(self.yaql_expr.match("$!")) # YaqlLexicalException
self.assertFalse(self.yaql_expr.match("$foo(")) # YaqlGrammarException
def test_evaluate(self):
self.assertEqual("test", self.str_expr.evaluate())
self.assertIsNone(self.yaql_expr.evaluate())

0
muranodashboard/tests/unit/environments/__init__.py Normal file
View File

205
muranodashboard/tests/unit/environments/test_api.py Normal file
View File

@ -0,0 +1,205 @@
# Copyright (c) 2016 AT&T Corp
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import mock
from muranoclient.v1 import client
from muranodashboard.environments import api as env_api
from openstack_dashboard.test import helpers
class TestEnvironmentsAPI(helpers.APITestCase):
def setUp(self):
super(TestEnvironmentsAPI, self).setUp()
self.mock_client = mock.Mock(spec=client)
self.mock_request = mock.MagicMock()
self.env_id = 12
self.addCleanup(mock.patch.stopall)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_get_status_messages_for_service(self, mock_log, mock_api):
service_id = 11
result = env_api.get_status_messages_for_service(self.mock_request,
service_id,
self.env_id)
self.assertEqual('\n', result)
env_api.api.muranoclient.assert_called_once_with(self.mock_request)
self.assertTrue(mock_log.debug.called)
@mock.patch.object(env_api, 'api')
def test_environment_update(self, mock_api):
env_name = "test_env"
env_api.environment_update(self.mock_request, self.env_id, env_name)
env_api.api.muranoclient.assert_called_once_with(self.mock_request)
@mock.patch.object(env_api, 'api')
def test_environment_list(self, mock_api):
env_api.environments_list(self.mock_request)
env_api.api.muranoclient.assert_called_with(self.mock_request)
env_api.api.handled_exceptions.assert_called_with(self.mock_request)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_environment_create(self, mock_log, mock_api):
parameters = {
'name': 'test_env',
'defaultNetworks': 'test_net'
}
env_api.environment_create(self.mock_request, parameters)
env_api.api.muranoclient.assert_called_with(self.mock_request)
self.assertTrue(mock_log.debug.called)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_environment_delete(self, mock_log, mock_api):
env_api.environment_delete(self.mock_request, self.env_id)
env_api.api.muranoclient.assert_called_with(self.mock_request)
(mock_log.debug.
assert_called_once_with('Environment::{0} <Id :'
' {1}>'.format('Delete', self.env_id)))
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_environment_deploy(self, mock_log, mock_api):
env_api.environment_deploy(self.mock_request, self.env_id)
self.assertTrue(env_api.api.muranoclient.called)
self.assertTrue(mock_log.debug.called)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_action_allowed(self, mock_log, mock_api):
result = env_api.action_allowed(self.mock_request, self.env_id)
self.assertTrue(result)
env_api.api.muranoclient.assert_called_with(self.mock_request)
self.assertTrue(mock_log.debug.called)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_service_create(self, mock_log, mock_api):
parameters = {
'?': {
'type': 'test.Service'
}
}
env_api.service_create(self.mock_request, self.env_id, parameters)
env_api.api.muranoclient.assert_called_with(self.mock_request)
mock_log.debug.assert_called_with('Service::Create {0}'
.format(parameters['?']['type']))
@mock.patch.object(env_api, 'api')
@mock.patch("muranodashboard.environments.api.Session."
"get_or_create_or_delete")
@mock.patch.object(env_api, 'LOG')
def test_service_delete(self, mock_log, mock_gcd, mock_api):
service_id = str(11)
mock_gcd.return_value = self.env_id
env_api.service_delete(self.mock_request, self.env_id, service_id)
env_api.api.muranoclient.assert_called_with(self.mock_request)
mock_log.debug.assert_called_with('Service::Delete <SrvId: '
'{0}>'.format(service_id))
mock_gcd.assert_called_with(self.mock_request, self.env_id)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_service_get(self, mock_log, mock_api):
service_id = 11
result = env_api.service_get(self.mock_request,
self.env_id, service_id)
self.assertIsNone(result)
env_api.api.muranoclient.assert_called_with(self.mock_request)
mock_log.debug.assert_called_with('Return service'
' detail for a specified id')
def test_extract_actions_list(self):
service = {
'?': {
'test': 'test'
}
}
result = env_api.extract_actions_list(service)
self.assertEqual([], result)
@mock.patch.object(env_api, 'api')
def test_run_action(self, mock_api):
action_id = 11
env_api.run_action(self.mock_request, self.env_id, action_id)
env_api.api.muranoclient.assert_called_with(self.mock_request)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_deployment_reports(self, mock_log, mock_api):
deployment_id = 11
env_api.deployment_reports(self.mock_request, self.env_id,
deployment_id)
env_api.api.muranoclient.assert_called_with(self.mock_request)
self.assertTrue(mock_log.debug.called)
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_get_deployment_start(self, mock_log, mock_api):
deployment_id = 11
result = env_api.get_deployment_start(self.mock_request, self.env_id,
deployment_id)
self.assertIsNone(result)
env_api.api.muranoclient.assert_called_with(self.mock_request)
mock_log.debug.assert_called_with('Get deployment start time')
@mock.patch.object(env_api, 'api')
@mock.patch.object(env_api, 'LOG')
def test_get_deployment_descr(self, mock_log, mock_api):
deployment_id = 11
result = env_api.get_deployment_descr(self.mock_request, self.env_id,
deployment_id)
self.assertIsNone(result)
env_api.api.muranoclient.assert_called_with(self.mock_request)
mock_log.debug.assert_called_with('Get deployment description')
@mock.patch('muranodashboard.environments.api.topology.json.dumps')
@mock.patch('muranodashboard.environments.api.topology._environment_info')
@mock.patch('muranodashboard.environments.api.environment_get')
def test_load_environment_data(self, mock_env_get,
mock_env_info, mock_dump):
mock_env_info.return_value = 'services/_environment_info.html'
mock_dump.return_value = self.env_id
result = env_api.load_environment_data(self.mock_request, self.env_id)
self.assertTrue(mock_env_get.called)
self.assertEqual(self.env_id, result)
self.assertTrue(mock_dump.called)
class TestEnvironmentsSessionAPI(helpers.APITestCase):
def setUp(self):
super(TestEnvironmentsSessionAPI, self).setUp()
self.mock_client = mock.Mock(spec=client)
self.mock_request = mock.MagicMock()
self.env_id = 12
self.addCleanup(mock.patch.stopall)
@mock.patch.object(env_api, 'api')
def test_get_or_create(self, mock_api):
self.session = env_api.Session()
result = self.session.get_or_create(self.mock_request, self.env_id)
self.assertIsNotNone(result)
env_api.api.muranoclient.assert_called_once_with(self.mock_request)
def test_set(self):
session_id = 11
self.session = env_api.Session()
result = self.session.set(self.mock_request, self.env_id, session_id)
self.assertIsNone(result)

66
muranodashboard/tests/unit/environments/test_forms.py Normal file
View File

@ -0,0 +1,66 @@
# Copyright (c) 2016 AT&T Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import mock
import testtools
from django.utils.translation import ugettext_lazy as _
from muranoclient.common import exceptions as exc
from muranodashboard.environments import forms as env_forms
class TestCreateEnvForm(testtools.TestCase):
def setUp(self):
super(TestCreateEnvForm, self).setUp()
self.mock_request = mock.MagicMock()
self.data = {
'name': 'test',
'net_config': 'Nova'
}
@mock.patch.object(env_forms, 'ast')
@mock.patch.object(env_forms, 'api')
@mock.patch('muranodashboard.common.net.get_available_networks')
def test_handle(self, mock_net, mock_api, mock_ast):
mock_net.return_value = None
test_env_form = env_forms.CreateEnvironmentForm(self.mock_request)
self.assertEqual([((None, None), _('Unavailable'))],
test_env_form.fields['net_config'].choices)
self.assertEqual(env_forms.net.NN_HELP,
test_env_form.fields['net_config'].help_text)
self.assertTrue(test_env_form.handle(self.mock_request, self.data))
mock_api.environment_create.assert_called_once_with(self.mock_request,
self.data)
mock_ast.literal_eval.assert_called_once_with('Nova')
@mock.patch.object(env_forms, 'LOG')
@mock.patch.object(env_forms, 'ast')
@mock.patch.object(env_forms, 'api')
@mock.patch('muranodashboard.common.net.get_available_networks')
def test_handle_error(self, mock_net, mock_api, mock_ast, mock_log):
mock_net.return_value = None
test_env_form = env_forms.CreateEnvironmentForm(self.mock_request)
self.assertEqual([((None, None), _('Unavailable'))],
test_env_form.fields['net_config'].choices)
self.assertEqual(env_forms.net.NN_HELP,
test_env_form.fields['net_config'].help_text)
mock_api.environment_create.side_effect = exc.HTTPConflict
msg = _('Environment with specified name already exists')
self.assertRaises(exc.HTTPConflict, test_env_form.handle,
self.mock_request, self.data)
mock_ast.literal_eval.assert_called_once_with('Nova')
mock_log.exception.assert_called_once_with(msg)