test: use an uniform pattern for mocking Provider

Author: danielkza

stacker/tests/actions/test_build.py

@@ -2,9 +2,8 @@
 from __future__ import division
 from __future__ import absolute_import
 from builtins import str
-import unittest
 from collections import namedtuple
-
+import unittest
 import mock
 
 from stacker import exceptions
@@ -18,7 +17,6 @@
 from stacker.blueprints.variables.types import CFNString
 from stacker.context import Context, Config
 from stacker.exceptions import StackDidNotChange, StackDoesNotExist
-from stacker.providers.base import BaseProvider
 from stacker.providers.aws.default import Provider
 from stacker.status import (
     NotSubmittedStatus,
@@ -29,7 +27,7 @@
     FAILED
 )
 
-from ..factories import MockThreadingEvent, MockProviderBuilder
+from ..factories import MockThreadingEvent, MockProviderBuilder, mock_provider
 
 
 def mock_stack_parameters(parameters):
@@ -41,27 +39,10 @@ def mock_stack_parameters(parameters):
     }
 
 
-class TestProvider(BaseProvider):
-    def __init__(self, outputs=None, *args, **kwargs):
-        self._outputs = outputs or {}
-
-    def set_outputs(self, outputs):
-        self._outputs = outputs
-
-    def get_stack(self, stack_name, **kwargs):
-        if stack_name not in self._outputs:
-            raise exceptions.StackDoesNotExist(stack_name)
-        return {"name": stack_name, "outputs": self._outputs[stack_name]}
-
-    def get_outputs(self, stack_name, *args, **kwargs):
-        stack = self.get_stack(stack_name)
-        return stack["outputs"]
-
-
 class TestBuildAction(unittest.TestCase):
     def setUp(self):
         self.context = Context(config=Config({"namespace": "namespace"}))
-        self.provider = TestProvider()
+        self.provider = mock_provider()
         self.build_action = build.Action(
             self.context,
             provider_builder=MockProviderBuilder(self.provider))

stacker/tests/factories.py

@@ -2,11 +2,13 @@
 from __future__ import division
 from __future__ import absolute_import
 from builtins import object
-from mock import MagicMock
+
+import mock
 
 from stacker.context import Context
 from stacker.config import Config, Stack
-from stacker.lookups import Lookup
+from stacker.exceptions import StackDoesNotExist, StackUpdateBadStatus
+from stacker.providers.base import BaseProvider
 
 
 class MockThreadingEvent(object):
@@ -23,23 +25,72 @@ def build(self, region=None, profile=None):
         return self.provider
 
 
-def mock_provider(**kwargs):
-    return MagicMock(**kwargs)
+class MockProvider(BaseProvider):
+    def __init__(self, outputs=None):
+        self._stacks = {}
+        for stack_name, stack_outputs in (outputs or {}).items():
+            self._stacks[stack_name] = {
+                "StackName": stack_name,
+                "Outputs": stack_outputs,
+                "StackStatus": "CREATED"
+            }
+
+    def get_stack(self, stack_name, **kwargs):
+        try:
+            return self._stacks[stack_name]
+        except KeyError:
+            raise StackDoesNotExist(stack_name)
+
+    def get_outputs(self, stack_name, *args, **kwargs):
+        return self.get_stack(stack_name)["Outputs"]
+
+    def get_stack_status(self, stack_name, *args, **kwargs):
+        return self.get_stack(stack_name)["StackStatus"]
+
+    def create_stack(self, stack_name, *args, **kwargs):
+        try:
+            stack = self.get_stack(stack_name)
+            status = self.get_stack_status(stack)
+            if status != "DELETED":
+                raise StackUpdateBadStatus(stack_name, status, "can't create")
+        except StackDoesNotExist:
+            pass
+
+        return None
+
+    def update_stack(self, stack_name, *args, **kwargs):
+        stack = self.get_stack(stack_name)
+        status = self.get_stack_status(stack)
+        if status == "DELETED":
+            raise StackUpdateBadStatus(stack_name, status, "can't update")
+
+        stack["StackStatus"] = "UPDATED"
+        return None
 
+    def destroy_stack(self, stack_name, *args, **kwargs):
+        stack = self.get_stack(stack_name)
+        status = self.get_stack_status(stack)
+        if status == "DELETED":
+            raise StackUpdateBadStatus(stack_name, status, "can't destroy")
 
-def mock_context(namespace="default", extra_config_args=None, **kwargs):
+        stack["StackStatus"] = "DELETED"
+        return None
+
+
+def mock_provider(outputs=None, **kwargs):
+    provider = mock.MagicMock(wraps=MockProvider(outputs), **kwargs)
+    return provider
+
+
+def mock_context(namespace="default", extra_config_args=None,
+                 environment=None, **kwargs):
     config_args = {"namespace": namespace}
     if extra_config_args:
         config_args.update(extra_config_args)
+
     config = Config(config_args)
-    if kwargs.get("environment"):
-        return Context(
-            config=config,
-            **kwargs)
-    return Context(
-        config=config,
-        environment={},
-        **kwargs)
+    environment = environment or {}
+    return Context(config=config, environment=environment, **kwargs)
 
 
 def generate_definition(base_name, stack_id, **overrides):
@@ -53,12 +104,6 @@ def generate_definition(base_name, stack_id, **overrides):
     return Stack(definition)
 
 
-def mock_lookup(lookup_input, lookup_type, raw=None):
-    if raw is None:
-        raw = "%s %s" % (lookup_type, lookup_input)
-    return Lookup(type=lookup_type, input=lookup_input, raw=raw)
-
-
 class SessionStub(object):
 
     """Stubber class for boto3 sessions made with session_cache.get_session()

stacker/tests/lookups/handlers/test_default.py

@@ -1,22 +1,18 @@
 from __future__ import print_function
 from __future__ import division
 from __future__ import absolute_import
-from mock import MagicMock
 import unittest
 
-from stacker.context import Context
 from stacker.lookups.handlers.default import DefaultLookup
 
+from ...factories import mock_context, mock_provider
 
-class TestDefaultLookup(unittest.TestCase):
 
+class TestDefaultLookup(unittest.TestCase):
     def setUp(self):
-        self.provider = MagicMock()
-        self.context = Context(
-            environment={
-                'namespace': 'test',
-                'env_var': 'val_in_env'}
-        )
+        self.provider = mock_provider()
+        self.context = mock_context(
+            namespace='test', environment={'env_var': 'val_in_env'})
 
     def test_env_var_present(self):
         lookup_val = "env_var::fallback"

stacker/tests/lookups/handlers/test_output.py

@@ -5,25 +5,22 @@
 import unittest
 
 from stacker.stack import Stack
-from ...factories import generate_definition
 from stacker.lookups.handlers.output import OutputLookup
 
+from ...factories import generate_definition, mock_context, mock_provider
 
-class TestOutputHandler(unittest.TestCase):
 
+class TestOutputHandler(unittest.TestCase):
     def setUp(self):
-        self.context = MagicMock()
+        stack_def = generate_definition("vpc", 1)
+        self.context = mock_context()
+        self.stack = Stack(definition=stack_def, context=self.context)
+        self.context.get_stacks = MagicMock(return_value=[self.stack])
+        self.provider = mock_provider(
+            outputs={self.stack.fqn: {"SomeOutput": "Test Output"}})
 
     def test_output_handler(self):
-        stack = Stack(
-            definition=generate_definition("vpc", 1),
-            context=self.context)
-        stack.set_outputs({
-            "SomeOutput": "Test Output"})
-        self.context.get_stack.return_value = stack
-        value = OutputLookup.handle("stack-name::SomeOutput",
-                                    context=self.context)
+        value = OutputLookup.handle("{}::SomeOutput".format(self.stack.name),
+                                    context=self.context,
+                                    provider=self.provider)
         self.assertEqual(value, "Test Output")
-        self.assertEqual(self.context.get_stack.call_count, 1)
-        args = self.context.get_stack.call_args
-        self.assertEqual(args[0][0], "stack-name")

stacker/tests/lookups/handlers/test_rxref.py

@@ -1,30 +1,24 @@
 from __future__ import print_function
 from __future__ import division
 from __future__ import absolute_import
-from mock import MagicMock
 import unittest
 
 from stacker.lookups.handlers.rxref import RxrefLookup
-from ....context import Context
-from ....config import Config
+
+from ...factories import mock_context, mock_provider
 
 
 class TestRxrefHandler(unittest.TestCase):
 
     def setUp(self):
-        self.provider = MagicMock()
-        self.context = Context(
-            config=Config({"namespace": "ns"})
-        )
+        self.context = mock_context()
+        self.stack_name = "stack-name"
+        self.stack_fqn = self.context.get_fqn(self.stack_name)
+        self.provider = mock_provider(
+            outputs={self.stack_fqn: {"SomeOutput": "Test Output"}})
 
     def test_rxref_handler(self):
-        self.provider.get_output.return_value = "Test Output"
-
-        value = RxrefLookup.handle("fully-qualified-stack-name::SomeOutput",
+        value = RxrefLookup.handle("{}::SomeOutput".format(self.stack_name),
                                    provider=self.provider,
                                    context=self.context)
         self.assertEqual(value, "Test Output")
-
-        args = self.provider.get_output.call_args
-        self.assertEqual(args[0][0], "ns-fully-qualified-stack-name")
-        self.assertEqual(args[0][1], "SomeOutput")

stacker/tests/lookups/handlers/test_xref.py

@@ -1,25 +1,23 @@
 from __future__ import print_function
 from __future__ import division
 from __future__ import absolute_import
-from mock import MagicMock
 import unittest
 
 from stacker.lookups.handlers.xref import XrefLookup
 
+from ...factories import mock_context, mock_provider
+
 
 class TestXrefHandler(unittest.TestCase):
 
     def setUp(self):
-        self.provider = MagicMock()
-        self.context = MagicMock()
+        self.stack_fqn = "fully-qualified-stack-name"
+        self.context = mock_context()
+        self.provider = mock_provider(
+            outputs={self.stack_fqn: {"SomeOutput": "Test Output"}})
 
     def test_xref_handler(self):
-        self.provider.get_output.return_value = "Test Output"
-        value = XrefLookup.handle("fully-qualified-stack-name::SomeOutput",
+        value = XrefLookup.handle("{}::SomeOutput".format(self.stack_fqn),
                                   provider=self.provider,
                                   context=self.context)
         self.assertEqual(value, "Test Output")
-        self.assertEqual(self.context.get_fqn.call_count, 0)
-        args = self.provider.get_output.call_args
-        self.assertEqual(args[0][0], "fully-qualified-stack-name")
-        self.assertEqual(args[0][1], "SomeOutput")

stacker/tests/test_variables.py

@@ -11,7 +11,7 @@
 from stacker.variables import Variable
 from stacker.lookups import register_lookup_handler
 
-from .factories import TestProvider, mock_context
+from .factories import mock_context, mock_provider
 
 
 class MockLookup(LookupHandler):
@@ -29,7 +29,7 @@ def handle(cls, value, context, provider):
 class TestVariables(unittest.TestCase):
 
     def setUp(self):
-        self.provider = TestProvider()
+        self.provider = mock_provider()
         self.context = mock_context()
 
         register_lookup_handler("test", MockLookup)