Arnike/watcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Enabled config parameters to plugins"

Browse Source
This commit is contained in:
Jenkins
2016-05-30 09:40:30 +00:00
committed by Gerrit Code Review
parent 30bdf29002 5aa6b16238
commit e9f237dc80
22 changed files with 453 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
watcher/tests/applier/actions/test_change_nova_service_state.py
View File

@@ -54,7 +54,8 @@ class TestChangeNovaServiceState(base.TestCase):
baction.BaseAction.RESOURCE_ID: "compute-1",
"state": hstate.HypervisorState.ENABLED.value,
}
self.action = change_nova_service_state.ChangeNovaServiceState()
self.action = change_nova_service_state.ChangeNovaServiceState(
mock.Mock())
self.action.input_parameters = self.input_parameters
def test_parameters_down(self):

4
watcher/tests/applier/actions/test_migration.py
View File

@@ -58,7 +58,7 @@ class TestMigration(base.TestCase):
"dst_hypervisor": "hypervisor2-hostname",
baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
}
self.action = migration.Migrate()
self.action = migration.Migrate(mock.Mock())
self.action.input_parameters = self.input_parameters
self.input_parameters_cold = {
@@ -67,7 +67,7 @@ class TestMigration(base.TestCase):
"dst_hypervisor": "hypervisor2-hostname",
baction.BaseAction.RESOURCE_ID: self.INSTANCE_UUID,
}
self.action_cold = migration.Migrate()
self.action_cold = migration.Migrate(mock.Mock())
self.action_cold.input_parameters = self.input_parameters_cold
def test_parameters(self):

4
watcher/tests/applier/actions/test_sleep.py
View File

@@ -14,6 +14,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
import mock
import voluptuous
from watcher.applier.actions import sleep
@@ -23,7 +25,7 @@ from watcher.tests import base
class TestSleep(base.TestCase):
def setUp(self):
super(TestSleep, self).setUp()
self.s = sleep.Sleep()
self.s = sleep.Sleep(mock.Mock())
def test_parameters_duration(self):
self.s.input_parameters = {self.s.DURATION: 1.0}

40
watcher/tests/applier/workflow_engine/test_default_workflow_engine.py
View File

@@ -20,10 +20,9 @@ import abc
import mock
import six
from stevedore import driver
from stevedore import extension
from watcher.applier.actions import base as abase
from watcher.applier.actions import factory
from watcher.applier.workflow_engine import default as tflow
from watcher.common import exception
from watcher.common import utils
@@ -31,6 +30,10 @@ from watcher import objects
from watcher.tests.db import base
class ExpectedException(Exception):
pass
@six.add_metaclass(abc.ABCMeta)
class FakeAction(abase.BaseAction):
def schema(self):
@@ -46,21 +49,14 @@ class FakeAction(abase.BaseAction):
pass
def execute(self):
raise Exception()
@classmethod
def namespace(cls):
return "TESTING"
@classmethod
def get_name(cls):
return 'fake_action'
raise ExpectedException()
class TestDefaultWorkFlowEngine(base.DbTestCase):
def setUp(self):
super(TestDefaultWorkFlowEngine, self).setUp()
self.engine = tflow.DefaultWorkFlowEngine(
config=mock.Mock(),
context=self.context,
applier_manager=mock.MagicMock())
@@ -86,6 +82,7 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
new_action = objects.Action(self.context, **action)
new_action.create(self.context)
new_action.save()
return new_action
def check_action_state(self, action, expected_state):
@@ -175,18 +172,13 @@ class TestDefaultWorkFlowEngine(base.DbTestCase):
self.check_action_state(second, objects.action.State.SUCCEEDED)
self.check_action_state(third, objects.action.State.FAILED)
@mock.patch("watcher.common.loader.default.DriverManager")
def test_execute_with_action_exception(self, m_driver):
m_driver.return_value = driver.DriverManager.make_test_instance(
extension=extension.Extension(name=FakeAction.get_name(),
entry_point="%s:%s" % (
FakeAction.__module__,
FakeAction.__name__),
plugin=FakeAction,
obj=None),
namespace=FakeAction.namespace())
actions = [self.create_action("dontcare", {}, None)]
@mock.patch.object(factory.ActionFactory, "make_action")
def test_execute_with_action_exception(self, m_make_action):
actions = [self.create_action("fake_action", {}, None)]
m_make_action.return_value = FakeAction(mock.Mock())
self.assertRaises(exception.WorkflowExecutionException,
self.engine.execute, actions)
exc = self.assertRaises(exception.WorkflowExecutionException,
self.engine.execute, actions)
self.assertIsInstance(exc.kwargs['error'], ExpectedException)
self.check_action_state(actions[0], objects.action.State.FAILED)

28
watcher/tests/common/loader/FakeLoadable.py
View File

@@ -1,28 +0,0 @@
# -*- encoding: utf-8 -*-
# Copyright (c) 2015 b<>com
#
# 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 abc
import six
@six.add_metaclass(abc.ABCMeta)
class FakeLoadable(object):
@classmethod
def namespace(cls):
return "TESTING"
@classmethod
def get_name(cls):
return 'fake'

94
watcher/tests/common/loader/test_loader.py
View File

@@ -18,36 +18,88 @@ from __future__ import unicode_literals
import mock
from oslotest.base import BaseTestCase
from stevedore.driver import DriverManager
from oslo_config import cfg
from stevedore import driver as drivermanager
from stevedore.extension import Extension
from watcher.common import exception
from watcher.common.loader.default import DefaultLoader
from watcher.tests.common.loader.FakeLoadable import FakeLoadable
from watcher.common.loader import default
from watcher.common.loader import loadable
from watcher.tests import base
class TestLoader(BaseTestCase):
@mock.patch("watcher.common.loader.default.DriverManager")
def test_load_driver_no_opt(self, m_driver_manager):
m_driver_manager.return_value = DriverManager.make_test_instance(
extension=Extension(name=FakeLoadable.get_name(),
entry_point="%s:%s" % (
FakeLoadable.__module__,
FakeLoadable.__name__),
plugin=FakeLoadable,
obj=None),
namespace=FakeLoadable.namespace())
class FakeLoadable(loadable.Loadable):
loader_manager = DefaultLoader(namespace='TESTING')
loaded_driver = loader_manager.load(name='fake')
@classmethod
def get_config_opts(cls):
return []
self.assertEqual(FakeLoadable.get_name(), loaded_driver.get_name())
@mock.patch("watcher.common.loader.default.DriverManager")
def test_load_driver_bad_plugin(self, m_driver_manager):
class FakeLoadableWithOpts(loadable.Loadable):
@classmethod
def get_config_opts(cls):
return [
cfg.StrOpt("test_opt", default="fake_with_opts"),
]
class TestLoader(base.TestCase):
def setUp(self):
super(TestLoader, self).setUp()
def _fake_parse(self, *args, **kw):
return cfg.ConfigOpts._parse_cli_opts(cfg.CONF, [])
cfg.CONF._parse_cli_opts = _fake_parse
def test_load_loadable_no_opt(self):
fake_driver = drivermanager.DriverManager.make_test_instance(
extension=Extension(
name="fake",
entry_point="%s:%s" % (FakeLoadable.__module__,
FakeLoadable.__name__),
plugin=FakeLoadable,
obj=None),
namespace="TESTING")
loader_manager = default.DefaultLoader(namespace='TESTING')
with mock.patch.object(drivermanager,
"DriverManager") as m_driver_manager:
m_driver_manager.return_value = fake_driver
loaded_driver = loader_manager.load(name='fake')
self.assertIsInstance(loaded_driver, FakeLoadable)
@mock.patch("watcher.common.loader.default.drivermanager.DriverManager")
def test_load_loadable_bad_plugin(self, m_driver_manager):
m_driver_manager.side_effect = Exception()
loader_manager = DefaultLoader(namespace='TESTING')
loader_manager = default.DefaultLoader(namespace='TESTING')
self.assertRaises(exception.LoadingError, loader_manager.load,
name='bad_driver')
def test_load_loadable_with_opts(self):
fake_driver = drivermanager.DriverManager.make_test_instance(
extension=Extension(
name="fake",
entry_point="%s:%s" % (FakeLoadableWithOpts.__module__,
FakeLoadableWithOpts.__name__),
plugin=FakeLoadableWithOpts,
obj=None),
namespace="TESTING")
loader_manager = default.DefaultLoader(namespace='TESTING')
with mock.patch.object(drivermanager,
"DriverManager") as m_driver_manager:
m_driver_manager.return_value = fake_driver
loaded_driver = loader_manager.load(name='fake')
self.assertIsInstance(loaded_driver, FakeLoadableWithOpts)
self.assertEqual(
"fake_with_opts", loaded_driver.config.get("test_opt"))
self.assertEqual(
"fake_with_opts", loaded_driver.config.test_opt)

14
watcher/tests/decision_engine/fake_strategies.py
View File

@@ -14,8 +14,12 @@
# See the License for the specific language governing permissions and
# limitations under the License.
from oslo_config import cfg
from watcher.decision_engine.strategy.strategies import base as base_strategy
CONF = cfg.CONF
class FakeStrategy(base_strategy.BaseStrategy):
@@ -48,6 +52,10 @@ class FakeStrategy(base_strategy.BaseStrategy):
def get_translatable_goal_display_name(cls):
return cls.GOAL_DISPLAY_NAME
@classmethod
def get_config_opts(cls):
return []
def execute(self, original_model):
pass
@@ -58,6 +66,12 @@ class FakeDummy1Strategy1(FakeStrategy):
NAME = "STRATEGY_1"
DISPLAY_NAME = "Strategy 1"
@classmethod
def get_config_opts(cls):
return [
cfg.StrOpt('test_opt', help="Option used for testing."),
]
class FakeDummy1Strategy2(FakeStrategy):
GOAL_NAME = "DUMMY_1"

7
watcher/tests/decision_engine/planner/test_default_planner.py
View File

@@ -57,7 +57,7 @@ class SolutionFakerSingleHyp(object):
class TestActionScheduling(base.DbTestCase):
def test_schedule_actions(self):
default_planner = pbase.DefaultPlanner()
default_planner = pbase.DefaultPlanner(mock.Mock())
audit = db_utils.create_test_audit(uuid=utils.generate_uuid())
solution = dsol.DefaultSolution()
@@ -83,7 +83,7 @@ class TestActionScheduling(base.DbTestCase):
self.assertEqual("migrate", actions[0].action_type)
def test_schedule_two_actions(self):
default_planner = pbase.DefaultPlanner()
default_planner = pbase.DefaultPlanner(mock.Mock())
audit = db_utils.create_test_audit(uuid=utils.generate_uuid())
solution = dsol.DefaultSolution()
@@ -115,9 +115,10 @@ class TestActionScheduling(base.DbTestCase):
class TestDefaultPlanner(base.DbTestCase):
def setUp(self):
super(TestDefaultPlanner, self).setUp()
self.default_planner = pbase.DefaultPlanner()
self.default_planner = pbase.DefaultPlanner(mock.Mock())
obj_utils.create_test_audit_template(self.context)
p = mock.patch.object(db_api.BaseConnection, 'create_action_plan')

47
watcher/tests/decision_engine/strategy/loading/test_default_strategy_loader.py
View File

@@ -15,8 +15,9 @@
# limitations under the License.
from __future__ import unicode_literals
from mock import patch
import mock
from stevedore import extension
from watcher.common import exception
from watcher.decision_engine.strategy.loading import default as default_loading
from watcher.decision_engine.strategy.strategies import dummy_strategy
@@ -25,38 +26,38 @@ from watcher.tests import base
class TestDefaultStrategyLoader(base.TestCase):
strategy_loader = default_loading.DefaultStrategyLoader()
def test_load_strategy_with_empty_model(self):
self.assertRaises(
exception.LoadingError, self.strategy_loader.load, None)
strategy_loader = default_loading.DefaultStrategyLoader()
self.assertRaises(exception.LoadingError, strategy_loader.load, None)
def test_load_strategy_is_basic(self):
strategy_loader = default_loading.DefaultStrategyLoader()
expected_strategy = 'basic'
selected_strategy = self.strategy_loader.load(expected_strategy)
selected_strategy = strategy_loader.load(expected_strategy)
self.assertEqual(
selected_strategy.id,
expected_strategy,
'The default strategy should be basic')
@patch("watcher.common.loader.default.ExtensionManager")
def test_strategy_loader(self, m_extension_manager):
def test_strategy_loader(self):
dummy_strategy_name = "dummy"
# Set up the fake Stevedore extensions
m_extension_manager.return_value = extension.\
ExtensionManager.make_test_instance(
extensions=[extension.Extension(
name=dummy_strategy_name,
entry_point="%s:%s" % (
dummy_strategy.DummyStrategy.__module__,
dummy_strategy.DummyStrategy.__name__),
plugin=dummy_strategy.DummyStrategy,
obj=None,
)],
namespace="watcher_strategies",
)
strategy_loader = default_loading.DefaultStrategyLoader()
loaded_strategy = strategy_loader.load("dummy")
fake_extmanager_call = extension.ExtensionManager.make_test_instance(
extensions=[extension.Extension(
name=dummy_strategy_name,
entry_point="%s:%s" % (
dummy_strategy.DummyStrategy.__module__,
dummy_strategy.DummyStrategy.__name__),
plugin=dummy_strategy.DummyStrategy,
obj=None,
)],
namespace="watcher_strategies",
)
with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
m_ext_manager.return_value = fake_extmanager_call
strategy_loader = default_loading.DefaultStrategyLoader()
loaded_strategy = strategy_loader.load("dummy")
self.assertEqual("dummy", loaded_strategy.id)
self.assertEqual("Dummy strategy", loaded_strategy.display_name)
@@ -67,5 +68,5 @@ class TestDefaultStrategyLoader(base.TestCase):
self.assertIsInstance(loaded_strategy, dummy_strategy.DummyStrategy)
def test_endpoints(self):
for endpoint in self.strategy_loader.list_available():
for endpoint in strategy_loader.list_available():
self.assertIsNotNone(self.strategy_loader.load(endpoint))

93
watcher/tests/test_list_opts.py
View File

@@ -14,18 +14,97 @@
# See the License for the specific language governing permissions and
# limitations under the License.
from __future__ import absolute_import
from __future__ import unicode_literals
import mock
from stevedore import extension
import watcher.opts as opt
from watcher.tests.base import BaseTestCase
from watcher import opts
from watcher.tests import base
from watcher.tests.decision_engine import fake_strategies
class TestListOpts(BaseTestCase):
class TestListOpts(base.TestCase):
def setUp(self):
super(TestListOpts, self).setUp()
self.base_sections = [
'api', 'watcher_decision_engine', 'watcher_applier',
'watcher_planner', 'nova_client', 'glance_client',
'cinder_client', 'ceilometer_client', 'neutron_client',
'watcher_clients_auth']
def test_run_list_opts(self):
result = opt.list_opts()
expected_sections = self.base_sections
result = opts.list_opts()
self.assertIsNotNone(result)
for section_name, options in result:
self.assertIn(section_name, expected_sections)
self.assertTrue(len(options))
def test_list_opts_no_opts(self):
expected_sections = self.base_sections
# Set up the fake Stevedore extensions
fake_extmanager_call = extension.ExtensionManager.make_test_instance(
extensions=[extension.Extension(
name=fake_strategies.FakeDummy1Strategy2.get_name(),
entry_point="%s:%s" % (
fake_strategies.FakeDummy1Strategy2.__module__,
fake_strategies.FakeDummy1Strategy2.__name__),
plugin=fake_strategies.FakeDummy1Strategy2,
obj=None,
)],
namespace="watcher_strategies",
)
def m_list_available(namespace):
if namespace == "watcher_strategies":
return fake_extmanager_call
else:
return extension.ExtensionManager.make_test_instance(
extensions=[], namespace=namespace)
with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
m_ext_manager.side_effect = m_list_available
result = opts.list_opts()
self.assertIsNotNone(result)
for section_name, options in result:
self.assertIn(section_name, expected_sections)
self.assertTrue(len(options))
def test_list_opts_with_opts(self):
expected_sections = self.base_sections + [
'watcher_strategies.STRATEGY_1']
# Set up the fake Stevedore extensions
fake_extmanager_call = extension.ExtensionManager.make_test_instance(
extensions=[extension.Extension(
name=fake_strategies.FakeDummy1Strategy1.get_name(),
entry_point="%s:%s" % (
fake_strategies.FakeDummy1Strategy1.__module__,
fake_strategies.FakeDummy1Strategy1.__name__),
plugin=fake_strategies.FakeDummy1Strategy1,
obj=None,
)],
namespace="watcher_strategies",
)
def m_list_available(namespace):
if namespace == "watcher_strategies":
return fake_extmanager_call
else:
return extension.ExtensionManager.make_test_instance(
extensions=[], namespace=namespace)
with mock.patch.object(extension, "ExtensionManager") as m_ext_manager:
m_ext_manager.side_effect = m_list_available
result = opts.list_opts()
self.assertIsNotNone(result)
for section_name, options in result:
self.assertIn(section_name, expected_sections)
self.assertTrue(len(options))
result_map = dict(result)
strategy_opts = result_map['watcher_strategies.STRATEGY_1']
self.assertEqual(['test_opt'], [opt.name for opt in strategy_opts])