tests: add unit, functional and integration tests

Why is this change necessary?

* Tests to ensure that the makefile based approach for provided runtimes
works.

Author: sriram-mv

.appveyor.yml

@@ -70,6 +70,9 @@ for:
     # setup Gradle
     - "choco install gradle"
 
+    # setup make
+    - "choco install make"
+
     # Echo final Path
     - "echo %PATH%"
 

aws_lambda_builders/workflows/provided_make/actions.py

@@ -52,11 +52,15 @@ def execute(self):
         :raises lambda_builders.actions.ActionFailedError: when Make Build fails.
         """
 
-       # Create the Artifacts Directory if it doesnt exist.
+        # Create the Artifacts Directory if it doesnt exist.
         if not self.osutils.exists(self.artifacts_dir):
             self.osutils.makedirs(self.artifacts_dir)
 
         try:
-            self.subprocess_make.run([f"build-{self.build_logical_id}"], env={"ARTIFACTS_DIR": self.artifacts_dir}, cwd=self.scratch_dir)
+            self.subprocess_make.run(
+                ["build-{logical_id}".format(logical_id=self.build_logical_id)],
+                env={"ARTIFACTS_DIR": self.artifacts_dir},
+                cwd=self.scratch_dir,
+            )
         except MakeExecutionError as ex:
             raise ActionFailedError(str(ex))

aws_lambda_builders/workflows/provided_make/make.py

@@ -46,7 +46,7 @@ def __init__(self, osutils, make_exe=None):
 
         self.make_exe = make_exe
 
-    def run(self, args, env, cwd=None):
+    def run(self, args, env=None, cwd=None):
 
         """
         Runs the action.
@@ -55,7 +55,7 @@ def run(self, args, env, cwd=None):
         :param args: Command line arguments to pass to Make
 
         :type args: dict
-        :param env : Environment variables dictionary to be passed into subprocess
+        :param env : environment variables dictionary to be passed into subprocess
 
         :type cwd: str
         :param cwd: Directory where to execute the command (defaults to current dir)
@@ -80,7 +80,9 @@ def run(self, args, env, cwd=None):
 
         LOG.debug("executing Make: %s", invoke_make)
 
-        p = self.osutils.popen(invoke_make, stdout=self.osutils.pipe, stderr=self.osutils.pipe, cwd=cwd, env=env)
+        p = self.osutils.popen(
+            invoke_make, stdout=self.osutils.pipe, stderr=self.osutils.pipe, cwd=cwd, env=env if env else {}
+        )
 
         out, err = p.communicate()
 

aws_lambda_builders/workflows/provided_make/make_resolver.py

@@ -4,11 +4,7 @@
 
 import os
 import platform
-import tarfile
 import subprocess
-import shutil
-
-from aws_lambda_builders.utils import which
 
 
 class OSUtils(object):
@@ -18,21 +14,8 @@ class OSUtils(object):
     unit test actions in memory
     """
 
-    def copy_file(self, file_path, destination_path):
-        return shutil.copy2(file_path, destination_path)
-
-    def extract_tarfile(self, tarfile_path, unpack_dir):
-        with tarfile.open(tarfile_path, "r:*") as tar:
-            tar.extractall(unpack_dir)
-
-    def file_exists(self, filename):
-        return os.path.isfile(filename)
-
-    def joinpath(self, *args):
-        return os.path.join(*args)
-
-    def exists(self, path):
-        return os.path.exists(path)
+    def exists(self, p):
+        return os.path.exists(p)
 
     def makedirs(self, path):
         return os.makedirs(path)
@@ -45,17 +28,5 @@ def popen(self, command, stdout=None, stderr=None, env=None, cwd=None):
     def pipe(self):
         return subprocess.PIPE
 
-    def dirname(self, path):
-        return os.path.dirname(path)
-
-    def remove_file(self, filename):
-        return os.remove(filename)
-
-    def abspath(self, path):
-        return os.path.abspath(path)
-
     def is_windows(self):
         return platform.system().lower() == "windows"
-
-    def which(self, executable, executable_search_paths=None):
-        return which(executable, executable_search_paths=executable_search_paths)

aws_lambda_builders/workflows/provided_make/utils.py

@@ -3,8 +3,8 @@
 """
 from aws_lambda_builders.workflow import BaseWorkflow, Capability
 from aws_lambda_builders.actions import CopySourceAction
+from aws_lambda_builders.path_resolver import PathResolver
 from .actions import ProvidedMakeAction
-from .make_resolver import MakeResolver
 from .utils import OSUtils
 from .make import SubProcessMake
 
@@ -32,17 +32,18 @@ def __init__(self, source_dir, artifacts_dir, scratch_dir, manifest_path, runtim
         options = kwargs.get("options") or {}
         build_logical_id = options.get("build_logical_id", None)
 
-        subprocess_make = SubProcessMake(make_exe=self.binaries['make'].binary_path, osutils=self.os_utils)
+        subprocess_make = SubProcessMake(make_exe=self.binaries["make"].binary_path, osutils=self.os_utils)
 
         make_action = ProvidedMakeAction(
             artifacts_dir,
-            scratch_dir, manifest_path, osutils=osutils, subprocess_make=subprocess_make, build_logical_id=build_logical_id
+            scratch_dir,
+            manifest_path,
+            osutils=self.os_utils,
+            subprocess_make=subprocess_make,
+            build_logical_id=build_logical_id,
         )
 
-        self.actions = [
-            CopySourceAction(source_dir, scratch_dir, excludes=self.EXCLUDED_FILES),
-            make_action
-        ]
+        self.actions = [CopySourceAction(source_dir, scratch_dir, excludes=self.EXCLUDED_FILES), make_action]
 
     def get_resolvers(self):
-        return [MakeResolver(executable_search_paths=self.executable_search_paths)]
+        return [PathResolver(runtime="provided", binary="make", executable_search_paths=self.executable_search_paths)]

aws_lambda_builders/workflows/provided_make/workflow.py

@@ -0,0 +1,42 @@
+import os
+import sys
+
+from unittest import TestCase
+
+from aws_lambda_builders.workflows.provided_make import utils
+
+
+class TestOSUtils(TestCase):
+    def setUp(self):
+
+        self.osutils = utils.OSUtils()
+
+    def test_popen_runs_a_process_and_returns_outcome(self):
+
+        cwd_py = os.path.join(os.path.dirname(__file__), "..", "..", "testdata", "cwd.py")
+
+        p = self.osutils.popen([sys.executable, cwd_py], stdout=self.osutils.pipe, stderr=self.osutils.pipe)
+
+        out, err = p.communicate()
+
+        self.assertEqual(p.returncode, 0)
+
+        self.assertEqual(out.decode("utf8").strip(), os.getcwd())
+
+    def test_popen_can_accept_cwd_and_env(self):
+
+        testdata_dir = os.path.join(os.path.dirname(__file__), "..", "..", "testdata")
+
+        p = self.osutils.popen(
+            [sys.executable, "cwd.py"],
+            stdout=self.osutils.pipe,
+            stderr=self.osutils.pipe,
+            env=os.environ.copy().update({"SOME_ENV": "SOME_VALUE"}),
+            cwd=testdata_dir,
+        )
+
+        out, err = p.communicate()
+
+        self.assertEqual(p.returncode, 0)
+
+        self.assertEqual(out.decode("utf8").strip(), os.path.abspath(testdata_dir))

tests/functional/workflows/provided_make/__init__.py

@@ -0,0 +1,69 @@
+import os
+import shutil
+import sys
+import tempfile
+from unittest import TestCase
+
+from aws_lambda_builders.builder import LambdaBuilder
+from aws_lambda_builders.exceptions import WorkflowFailedError
+
+
+class TestProvidedMakeWorkflow(TestCase):
+    """
+    Verifies that `provided_make` workflow works by building a Lambda that requires Numpy
+    """
+
+    TEST_DATA_FOLDER = os.path.join(os.path.dirname(__file__), "testdata", "makefile-present")
+
+    def setUp(self):
+        self.source_dir = self.TEST_DATA_FOLDER
+        self.artifacts_dir = tempfile.mkdtemp()
+        self.scratch_dir = tempfile.mkdtemp()
+
+        self.manifest_path_valid = os.path.join(self.TEST_DATA_FOLDER, "Makefile")
+
+        self.test_data_files = {"__init__.py", "main.py", "requirements-requests.txt"}
+
+        self.builder = LambdaBuilder(language="provided", dependency_manager=None, application_framework=None)
+        self.runtime = "provided"
+
+    def tearDown(self):
+        shutil.rmtree(self.artifacts_dir)
+        shutil.rmtree(self.scratch_dir)
+
+    def test_must_build_python_project_through_makefile(self):
+        self.builder.build(
+            self.source_dir,
+            self.artifacts_dir,
+            self.scratch_dir,
+            self.manifest_path_valid,
+            runtime=self.runtime,
+            options={"build_logical_id": "HelloWorldFunction"},
+        )
+        dependencies_installed = {
+            "chardet",
+            "urllib3",
+            "idna",
+            "urllib3-1.25.8.dist-info",
+            "chardet-3.0.4.dist-info",
+            "certifi-2020.4.5.1.dist-info",
+            "certifi",
+            "idna-2.9.dist-info",
+            "requests",
+            "requests-2.23.0.dist-info",
+        }
+
+        expected_files = self.test_data_files.union(dependencies_installed)
+        output_files = set(os.listdir(self.artifacts_dir))
+        self.assertEquals(expected_files, output_files)
+
+    def test_must_build_python_project_through_makefile_unknown_target(self):
+        with self.assertRaises(WorkflowFailedError):
+            self.builder.build(
+                self.source_dir,
+                self.artifacts_dir,
+                self.scratch_dir,
+                self.manifest_path_valid,
+                runtime=self.runtime,
+                options={"build_logical_id": "HelloWorldFunction2"},
+            )

tests/functional/workflows/provided_make/test_utils.py

@@ -0,0 +1,5 @@
+build-HelloWorldFunction:
+	cp -r *.py $(ARTIFACTS_DIR)
+	cp -r requirements-requests.txt $(ARTIFACTS_DIR)
+	python -m pip install -r requirements-requests.txt -t $(ARTIFACTS_DIR)
+	rm -rf $(ARTIFACTS_DIR)/bin

tests/integration/workflows/provided_make/test_provided_make.py

@@ -0,0 +1,6 @@
+import requests
+
+
+def lambda_handler(event, context):
+    # Just return the requests version.
+    return "{}".format(requests.__version__)

tests/integration/workflows/provided_make/testdata/makefile-present/Makefile

@@ -0,0 +1 @@
+requests==2.23.0

tests/integration/workflows/provided_make/testdata/makefile-present/__init__.py

@@ -0,0 +1,61 @@
+from unittest import TestCase
+from mock import patch
+
+from aws_lambda_builders.actions import ActionFailedError
+from aws_lambda_builders.workflows.provided_make.actions import ProvidedMakeAction
+from aws_lambda_builders.workflows.provided_make.make import MakeExecutionError
+
+
+class TestProvidedMakeAction(TestCase):
+    @patch("aws_lambda_builders.workflows.provided_make.utils.OSUtils")
+    @patch("aws_lambda_builders.workflows.provided_make.make.SubProcessMake")
+    def test_call_makefile_target(self, OSUtilMock, SubprocessMakeMock):
+        osutils = OSUtilMock.return_value
+        subprocess_make = SubprocessMakeMock.return_value
+
+        action = ProvidedMakeAction(
+            "artifacts",
+            "scratch_dir",
+            "manifest",
+            osutils=osutils,
+            subprocess_make=subprocess_make,
+            build_logical_id="logical_id",
+        )
+
+        osutils.dirname.side_effect = lambda value: "/dir:{}".format(value)
+        osutils.abspath.side_effect = lambda value: "/abs:{}".format(value)
+        osutils.joinpath.side_effect = lambda a, b: "{}/{}".format(a, b)
+
+        action.execute()
+
+        subprocess_make.run.assert_called_with(
+            ["build-logical_id"], env={"ARTIFACTS_DIR": "artifacts"}, cwd="scratch_dir"
+        )
+
+    @patch("aws_lambda_builders.workflows.provided_make.utils.OSUtils")
+    @patch("aws_lambda_builders.workflows.provided_make.make.SubProcessMake")
+    def test_makefile_target_fails(self, OSUtilMock, SubprocessMakeMock):
+        osutils = OSUtilMock.return_value
+        subprocess_make = SubprocessMakeMock.return_value
+
+        action = ProvidedMakeAction(
+            "artifacts",
+            "scratch_dir",
+            "manifest",
+            osutils=osutils,
+            subprocess_make=subprocess_make,
+            build_logical_id="logical_id",
+        )
+
+        osutils.dirname.side_effect = lambda value: "/dir:{}".format(value)
+        osutils.abspath.side_effect = lambda value: "/abs:{}".format(value)
+        osutils.joinpath.side_effect = lambda a, b: "{}/{}".format(a, b)
+
+        subprocess_make.run.side_effect = [MakeExecutionError(message="failure")]
+
+        with self.assertRaises(ActionFailedError):
+            action.execute()
+
+        subprocess_make.run.assert_called_with(
+            ["build-logical_id"], env={"ARTIFACTS_DIR": "artifacts"}, cwd="scratch_dir"
+        )