Merge "Enabled config parameters to plugins"

watcher/tests/decision_engine/fake_strategies.py

@@ -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"

watcher/tests/decision_engine/planner/test_default_planner.py

@@ -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')

watcher/tests/decision_engine/strategy/loading/test_default_strategy_loader.py

@@ -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))