From 870030005adff9c2884025fadc85ef828a8831ac Mon Sep 17 00:00:00 2001 From: Samantha Blanco Date: Tue, 25 Oct 2016 18:20:33 -0400 Subject: [PATCH] Increase unit test coverage for environments, helpers, and yaql expression Implements bp: murano-unit-test-coverage Change-Id: If7445310d6a345e15da764e116d1f712c8967c4e --- .../tests/unit/dynamic_ui/test_helpers.py | 28 +++ .../unit/dynamic_ui/test_yaql_expression.py | 51 +++++ .../tests/unit/environments/__init__.py | 0 .../tests/unit/environments/test_api.py | 205 ++++++++++++++++++ .../tests/unit/environments/test_forms.py | 66 ++++++ 5 files changed, 350 insertions(+) create mode 100644 muranodashboard/tests/unit/dynamic_ui/test_yaql_expression.py create mode 100644 muranodashboard/tests/unit/environments/__init__.py create mode 100644 muranodashboard/tests/unit/environments/test_api.py create mode 100644 muranodashboard/tests/unit/environments/test_forms.py diff --git a/muranodashboard/tests/unit/dynamic_ui/test_helpers.py b/muranodashboard/tests/unit/dynamic_ui/test_helpers.py index 318c7d2c9..d223ffea3 100644 --- a/muranodashboard/tests/unit/dynamic_ui/test_helpers.py +++ b/muranodashboard/tests/unit/dynamic_ui/test_helpers.py @@ -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) diff --git a/muranodashboard/tests/unit/dynamic_ui/test_yaql_expression.py b/muranodashboard/tests/unit/dynamic_ui/test_yaql_expression.py new file mode 100644 index 000000000..4a428a632 --- /dev/null +++ b/muranodashboard/tests/unit/dynamic_ui/test_yaql_expression.py @@ -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()) diff --git a/muranodashboard/tests/unit/environments/__init__.py b/muranodashboard/tests/unit/environments/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/muranodashboard/tests/unit/environments/test_api.py b/muranodashboard/tests/unit/environments/test_api.py new file mode 100644 index 000000000..bf2fae4fb --- /dev/null +++ b/muranodashboard/tests/unit/environments/test_api.py @@ -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} '.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 '.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) diff --git a/muranodashboard/tests/unit/environments/test_forms.py b/muranodashboard/tests/unit/environments/test_forms.py new file mode 100644 index 000000000..b25316c2e --- /dev/null +++ b/muranodashboard/tests/unit/environments/test_forms.py @@ -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)