Update go modules path resolvers and validators

Update the go models path resolvers and validators to the latest framework
merged in aws#55

Author: volkangurel

aws_lambda_builders/workflows/go_modules/actions.py

@@ -10,7 +10,7 @@ class GoModulesBuildAction(BaseAction):
 
     NAME = "Build"
     DESCRIPTION = "Building Go package with Go Modules"
-    PURPOSE = Purpose.RESOLVE_DEPENDENCIES
+    PURPOSE = Purpose.COMPILE_SOURCE
 
     def __init__(self, source_dir, output_path, builder):
         self.source_dir = source_dir

aws_lambda_builders/workflows/go_modules/builder.py

@@ -15,18 +15,21 @@ def __init__(self, **kwargs):
 
 
 class GoModulesBuilder(object):
-    def __init__(self, osutils, runtime_path):
+
+    LANGUAGE = "go"
+
+    def __init__(self, osutils, binaries):
         """Initialize a GoModulesBuilder.
 
         :type osutils: :class:`lambda_builders.utils.OSUtils`
         :param osutils: A class used for all interactions with the
             outside OS.
 
-        :type runtime_path: str
-        :param runtime_path: The path to the go runtime.
+        :type binaries: dict
+        :param binaries: A dict of language binaries
         """
         self.osutils = osutils
-        self.runtime_path = runtime_path
+        self.binaries = binaries
 
     def build(self, source_dir_path, output_path):
         """Builds a go project onto an output path.
@@ -40,7 +43,8 @@ def build(self, source_dir_path, output_path):
         env = {}
         env.update(self.osutils.environ)
         env.update({"GOOS": "linux", "GOARCH": "amd64"})
-        cmd = [self.runtime_path, "build", "-o", output_path, source_dir_path]
+        runtime_path = self.binaries[self.LANGUAGE].binary_path
+        cmd = [runtime_path, "build", "-o", output_path, source_dir_path]
 
         p = self.osutils.popen(
             cmd,

aws_lambda_builders/workflows/go_modules/path_resolver.py

@@ -16,10 +16,10 @@ class GoRuntimeValidator(object):
         "go1.x"
     }
 
-    def __init__(self, runtime, runtime_path):
+    def __init__(self, runtime):
         self.language = "go"
         self.runtime = runtime
-        self.runtime_path = runtime_path
+        self._valid_runtime_path = None
 
     def has_runtime(self):
         """
@@ -29,29 +29,35 @@ def has_runtime(self):
         """
         return self.runtime in self.SUPPORTED_RUNTIMES
 
-    def validate_runtime(self):
+    def validate(self, runtime_path):
         """
         Checks if the language supplied matches the required lambda runtime
         :param string runtime_path: runtime to check eg: /usr/bin/go
         :raises MisMatchRuntimeError: Version mismatch of the language vs the required runtime
         """
         if not self.has_runtime():
             LOG.warning("'%s' runtime is not "
-                        "a supported runtime", self.runtime_path)
-            return
+                        "a supported runtime", self.runtime)
+            return None
 
         expected_major_version = self.runtime.replace(self.language, "").split('.')[0]
 
-        p = subprocess.Popen([self.runtime_path, "version"],
+        p = subprocess.Popen([runtime_path, "version"],
                              cwd=os.getcwd(),
                              stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         out, _ = p.communicate()
 
         mismatched = p.returncode != 0 \
             or len(out.split()) < 3 \
-            or out.split()[2].replace(self.language, "").split('.')[0] != expected_major_version
+            or out.split()[2].decode().replace(self.language, "").split('.')[0] != expected_major_version
         if mismatched:
             raise MisMatchRuntimeError(language=self.language,
-                                       found_runtime=self.runtime_path,
                                        required_runtime=self.runtime,
-                                       runtime_path=self.runtime_path)
+                                       runtime_path=runtime_path)
+        else:
+            self._valid_runtime_path = runtime_path
+            return self._valid_runtime_path
+
+    @property
+    def validated_runtime_path(self):
+        return self._valid_runtime_path if self._valid_runtime_path is not None else None

aws_lambda_builders/workflows/go_modules/validator.py

@@ -5,7 +5,6 @@
 
 from .actions import GoModulesBuildAction
 from .builder import GoModulesBuilder
-from .path_resolver import GoPathResolver
 from .validator import GoRuntimeValidator
 from .utils import OSUtils
 
@@ -43,13 +42,10 @@ def __init__(self,
 
         output_path = osutils.joinpath(artifacts_dir, handler)
 
-        builder = GoModulesBuilder(osutils, runtime_path=self.get_executable())
+        builder = GoModulesBuilder(osutils, binaries=self.binaries)
         self.actions = [
             GoModulesBuildAction(source_dir, output_path, builder),
         ]
 
-    def get_executable(self):
-        return GoPathResolver(runtime=self.runtime).exec_path
-
-    def get_validator(self):
-        return GoRuntimeValidator(runtime=self.runtime, runtime_path=self.get_executable())
+    def get_validators(self):
+        return [GoRuntimeValidator(runtime=self.runtime)]

aws_lambda_builders/workflows/go_modules/workflow.py

@@ -1,6 +1,8 @@
 from unittest import TestCase
-from mock import patch
 
+from mock import patch, Mock
+
+from aws_lambda_builders.binary_path import BinaryPath
 from aws_lambda_builders.workflows.go_modules.builder import GoModulesBuilder, BuilderError
 
 
@@ -22,14 +24,18 @@ def setUp(self, OSUtilMock):
         self.osutils.pipe = 'PIPE'
         self.popen = FakePopen()
         self.osutils.popen.side_effect = [self.popen]
-        self.under_test = GoModulesBuilder(self.osutils, "go")
+        self.binaries = {
+            "go": BinaryPath(resolver=Mock(), validator=Mock(),
+                             binary="go", binary_path="/path/to/go")
+        }
+        self.under_test = GoModulesBuilder(self.osutils, self.binaries)
 
     def test_run_executes_bundler_on_nixes(self):
         self.osutils.is_windows.side_effect = [False]
-        self.under_test = GoModulesBuilder(self.osutils, "go")
+        self.under_test = GoModulesBuilder(self.osutils, self.binaries)
         self.under_test.build("source_dir", "output_path")
         self.osutils.popen.assert_called_with(
-            ["go", "build", "-o", "output_path", "source_dir"],
+            ["/path/to/go", "build", "-o", "output_path", "source_dir"],
             cwd="source_dir",
             env={'GOOS': 'linux', 'GOARCH': 'amd64'},
             stderr='PIPE',

tests/unit/workflows/go_modules/test_builder.py

@@ -21,28 +21,28 @@ def communicate(self):
 class TestGoRuntimeValidator(TestCase):
 
     def setUp(self):
-        self.validator = GoRuntimeValidator(runtime="go1.x", runtime_path="/usr/bin/go")
+        self.validator = GoRuntimeValidator(runtime="go1.x")
 
     @parameterized.expand([
-        ("go1.x", "/usr/bin/go"),
+        "go1.x",
     ])
-    def test_supported_runtimes(self, runtime, runtime_path):
-        validator = GoRuntimeValidator(runtime=runtime, runtime_path=runtime_path)
+    def test_supported_runtimes(self, runtime):
+        validator = GoRuntimeValidator(runtime=runtime)
         self.assertTrue(validator.has_runtime())
 
     def test_runtime_validate_unsupported_language_fail_open(self):
-        validator = GoRuntimeValidator(runtime='go2.x', runtime_path='/usr/bin/go2')
-        validator.validate_runtime()
+        validator = GoRuntimeValidator(runtime='go2.x')
+        validator.validate(runtime_path='/usr/bin/go2')
 
     def test_runtime_validate_supported_version_runtime(self):
         with mock.patch('subprocess.Popen') as mock_subprocess:
             mock_subprocess.return_value = MockSubProcess(0, out='go version go1.11.2 test')
-            self.validator.validate_runtime()
+            self.validator.validate(runtime_path='/usr/bin/go')
             self.assertTrue(mock_subprocess.call_count, 1)
 
     def test_runtime_validate_mismatch_version_runtime(self):
         with mock.patch('subprocess.Popen') as mock_subprocess:
             mock_subprocess.return_value = MockSubProcess(1)
             with self.assertRaises(MisMatchRuntimeError):
-                self.validator.validate_runtime()
+                self.validator.validate(runtime_path='/usr/bin/go')
                 self.assertTrue(mock_subprocess.call_count, 1)