Rewriting some tests and also rewriting the MockAWS module to automatically map …

…all responses in responses.py to mocks in the client.

@@ -13,8 +13,6 @@
 
 
 import logging
 import logging
 
 
-from botocore.exceptions import ClientError
-
 import kappa.aws
 import kappa.aws
 
 
 LOG = logging.getLogger(__name__)
 LOG = logging.getLogger(__name__)

+{
+  "Statement":[
+    {"Condition":
+      {"ArnLike":{"AWS:SourceArn":"arn:aws:sns:us-east-1:123456789012:lambda_topic"}},
+      "Resource":"arn:aws:lambda:us-east-1:123456789023:function:messageStore",
+      "Action":"lambda:invokeFunction",
+      "Principal":{"Service":"sns.amazonaws.com"},
+      "Sid":"sns invoke","Effect":"Allow"
+    }],
+  "Id":"default",
+  "Version":"2012-10-17"
+}

+import inspect
+
 import mock
 import mock
 
 
 import tests.unit.responses as responses
 import tests.unit.responses as responses
@@ -6,40 +8,23 @@ import tests.unit.responses as responses
 class MockAWS(object):
 class MockAWS(object):
 
 
     def __init__(self, profile=None, region=None):
     def __init__(self, profile=None, region=None):
-        pass
+        self.response_map = {}
+        for name, value in inspect.getmembers(responses):
+            if name.startswith('__'):
+                continue
+            if '_' in name:
+                service_name, request_name = name.split('_', 1)
+                if service_name not in self.response_map:
+                    self.response_map[service_name] = {}
+                self.response_map[service_name][request_name] = value
 
 
     def create_client(self, client_name):
     def create_client(self, client_name):
         client = None
         client = None
-        if client_name == 'logs':
-            client = mock.Mock()
-            choices = responses.logs_describe_log_groups
-            client.describe_log_groups = mock.Mock(
-                side_effect=choices)
-            choices = responses.logs_describe_log_streams
-            client.describe_log_streams = mock.Mock(
-                side_effect=choices)
-            choices = responses.logs_get_log_events
-            client.get_log_events = mock.Mock(
-                side_effect=choices)
-        if client_name == 'cloudformation':
-            client = mock.Mock()
-            choices = responses.cfn_list_stack_resources
-            client.list_stack_resources = mock.Mock(
-                side_effect=choices)
-            choices = responses.cfn_describe_stacks
-            client.describe_stacks = mock.Mock(
-                side_effect=choices)
-            choices = responses.cfn_create_stack
-            client.create_stack = mock.Mock(
-                side_effect=choices)
-            choices = responses.cfn_delete_stack
-            client.delete_stack = mock.Mock(
-                side_effect=choices)
-        if client_name == 'iam':
+        if client_name in self.response_map:
             client = mock.Mock()
             client = mock.Mock()
-            choices = responses.iam_get_role
-            client.get_role = mock.Mock(
-                side_effect=choices)
+            for request in self.response_map[client_name]:
+                response = self.response_map[client_name][request]
+                setattr(client, request, mock.Mock(side_effect=response))
         return client
         return client
 
 
 
 

+# Copyright (c) 2015 Mitch Garnaat http://garnaat.org/
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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 unittest
+import os
+
+import mock
+
+from kappa.policy import Policy
+from tests.unit.mock_aws import get_aws
+
+Config1 = {
+    'name': 'FooPolicy',
+    'description': 'This is the Foo policy',
+    'document': 'FooPolicy.json'}
+
+Config2 = {
+    'name': 'BazPolicy',
+    'description': 'This is the Baz policy',
+    'document': 'BazPolicy.json'}
+
+
+def path(filename):
+    return os.path.join(os.path.dirname(__file__), 'data', filename)
+
+
+class TestPolicy(unittest.TestCase):
+
+    def setUp(self):
+        self.aws_patch = mock.patch('kappa.aws.get_aws', get_aws)
+        self.mock_aws = self.aws_patch.start()
+        Config1['document'] = path(Config1['document'])
+        Config2['document'] = path(Config2['document'])
+
+    def tearDown(self):
+        self.aws_patch.stop()
+
+    def test_properties(self):
+        mock_context = mock.Mock()
+        policy = Policy(mock_context, Config1)
+        self.assertEqual(policy.name, Config1['name'])
+        self.assertEqual(policy.document, Config1['document'])
+        self.assertEqual(policy.description, Config1['description'])
+
+    def test_exists(self):
+        mock_context = mock.Mock()
+        policy = Policy(mock_context, Config1)
+        self.assertTrue(policy.exists())
+
+    def test_not_exists(self):
+        mock_context = mock.Mock()
+        policy = Policy(mock_context, Config2)
+        self.assertFalse(policy.exists())
+
+    def test_create(self):
+        mock_context = mock.Mock()
+        policy = Policy(mock_context, Config2)
+        policy.create()
+
+    def test_delete(self):
+        mock_context = mock.Mock()
+        policy = Policy(mock_context, Config1)
+        policy.delete()

@@ -12,56 +12,47 @@
 # language governing permissions and limitations under the License.
 # language governing permissions and limitations under the License.
 
 
 import unittest
 import unittest
-import os
 
 
 import mock
 import mock
 
 
-from kappa.stack import Stack
+from kappa.role import Role
 from tests.unit.mock_aws import get_aws
 from tests.unit.mock_aws import get_aws
 
 
-Config = {
-    'template': 'roles.cf',
-    'stack_name': 'FooBar',
-    'exec_role': 'ExecRole',
-    'invoke_role': 'InvokeRole'}
+Config1 = {'name': 'FooRole'}
 
 
+Config2 = {'name': 'BazRole'}
 
 
-def path(filename):
-    return os.path.join(os.path.dirname(__file__), 'data', filename)
 
 
-
-class TestStack(unittest.TestCase):
+class TestRole(unittest.TestCase):
 
 
     def setUp(self):
     def setUp(self):
         self.aws_patch = mock.patch('kappa.aws.get_aws', get_aws)
         self.aws_patch = mock.patch('kappa.aws.get_aws', get_aws)
         self.mock_aws = self.aws_patch.start()
         self.mock_aws = self.aws_patch.start()
-        Config['template'] = path(Config['template'])
 
 
     def tearDown(self):
     def tearDown(self):
         self.aws_patch.stop()
         self.aws_patch.stop()
 
 
     def test_properties(self):
     def test_properties(self):
         mock_context = mock.Mock()
         mock_context = mock.Mock()
-        stack = Stack(mock_context, Config)
-        self.assertEqual(stack.name, Config['stack_name'])
-        self.assertEqual(stack.template_path, Config['template'])
-        self.assertEqual(stack.exec_role, Config['exec_role'])
-        self.assertEqual(stack.invoke_role, Config['invoke_role'])
-        self.assertEqual(
-            stack.invoke_role_arn,
-            'arn:aws:iam::0123456789012:role/TestKinesis-InvokeRole-FOO')
+        role = Role(mock_context, Config1)
+        self.assertEqual(role.name, Config1['name'])
 
 
     def test_exists(self):
     def test_exists(self):
         mock_context = mock.Mock()
         mock_context = mock.Mock()
-        stack = Stack(mock_context, Config)
-        self.assertTrue(stack.exists())
+        role = Role(mock_context, Config1)
+        self.assertTrue(role.exists())
+
+    def test_not_exists(self):
+        mock_context = mock.Mock()
+        role = Role(mock_context, Config2)
+        self.assertFalse(role.exists())
 
 
-    def test_update(self):
+    def test_create(self):
         mock_context = mock.Mock()
         mock_context = mock.Mock()
-        stack = Stack(mock_context, Config)
-        stack.update()
+        role = Role(mock_context, Config2)
+        role.create()
 
 
     def test_delete(self):
     def test_delete(self):
         mock_context = mock.Mock()
         mock_context = mock.Mock()
-        stack = Stack(mock_context, Config)
-        stack.delete()
+        role = Role(mock_context, Config1)
+        role.delete()