[lambda] Implement ListFunctions, GetFunction, and DeleteFunction

moto/awslambda/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import unicode_literals
+from .models import lambda_backends
+from ..core.models import MockAWS
+
+
+lambda_backend = lambda_backends['us-east-1']
+
+
+def mock_lambda(func=None):
+    if func:
+        return MockAWS(lambda_backends)(func)
+    else:
+        return MockAWS(lambda_backends)

moto/awslambda/models.py

@@ -0,0 +1,82 @@
+from __future__ import unicode_literals
+
+import datetime
+import boto.awslambda
+from moto.core import BaseBackend
+
+
+class LambdaFunction(object):
+
+    def __init__(self, spec):
+        self.function_name = spec['FunctionName']
+        self.run_time = spec['Runtime']
+        self.role = spec['Role']
+        self.handler = spec['Handler']
+        self.description = spec['Description']
+        self.timeout = spec['Timeout']
+        self.memory_size = spec['MemorySize']
+        self.vpc_config = spec.get('VpcConfig', {})
+        self.code = spec['Code']
+
+        self.version = '$LATEST'
+        self.last_modified = datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')
+        self.code_size = 210  # hello world function
+        self.code_sha_256 = 'b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9' # hello world function
+        self.function_arn = 'arn:aws:lambda:123456789012:function:{}'.format(self.function_name)
+
+    def __repr__(self):
+        return json.dumps(self.get_configuration())
+
+    def get_configuration(self):
+        return {
+            "CodeSha256": self.code_sha_256,
+            "CodeSize": self.code_size,
+            "Description": self.description,
+            "FunctionArn": self.function_arn,
+            "FunctionName": self.function_name,
+            "Handler": self.handler,
+            "LastModified": self.last_modified,
+            "MemorySize": self.memory_size,
+            "Role": self.role,
+            "Runtime": self.run_time,
+            "Timeout": self.timeout,
+            "Version": self.version,
+            "VpcConfig": self.vpc_config,
+        }
+
+    def get_code(self):
+        return {
+            "Code": {
+                "Location": "s3://lambda-functions.aws.amazon.com/{}".format(self.code['S3Key']),
+                "RepositoryType": "S3"
+            },
+            "Configuration": self.get_configuration(),
+        }
+
+
+class LambdaBackend(BaseBackend):
+
+    def __init__(self):
+        self._functions = {}
+    
+    def has_function(self, function_name):
+        return function_name in self._functions
+
+    def create_function(self, spec):
+        fn = LambdaFunction(spec)
+        self._functions[fn.function_name] = fn
+        return fn
+
+    def get_function(self, function_name):
+        return self._functions[function_name]
+
+    def delete_function(self, function_name):
+        del self._functions[function_name]
+
+    def list_functions(self):
+        return self._functions.values()
+
+
+lambda_backends = {}
+for region in boto.awslambda.regions():
+    lambda_backends[region.name] = LambdaBackend()

moto/awslambda/responses.py

@@ -0,0 +1,78 @@
+from __future__ import unicode_literals
+
+import json
+import re
+
+from moto.core.responses import BaseResponse
+from .models import lambda_backends
+
+
+class LambdaResponse(BaseResponse):
+    
+    @classmethod
+    def root(cls, request, full_url, headers):
+        if request.method == 'GET':
+            return cls()._list_functions(request, full_url, headers)
+        elif request.method == 'POST':
+            return cls()._create_function(request, full_url, headers)
+        else:
+            raise ValueError("Cannot handle request")
+
+    @classmethod
+    def function(cls, request, full_url, headers):
+        if request.method == 'GET':
+            return cls()._get_function(request, full_url, headers)
+        elif request.method == 'DELETE':
+            return cls()._delete_function(request, full_url, headers)
+        else:
+            raise ValueError("Cannot handle request")
+
+    def _list_functions(self, request, full_url, headers):
+        lambda_backend = self.get_lambda_backend(full_url)
+        return 200, headers, json.dumps({
+            "Functions": [fn.get_configuration() for fn in lambda_backend.list_functions()],
+            "NextMarker": "aws-lambda-next-marker",
+        })
+
+    def _create_function(self, request, full_url, headers):
+        lambda_backend = self.get_lambda_backend(full_url)
+
+        spec = json.loads(request.body)
+        fn = lambda_backend.create_function(spec)
+        config = fn.get_configuration()
+        return 200, headers, json.dumps(config)
+
+    def _delete_function(self, request, full_url, headers):
+        lambda_backend = self.get_lambda_backend(full_url)
+
+        function_name = request.path.split('/')[-1]
+
+        if lambda_backend.has_function(function_name):
+            lambda_backend.delete_function(function_name)
+            return 204, headers, ""
+        else:
+            return 404, headers, "{}"
+
+    def _get_function(self, request, full_url, headers):
+        lambda_backend = self.get_lambda_backend(full_url)
+
+        function_name = request.path.split('/')[-1]
+
+        if lambda_backend.has_function(function_name):
+            fn = lambda_backend.get_function(function_name)
+            code = fn.get_code()
+            return 200, headers, json.dumps(code)
+        else:
+            return 404, headers, "{}"
+    
+    def get_lambda_backend(self, full_url):
+        from moto.awslambda.models import lambda_backends
+        region = self._get_aws_region(full_url)
+        return lambda_backends[region]
+
+    def _get_aws_region(self, full_url):
+        region = re.search(self.region_regex, full_url)
+        if region:
+            return region.group(1)
+        else:
+            return self.default_region

moto/awslambda/urls.py

@@ -0,0 +1,12 @@
+from __future__ import unicode_literals
+from .responses import LambdaResponse
+
+url_bases = [
+    "https?://lambda.(.+).amazonaws.com",
+]
+
+url_paths = {
+    # double curly braces because the `format()` method is called on the strings
+    '{0}/\d{{4}}-\d{{2}}-\d{{2}}/functions/?$': LambdaResponse.root,
+    '{0}/\d{{4}}-\d{{2}}-\d{{2}}/functions/(?P<function_name>[\w_-]+)/?$': LambdaResponse.function,
+}