class TestLocalLambda_is_debugging(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_port = 123
self.debug_args = "abc"
self.aws_profile = "myprofile"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd, self.env_vars_values,
self.debug_port, self.debug_args,
self.aws_profile)
def test_must_be_on(self):
self.assertTrue(self.local_lambda.is_debugging())
def test_must_be_off(self):
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
self.env_vars_values,
debug_port=None, # No debug port
debug_args=self.debug_args,
aws_profile=self.aws_profile)
self.assertFalse(self.local_lambda.is_debugging())
def test_must_invoke(self):
input_event = '"some data"'
expected_env_vars = {
"var1": "override_value1",
"var2": "shell_env_value2"
}
manager = ContainerManager()
local_runtime = LambdaRuntime(manager)
runner = LocalLambdaRunner(local_runtime, self.mock_function_provider, self.cwd, self.env_var_overrides,
debug_args=None, debug_port=None, aws_profile=None)
# Append the real AWS credentials to the expected values.
creds = runner.get_aws_creds()
# default value for creds is not configured by the test. But coming from a downstream class
expected_env_vars["AWS_SECRET_ACCESS_KEY"] = creds.get("secret", "defaultsecret")
expected_env_vars["AWS_ACCESS_KEY_ID"] = creds.get("key", "defaultkey")
expected_env_vars["AWS_REGION"] = creds.get("region", "us-east-1")
stdout_stream = io.BytesIO()
stderr_stream = io.BytesIO()
runner.invoke(self.function_name, input_event, stdout=stdout_stream, stderr=stderr_stream)
# stderr is where the Lambda container runtime logs are available. It usually contains requestId, start time
# etc. So it is non-zero in size
self.assertGreater(len(stderr_stream.getvalue().strip()), 0, "stderr stream must contain data")
# This should contain all the environment variables passed to the function
actual_output = json.loads(stdout_stream.getvalue().strip().decode('utf-8'))
for key, value in expected_env_vars.items():
self.assertTrue(key in actual_output, "Key '{}' must be in function output".format(key))
self.assertEquals(actual_output.get(key), value)
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.environ = {
"Variables": {
"var1": "value1",
}
}
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
aws_profile=self.aws_profile,
aws_region=self.aws_region)
self.aws_creds = {"key": "key"}
self.local_lambda.get_aws_creds = Mock()
self.local_lambda.get_aws_creds.return_value = self.aws_creds
class TestLocalLambda_is_debugging(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = Mock()
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
)
def test_must_be_on(self):
self.assertTrue(self.local_lambda.is_debugging())
def test_must_be_off(self):
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=None,
)
self.assertFalse(self.local_lambda.is_debugging())
class TestLocalLambda_is_debugging(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = Mock()
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
def test_must_be_on(self):
self.assertTrue(self.local_lambda.is_debugging())
def test_must_be_off(self):
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=None)
self.assertFalse(self.local_lambda.is_debugging())
def test_must_be_off(self):
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=None)
self.assertFalse(self.local_lambda.is_debugging())
def test_must_be_off(self):
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
self.env_vars_values,
debug_port=None, # No debug port
debug_args=self.debug_args,
aws_profile=self.aws_profile)
self.assertFalse(self.local_lambda.is_debugging())
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_port = 123
self.debug_args = "abc"
self.aws_profile = "myprofile"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd, self.env_vars_values,
self.debug_port, self.debug_args,
self.aws_profile)
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = Mock()
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
class TestLocalLambda_invoke(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
)
def test_must_work(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock(functionname="name")
invoke_config = "config"
self.function_provider_mock.get_all.return_value = [function]
self.local_lambda._get_invoke_config = Mock()
self.local_lambda._get_invoke_config.return_value = invoke_config
self.local_lambda.invoke(name, event, stdout, stderr)
self.runtime_mock.invoke.assert_called_with(invoke_config,
event,
debug_context=None,
stdout=stdout,
stderr=stderr)
def test_must_raise_if_function_not_found(self):
function = Mock()
function.name = "name"
function.functionname = "FunctionLogicalId"
self.function_provider_mock.get.return_value = None # function not found
self.function_provider_mock.get_all.return_value = [function]
with self.assertRaises(FunctionNotFound):
self.local_lambda.invoke("name", "event")
class TestLocalLambda_invoke_with_container_host_option(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.container_host = "localhost"
self.container_host_interface = "127.0.0.1"
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
container_host=self.container_host,
container_host_interface=self.container_host_interface,
)
def test_must_work(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock(functionname="name")
invoke_config = "config"
self.function_provider_mock.get_all.return_value = [function]
self.local_lambda.get_invoke_config = Mock()
self.local_lambda.get_invoke_config.return_value = invoke_config
self.local_lambda.invoke(name, event, stdout, stderr)
self.runtime_mock.invoke.assert_called_with(
invoke_config,
event,
debug_context=None,
stdout=stdout,
stderr=stderr,
container_host="localhost",
container_host_interface="127.0.0.1",
)
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.env_vars_values = {}
self.debug_port = 123
self.debug_args = "abc"
self.aws_profile = "myprofile"
self.relative_codeuri = "./my/path"
self.absolute_codeuri = "/home/foo/bar" # Some absolute path to use
self.os_cwd = os.getcwd()
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd, self.env_vars_values,
self.debug_port, self.debug_args,
self.aws_profile)
def test_must_be_off(self):
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=None)
self.assertFalse(self.local_lambda.is_debugging())
def setUp(self):
self.host = "127.0.0.1"
self.port = random.randint(30000, 40000) # get a random port
self.url = "http://{}:{}".format(self.host, self.port)
self.code_abs_path = nodejs_lambda(API_GATEWAY_ECHO_EVENT)
# Let's convert this absolute path to relative path. Let the parent be the CWD, and codeuri be the folder
self.cwd = os.path.dirname(self.code_abs_path)
self.code_uri = os.path.relpath(self.code_abs_path, self.cwd) # Get relative path with respect to CWD
# Setup a static file in the directory
self.static_dir = "mystaticdir"
self.static_file_name = "myfile.txt"
self.static_file_content = "This is a static file"
self._setup_static_file(
os.path.join(self.cwd, self.static_dir), # Create static directory with in cwd
self.static_file_name,
self.static_file_content,
)
# Create one Lambda function
self.function_name = "name"
self.function = provider.Function(
name=self.function_name,
runtime="nodejs4.3",
memory=256,
timeout=5,
handler="index.handler",
codeuri=self.code_uri,
environment={},
rolearn=None,
layers=[],
)
self.mock_function_provider = Mock()
self.mock_function_provider.get.return_value = self.function
# Setup two APIs pointing to the same function
routes = [
Route(path="/get", methods=["GET"], function_name=self.function_name),
Route(path="/post", methods=["POST"], function_name=self.function_name),
]
api = Api(routes=routes)
self.api_provider_mock = Mock()
self.api_provider_mock.get_all.return_value = api
# Now wire up the Lambda invoker and pass it through the context
self.lambda_invoke_context_mock = Mock()
manager = ContainerManager()
layer_downloader = LayerDownloader("./", "./")
lambda_image = LambdaImage(layer_downloader, False, False)
local_runtime = LambdaRuntime(manager, lambda_image)
lambda_runner = LocalLambdaRunner(local_runtime, self.mock_function_provider, self.cwd, debug_context=None)
self.lambda_invoke_context_mock.local_lambda_runner = lambda_runner
self.lambda_invoke_context_mock.get_cwd.return_value = self.cwd
def setUp(self):
self.region = "region"
self.key = "key"
self.secret = "secret"
self.token = "token"
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "cwd"
self.env_vars_values = {}
self.debug_port = 123
self.debug_args = "abc"
self.aws_profile = "myprofile"
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd, self.env_vars_values,
self.debug_port, self.debug_args,
self.aws_profile)
class TestLocalLambda_invoke(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
def test_must_work(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock()
invoke_config = "config"
self.function_provider_mock.get.return_value = function
self.local_lambda._get_invoke_config = Mock()
self.local_lambda._get_invoke_config.return_value = invoke_config
self.local_lambda.invoke(name, event, stdout, stderr)
self.runtime_mock.invoke.assert_called_with(invoke_config, event,
debug_context=None,
stdout=stdout, stderr=stderr)
def test_must_raise_if_function_not_found(self):
function = Mock()
function.name = 'FunctionLogicalId'
self.function_provider_mock.get.return_value = None # function not found
self.function_provider_mock.get_all.return_value = [function]
with self.assertRaises(FunctionNotFound):
self.local_lambda.invoke("name", "event")
def setUp(self):
self.region = "region"
self.key = "key"
self.secret = "secret"
self.token = "token"
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "cwd"
self.env_vars_values = {}
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
class TestLocalLambda_invoke(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_port = 123
self.debug_args = "abc"
self.aws_profile = "myprofile"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd, self.env_vars_values,
self.debug_port, self.debug_args,
self.aws_profile)
def test_must_work(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock()
invoke_config = "config"
self.function_provider_mock.get.return_value = function
self.local_lambda._get_invoke_config = Mock()
self.local_lambda._get_invoke_config.return_value = invoke_config
self.local_lambda.invoke(name, event, stdout, stderr)
self.runtime_mock.invoke.assert_called_with(invoke_config,
event,
debug_port=self.debug_port,
debug_args=self.debug_args,
stdout=stdout,
stderr=stderr)
def test_must_raise_if_function_not_found(self):
self.function_provider_mock.get.return_value = None # function not found
with self.assertRaises(FunctionNotFound):
self.local_lambda.invoke("name", "event")
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.container_host = "localhost"
self.container_host_interface = "127.0.0.1"
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
container_host=self.container_host,
container_host_interface=self.container_host_interface,
)
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.env_vars_values = {}
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.relative_codeuri = "./my/path"
self.absolute_codeuri = "/home/foo/bar" # Some absolute path to use
self.os_cwd = os.getcwd()
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
aws_profile=self.aws_profile,
debug_context=self.debug_context,
aws_region=self.aws_region)
def make_service(function_provider, cwd):
port = random_port()
manager = ContainerManager()
layer_downloader = LayerDownloader("./", "./")
image_builder = LambdaImage(layer_downloader, False, False)
local_runtime = LambdaRuntime(manager, image_builder)
lambda_runner = LocalLambdaRunner(local_runtime=local_runtime, function_provider=function_provider, cwd=cwd)
service = LocalLambdaInvokeService(lambda_runner, port=port, host="127.0.0.1")
scheme = "http"
url = "{}://127.0.0.1:{}".format(scheme, port)
return service, port, url, scheme
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
# assuming there is only 1 root stack
self.function_provider_mock.stacks = [
Mock(stack_path="", location="template.yaml"),
Mock(stack_path="ChildStackX",
location=os.path.join("ChildStackX", "template.yaml")),
]
self.cwd = "/my/current/working/directory"
self.aws_profile = "myprofile"
self.debug_context = None
self.env_vars_values = {}
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
)
def test_must_invoke(self):
input_event = '"some data"'
expected_env_vars = {
"var1": "override_value1",
"var2": "shell_env_value2"
}
manager = ContainerManager()
layer_downloader = LayerDownloader("./", "./")
lambda_image = LambdaImage(layer_downloader, False, False)
local_runtime = LambdaRuntime(manager, lambda_image)
runner = LocalLambdaRunner(local_runtime, self.mock_function_provider, self.cwd, self.env_var_overrides,
debug_context=None)
# Append the real AWS credentials to the expected values.
creds = runner.get_aws_creds()
# default value for creds is not configured by the test. But coming from a downstream class
expected_env_vars["AWS_SECRET_ACCESS_KEY"] = creds.get("secret", "defaultsecret")
expected_env_vars["AWS_ACCESS_KEY_ID"] = creds.get("key", "defaultkey")
expected_env_vars["AWS_REGION"] = creds.get("region", "us-east-1")
stdout_stream = io.BytesIO()
stderr_stream = io.BytesIO()
stdout_stream_writer = StreamWriter(stdout_stream)
stderr_stream_writer = StreamWriter(stderr_stream)
runner.invoke(self.function_name, input_event, stdout=stdout_stream_writer, stderr=stderr_stream_writer)
# stderr is where the Lambda container runtime logs are available. It usually contains requestId, start time
# etc. So it is non-zero in size
self.assertGreater(len(stderr_stream.getvalue().strip()), 0, "stderr stream must contain data")
# This should contain all the environment variables passed to the function
actual_output = json.loads(stdout_stream.getvalue().strip().decode('utf-8'))
for key, value in expected_env_vars.items():
self.assertTrue(key in actual_output, "Key '{}' must be in function output".format(key))
self.assertEqual(actual_output.get(key), value)
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = Mock()
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
class TestLocalLambda_get_invoke_config(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_port = 123
self.debug_args = "abc"
self.aws_profile = "myprofile"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd, self.env_vars_values,
self.debug_port, self.debug_args,
self.aws_profile)
@patch('samcli.commands.local.lib.local_lambda.FunctionConfig')
def test_must_work(self, FunctionConfigMock):
env_vars = "envvars"
self.local_lambda._make_env_vars = Mock()
self.local_lambda._make_env_vars.return_value = env_vars
codepath = "codepath"
self.local_lambda._get_code_path = Mock()
self.local_lambda._get_code_path.return_value = codepath
function = Function(name="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=None,
rolearn=None)
config = "someconfig"
FunctionConfigMock.return_value = config
actual = self.local_lambda._get_invoke_config(function)
self.assertEquals(actual, config)
FunctionConfigMock.assert_called_with(name=function.name,
runtime=function.runtime,
handler=function.handler,
code_abs_path=codepath,
memory=function.memory,
timeout=function.timeout,
env_vars=env_vars)
self.local_lambda._get_code_path.assert_called_with(function.codeuri)
self.local_lambda._make_env_vars.assert_called_with(function)
def make_service(function_provider, cwd):
port = random_port()
manager = ContainerManager()
local_runtime = LambdaRuntime(manager)
lambda_runner = LocalLambdaRunner(local_runtime=local_runtime,
function_provider=function_provider,
cwd=cwd)
service = LocalLambdaInvokeService(lambda_runner,
port=port,
host='127.0.0.1')
scheme = "http"
url = '{}://127.0.0.1:{}'.format(scheme, port)
return service, port, url, scheme
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_port = 123
self.debug_args = "abc"
self.aws_profile = "myprofile"
self.env_vars_values = {}
self.environ = {
"Variables": {
"var1": "value1",
}
}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd, self.env_vars_values,
self.debug_port, self.debug_args,
self.aws_profile)
self.aws_creds = {"key": "key"}
self.local_lambda.get_aws_creds = Mock()
self.local_lambda.get_aws_creds.return_value = self.aws_creds
def local_lambda_runner(self):
"""
Returns an instance of the runner capable of running Lambda functions locally
:return samcli.commands.local.lib.local_lambda.LocalLambdaRunner: Runner configured to run Lambda functions
locally
"""
container_manager = ContainerManager(docker_network_id=self._docker_network,
skip_pull_image=self._skip_pull_image)
lambda_runtime = LambdaRuntime(container_manager)
return LocalLambdaRunner(local_runtime=lambda_runtime,
function_provider=self._function_provider,
cwd=self.get_cwd(),
env_vars_values=self._env_vars_value,
debug_context=self._debug_context,
aws_profile=self._aws_profile,
aws_region=self._aws_region)
def setUp(self):
self.region = "region"
self.key = "key"
self.secret = "secret"
self.token = "token"
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "cwd"
self.env_vars_values = {}
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
def local_lambda_runner(self):
"""
Returns an instance of the runner capable of running Lambda functions locally
:return samcli.commands.local.lib.local_lambda.LocalLambdaRunner: Runner configured to run Lambda functions
locally
"""
layer_downloader = LayerDownloader(self._layer_cache_basedir,
self.get_cwd())
image_builder = LambdaImage(layer_downloader, self._skip_pull_image,
self._force_image_build)
lambda_runtime = LambdaRuntime(self._container_manager, image_builder)
return LocalLambdaRunner(local_runtime=lambda_runtime,
function_provider=self._function_provider,
cwd=self.get_cwd(),
env_vars_values=self._env_vars_value,
debug_context=self._debug_context)
def local_lambda_runner(self) -> LocalLambdaRunner:
"""
Returns an instance of the runner capable of running Lambda functions locally
:return samcli.commands.local.lib.local_lambda.LocalLambdaRunner: Runner configured to run Lambda functions
locally
"""
if self._local_lambda_runner:
return self._local_lambda_runner
self._local_lambda_runner = LocalLambdaRunner(
local_runtime=self.lambda_runtime,
function_provider=self._function_provider,
cwd=self.get_cwd(),
aws_profile=self._aws_profile,
aws_region=self._aws_region,
env_vars_values=self._env_vars_value,
debug_context=self._debug_context,
)
return self._local_lambda_runner
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.environ = {
"Variables": {
"var1": "value1",
}
}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
self.aws_creds = {"key": "key"}
self.local_lambda.get_aws_creds = Mock()
self.local_lambda.get_aws_creds.return_value = self.aws_creds
class TestLocalLambda_make_env_vars(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.environ = {
"Variables": {
"var1": "value1",
}
}
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
self.aws_creds = {"key": "key"}
self.local_lambda.get_aws_creds = Mock()
self.local_lambda.get_aws_creds.return_value = self.aws_creds
@parameterized.expand([
# Override for the function exists
({"function_name": {"a": "b"}}, {"a": "b"}),
# Override for the function does *not* exist
({"otherfunction": {"c": "d"}}, None),
# Using a CloudFormation parameter file format
({"Parameters": {"p1": "v1"}}, {"p1": "v1"})
])
@patch("samcli.commands.local.lib.local_lambda.EnvironmentVariables")
@patch("samcli.commands.local.lib.local_lambda.os")
def test_must_work_with_override_values(self, env_vars_values, expected_override_value, os_mock,
EnvironmentVariablesMock):
os_environ = {"some": "value"}
os_mock.environ = os_environ
function = Function(name="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=self.environ,
rolearn=None,
layers=[])
self.local_lambda.env_vars_values = env_vars_values
self.local_lambda._make_env_vars(function)
EnvironmentVariablesMock.assert_called_with(function.memory,
function.timeout,
function.handler,
variables={"var1": "value1"},
shell_env_values=os_environ,
override_values=expected_override_value,
aws_creds=self.aws_creds)
@parameterized.expand([
# Using a invalid file format
({"a": "b"}, OverridesNotWellDefinedError),
({"a": False}, OverridesNotWellDefinedError),
({"a": [True, False]}, OverridesNotWellDefinedError)
])
@patch("samcli.commands.local.lib.local_lambda.os")
def test_must_not_work_with_invalid_override_values(self, env_vars_values, expected_exception, os_mock):
os_environ = {"some": "value"}
os_mock.environ = os_environ
function = Function(name="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=self.environ,
rolearn=None,
layers=[])
self.local_lambda.env_vars_values = env_vars_values
with self.assertRaises(expected_exception):
self.local_lambda._make_env_vars(function)
@parameterized.expand([
param({"a": "b"}), # Does not have the "Variables" Key
param("somestring"), # Must be a dict type
param(None)
])
@patch("samcli.commands.local.lib.local_lambda.EnvironmentVariables")
@patch("samcli.commands.local.lib.local_lambda.os")
def test_must_work_with_invalid_environment_variable(self, environment_variable, os_mock, EnvironmentVariablesMock):
os_environ = {"some": "value"}
os_mock.environ = os_environ
function = Function(name="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=environment_variable,
rolearn=None,
layers=[])
self.local_lambda.env_vars_values = {}
self.local_lambda._make_env_vars(function)
EnvironmentVariablesMock.assert_called_with(function.memory,
function.timeout,
function.handler,
variables=None,
shell_env_values=os_environ,
override_values=None,
aws_creds=self.aws_creds)
class TestLocalLambda_get_invoke_config(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.aws_profile = "myprofile"
self.debug_context = None
self.env_vars_values = {}
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
)
@patch("samcli.commands.local.lib.local_lambda.resolve_code_path")
@patch("samcli.commands.local.lib.local_lambda.LocalLambdaRunner.is_debugging")
@patch("samcli.commands.local.lib.local_lambda.FunctionConfig")
def test_must_work(self, FunctionConfigMock, is_debugging_mock, resolve_code_path_patch):
is_debugging_mock.return_value = False
env_vars = "envvars"
self.local_lambda._make_env_vars = Mock()
self.local_lambda._make_env_vars.return_value = env_vars
codepath = "codepath"
resolve_code_path_patch.return_value = codepath
layers = ["layer1", "layer2"]
function = Function(
name="function_name",
functionname="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=None,
rolearn=None,
layers=layers,
events=None,
)
config = "someconfig"
FunctionConfigMock.return_value = config
actual = self.local_lambda._get_invoke_config(function)
self.assertEqual(actual, config)
FunctionConfigMock.assert_called_with(
name=function.functionname,
runtime=function.runtime,
handler=function.handler,
code_abs_path=codepath,
layers=layers,
memory=function.memory,
timeout=function.timeout,
env_vars=env_vars,
)
resolve_code_path_patch.assert_called_with(self.cwd, function.codeuri)
self.local_lambda._make_env_vars.assert_called_with(function)
@patch("samcli.commands.local.lib.local_lambda.resolve_code_path")
@patch("samcli.commands.local.lib.local_lambda.LocalLambdaRunner.is_debugging")
@patch("samcli.commands.local.lib.local_lambda.FunctionConfig")
def test_timeout_set_to_max_during_debugging(self, FunctionConfigMock, is_debugging_mock, resolve_code_path_patch):
is_debugging_mock.return_value = True
env_vars = "envvars"
self.local_lambda._make_env_vars = Mock()
self.local_lambda._make_env_vars.return_value = env_vars
codepath = "codepath"
resolve_code_path_patch.return_value = codepath
function = Function(
name="function_name",
functionname="function_name",
runtime="runtime",
memory=1234,
timeout=36000,
handler="handler",
codeuri="codeuri",
environment=None,
rolearn=None,
layers=[],
events=None,
)
config = "someconfig"
FunctionConfigMock.return_value = config
actual = self.local_lambda._get_invoke_config(function)
self.assertEqual(actual, config)
FunctionConfigMock.assert_called_with(
name=function.functionname,
runtime=function.runtime,
handler=function.handler,
code_abs_path=codepath,
layers=[],
memory=function.memory,
timeout=function.timeout,
env_vars=env_vars,
)
resolve_code_path_patch.assert_called_with(self.cwd, function.codeuri)
self.local_lambda._make_env_vars.assert_called_with(function)
class TestLocalLambda_make_env_vars(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.environ = {"Variables": {"var1": "value1"}}
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
)
self.aws_creds = {"key": "key"}
self.local_lambda.get_aws_creds = Mock()
self.local_lambda.get_aws_creds.return_value = self.aws_creds
@parameterized.expand(
[
# Override for the function exists
({"function_name": {"a": "b"}}, {"a": "b"}),
# Override for the function does *not* exist
({"otherfunction": {"c": "d"}}, None),
# Using a CloudFormation parameter file format
({"Parameters": {"p1": "v1"}}, {"p1": "v1"}),
]
)
@patch("samcli.commands.local.lib.local_lambda.EnvironmentVariables")
@patch("samcli.commands.local.lib.local_lambda.os")
def test_must_work_with_override_values(
self, env_vars_values, expected_override_value, os_mock, EnvironmentVariablesMock
):
os_environ = {"some": "value"}
os_mock.environ = os_environ
function = Function(
name="function_name",
functionname="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=self.environ,
rolearn=None,
layers=[],
events=None,
)
self.local_lambda.env_vars_values = env_vars_values
self.local_lambda._make_env_vars(function)
EnvironmentVariablesMock.assert_called_with(
function.memory,
function.timeout,
function.handler,
variables={"var1": "value1"},
shell_env_values=os_environ,
override_values=expected_override_value,
aws_creds=self.aws_creds,
)
@parameterized.expand(
[
# Using a invalid file format
({"a": "b"}, OverridesNotWellDefinedError),
({"a": False}, OverridesNotWellDefinedError),
({"a": [True, False]}, OverridesNotWellDefinedError),
]
)
@patch("samcli.commands.local.lib.local_lambda.os")
def test_must_not_work_with_invalid_override_values(self, env_vars_values, expected_exception, os_mock):
os_environ = {"some": "value"}
os_mock.environ = os_environ
function = Function(
name="function_name",
functionname="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=self.environ,
rolearn=None,
layers=[],
events=None,
)
self.local_lambda.env_vars_values = env_vars_values
with self.assertRaises(expected_exception):
self.local_lambda._make_env_vars(function)
@parameterized.expand(
[
param({"a": "b"}), # Does not have the "Variables" Key
param("somestring"), # Must be a dict type
param(None),
]
)
@patch("samcli.commands.local.lib.local_lambda.EnvironmentVariables")
@patch("samcli.commands.local.lib.local_lambda.os")
def test_must_work_with_invalid_environment_variable(self, environment_variable, os_mock, EnvironmentVariablesMock):
os_environ = {"some": "value"}
os_mock.environ = os_environ
function = Function(
name="function_name",
functionname="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=environment_variable,
rolearn=None,
layers=[],
events=None,
)
self.local_lambda.env_vars_values = {}
self.local_lambda._make_env_vars(function)
EnvironmentVariablesMock.assert_called_with(
function.memory,
function.timeout,
function.handler,
variables=None,
shell_env_values=os_environ,
override_values=None,
aws_creds=self.aws_creds,
)
class TestLocalLambda_get_aws_creds(TestCase):
def setUp(self):
self.region = "region"
self.key = "key"
self.secret = "secret"
self.token = "token"
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "cwd"
self.env_vars_values = {}
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
aws_profile=self.aws_profile,
aws_region=self.aws_region,
)
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_get_from_boto_session(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
creds.secret_key = self.secret
creds.token = self.token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {"region": self.region, "key": self.key, "secret": self.secret, "sessiontoken": self.token}
actual = self.local_lambda.get_aws_creds()
self.assertEqual(expected, actual)
boto3_mock.session.Session.assert_called_with(profile_name=self.aws_profile, region_name=self.aws_region)
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_region_name(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
creds.secret_key = self.secret
creds.token = self.token
mock_session = Mock()
del mock_session.region_name # Ask mock to return AttributeError when 'region_name' is accessed
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {"key": self.key, "secret": self.secret, "sessiontoken": self.token}
actual = self.local_lambda.get_aws_creds()
self.assertEqual(expected, actual)
boto3_mock.session.Session.assert_called_with(profile_name=self.aws_profile, region_name=self.aws_region)
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_access_key(self, boto3_mock):
creds = Mock()
del creds.access_key # No access key
creds.secret_key = self.secret
creds.token = self.token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {"region": self.region, "secret": self.secret, "sessiontoken": self.token}
actual = self.local_lambda.get_aws_creds()
self.assertEqual(expected, actual)
boto3_mock.session.Session.assert_called_with(profile_name=self.aws_profile, region_name=self.aws_region)
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_secret_key(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
del creds.secret_key # No secret key
creds.token = self.token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {"region": self.region, "key": self.key, "sessiontoken": self.token}
actual = self.local_lambda.get_aws_creds()
self.assertEqual(expected, actual)
boto3_mock.session.Session.assert_called_with(profile_name=self.aws_profile, region_name=self.aws_region)
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_session_token(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
creds.secret_key = self.secret
del creds.token # No Token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.DEFAULT_SESSION = None
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {"region": self.region, "key": self.key, "secret": self.secret}
actual = self.local_lambda.get_aws_creds()
self.assertEqual(expected, actual)
boto3_mock.session.Session.assert_called()
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_credentials(self, boto3_mock):
boto3_mock.DEFAULT_SESSION = None
mock_session = Mock()
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = None
expected = {"region": mock_session.region_name}
actual = self.local_lambda.get_aws_creds()
self.assertEqual(expected, actual)
boto3_mock.session.Session.assert_called()
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_session(self, boto3_mock):
boto3_mock.DEFAULT_SESSION = None
boto3_mock.session.Session.return_value = None
expected = {}
actual = self.local_lambda.get_aws_creds()
self.assertEqual(expected, actual)
boto3_mock.session.Session.assert_called()
class TestLocalLambda_invoke(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.env_vars_values = {}
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
)
def test_must_work(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock(functionname="name")
invoke_config = "config"
self.function_provider_mock.get_all.return_value = [function]
self.local_lambda.get_invoke_config = Mock()
self.local_lambda.get_invoke_config.return_value = invoke_config
self.local_lambda.invoke(name, event, stdout, stderr)
self.runtime_mock.invoke.assert_called_with(invoke_config,
event,
debug_context=None,
stdout=stdout,
stderr=stderr)
def test_must_work_packagetype_ZIP(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock(functionname="name",
handler="app.handler",
runtime="test",
packagetype=ZIP)
invoke_config = "config"
self.function_provider_mock.get.return_value = function
self.local_lambda.get_invoke_config = Mock()
self.local_lambda.get_invoke_config.return_value = invoke_config
self.local_lambda.invoke(name, event, stdout, stderr)
self.runtime_mock.invoke.assert_called_with(invoke_config,
event,
debug_context=None,
stdout=stdout,
stderr=stderr)
def test_must_raise_if_no_privilege(self):
function = Mock()
function.name = "name"
function.functionname = "FunctionLogicalId"
invoke_config = "config"
self.function_provider_mock.get_all.return_value = [function]
self.local_lambda.get_invoke_config = Mock()
self.local_lambda.get_invoke_config.return_value = invoke_config
os_error = OSError()
os_error.winerror = 1314
self.runtime_mock.invoke.side_effect = os_error
with self.assertRaises(NoPrivilegeException):
self.local_lambda.invoke("name", "event")
def test_must_raise_os_error(self):
function = Mock()
function.name = "name"
function.functionname = "FunctionLogicalId"
invoke_config = "config"
self.function_provider_mock.get_all.return_value = [function]
self.local_lambda.get_invoke_config = Mock()
self.local_lambda.get_invoke_config.return_value = invoke_config
os_error = OSError()
os_error.winerror = 1315
self.runtime_mock.invoke.side_effect = os_error
with self.assertRaises(OSError):
self.local_lambda.invoke("name", "event")
def test_must_raise_if_function_not_found(self):
function = Mock()
function.name = "name"
function.functionname = "FunctionLogicalId"
self.function_provider_mock.get.return_value = None # function not found
self.function_provider_mock.get_all.return_value = [function]
with self.assertRaises(FunctionNotFound):
self.local_lambda.invoke("name", "event")
def test_must_not_raise_if_invoked_container_has_no_response(self):
function = Mock()
function.name = "name"
function.functionname = "FunctionLogicalId"
invoke_config = "invoke_config"
self.function_provider_mock.get.return_value = function
self.local_lambda.get_invoke_config = Mock()
self.local_lambda.get_invoke_config.return_value = invoke_config
self.runtime_mock.invoke = Mock(side_effect=ContainerResponseException)
# No exception raised back
self.local_lambda.invoke("name", "event")
def test_works_if_imageuri_and_Image_packagetype(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock(functionname="name",
packagetype=IMAGE,
imageuri="testimage:tag")
invoke_config = "config"
self.function_provider_mock.get.return_value = function
self.local_lambda.get_invoke_config = Mock()
self.local_lambda.get_invoke_config.return_value = invoke_config
self.local_lambda.invoke(name, event, stdout, stderr)
self.runtime_mock.invoke.assert_called_with(invoke_config,
event,
debug_context=None,
stdout=stdout,
stderr=stderr)
def test_must_raise_if_imageuri_not_found(self):
name = "name"
event = "event"
stdout = "stdout"
stderr = "stderr"
function = Mock(functionname="name", packagetype=IMAGE, imageuri=None)
self.function_provider_mock.get.return_value = function
with self.assertRaises(InvalidIntermediateImageError):
self.local_lambda.invoke(name, event, stdout, stderr)
class TestLocalLambda_get_aws_creds(TestCase):
def setUp(self):
self.region = "region"
self.key = "key"
self.secret = "secret"
self.token = "token"
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "cwd"
self.env_vars_values = {}
self.debug_context = None
self.aws_profile = "myprofile"
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_get_from_boto_session(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
creds.secret_key = self.secret
creds.token = self.token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.DEFAULT_SESSION = mock_session
mock_session.get_credentials.return_value = creds
expected = {
"region": self.region,
"key": self.key,
"secret": self.secret,
"sessiontoken": self.token
}
actual = self.local_lambda.get_aws_creds()
self.assertEquals(expected, actual)
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_region_name(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
creds.secret_key = self.secret
creds.token = self.token
mock_session = Mock()
del mock_session.region_name # Ask mock to return AttributeError when 'region_name' is accessed
boto3_mock.DEFAULT_SESSION = None
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {
"key": self.key,
"secret": self.secret,
"sessiontoken": self.token
}
actual = self.local_lambda.get_aws_creds()
self.assertEquals(expected, actual)
boto3_mock.session.Session.assert_called_with()
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_access_key(self, boto3_mock):
creds = Mock()
del creds.access_key # No access key
creds.secret_key = self.secret
creds.token = self.token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.DEFAULT_SESSION = None
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {
"region": self.region,
"secret": self.secret,
"sessiontoken": self.token
}
actual = self.local_lambda.get_aws_creds()
self.assertEquals(expected, actual)
boto3_mock.session.Session.assert_called_with()
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_secret_key(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
del creds.secret_key # No secret key
creds.token = self.token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.DEFAULT_SESSION = None
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {
"region": self.region,
"key": self.key,
"sessiontoken": self.token
}
actual = self.local_lambda.get_aws_creds()
self.assertEquals(expected, actual)
boto3_mock.session.Session.assert_called_with()
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_session_token(self, boto3_mock):
creds = Mock()
creds.access_key = self.key
creds.secret_key = self.secret
del creds.token # No Token
mock_session = Mock()
mock_session.region_name = self.region
boto3_mock.DEFAULT_SESSION = None
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = creds
expected = {
"region": self.region,
"key": self.key,
"secret": self.secret
}
actual = self.local_lambda.get_aws_creds()
self.assertEquals(expected, actual)
boto3_mock.session.Session.assert_called()
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_credentials(self, boto3_mock):
boto3_mock.DEFAULT_SESSION = None
mock_session = Mock()
boto3_mock.session.Session.return_value = mock_session
mock_session.get_credentials.return_value = None
expected = {}
actual = self.local_lambda.get_aws_creds()
self.assertEquals(expected, actual)
boto3_mock.session.Session.assert_called()
@patch("samcli.commands.local.lib.local_lambda.boto3")
def test_must_work_with_no_session(self, boto3_mock):
boto3_mock.DEFAULT_SESSION = None
boto3_mock.session.Session.return_value = None
expected = {}
actual = self.local_lambda.get_aws_creds()
self.assertEquals(expected, actual)
boto3_mock.session.Session.assert_called()
class TestLocalLambda_get_invoke_config(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
# assuming there is only 1 root stack
self.function_provider_mock.stacks = [
Mock(stack_path="", location="template.yaml"),
Mock(stack_path="ChildStackX",
location=os.path.join("ChildStackX", "template.yaml")),
]
self.cwd = "/my/current/working/directory"
self.aws_profile = "myprofile"
self.debug_context = None
self.env_vars_values = {}
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(
self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context,
)
@patch("samcli.commands.local.lib.local_lambda.resolve_code_path")
@patch(
"samcli.commands.local.lib.local_lambda.LocalLambdaRunner.is_debugging"
)
@patch("samcli.commands.local.lib.local_lambda.FunctionConfig")
def test_must_work(self, FunctionConfigMock, is_debugging_mock,
resolve_code_path_patch):
is_debugging_mock.return_value = False
env_vars = "envvars"
self.local_lambda._make_env_vars = Mock()
self.local_lambda._make_env_vars.return_value = env_vars
codepath = "codepath"
resolve_code_path_patch.return_value = codepath
layers = ["layer1", "layer2"]
function = Function(
stack_path="",
name="function_name",
functionname="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=None,
rolearn=None,
layers=layers,
events=None,
metadata=None,
inlinecode=None,
imageuri=None,
imageconfig=None,
packagetype=ZIP,
codesign_config_arn=None,
)
config = "someconfig"
FunctionConfigMock.return_value = config
actual = self.local_lambda.get_invoke_config(function)
self.assertEqual(actual, config)
FunctionConfigMock.assert_called_with(
imageconfig=function.imageconfig,
imageuri=function.imageuri,
name=function.functionname,
packagetype=function.packagetype,
runtime=function.runtime,
handler=function.handler,
code_abs_path=codepath,
layers=layers,
memory=function.memory,
timeout=function.timeout,
env_vars=env_vars,
)
resolve_code_path_patch.assert_called_with(self.cwd, function.codeuri)
self.local_lambda._make_env_vars.assert_called_with(function)
@patch("samcli.commands.local.lib.local_lambda.resolve_code_path")
@patch(
"samcli.commands.local.lib.local_lambda.LocalLambdaRunner.is_debugging"
)
@patch("samcli.commands.local.lib.local_lambda.FunctionConfig")
def test_timeout_set_to_max_during_debugging(
self,
FunctionConfigMock,
is_debugging_mock,
resolve_code_path_patch,
):
is_debugging_mock.return_value = True
env_vars = "envvars"
self.local_lambda._make_env_vars = Mock()
self.local_lambda._make_env_vars.return_value = env_vars
codepath = "codepath"
resolve_code_path_patch.return_value = codepath
function = Function(
stack_path=Mock(),
name="function_name",
functionname="function_name",
runtime="runtime",
memory=1234,
timeout=36000,
handler="handler",
codeuri="codeuri",
environment=None,
rolearn=None,
layers=[],
events=None,
metadata=None,
inlinecode=None,
imageuri=None,
imageconfig=None,
packagetype=ZIP,
codesign_config_arn=None,
)
config = "someconfig"
FunctionConfigMock.return_value = config
actual = self.local_lambda.get_invoke_config(function)
self.assertEqual(actual, config)
FunctionConfigMock.assert_called_with(
imageconfig=function.imageconfig,
imageuri=function.imageuri,
name=function.functionname,
packagetype=function.packagetype,
runtime=function.runtime,
handler=function.handler,
code_abs_path=codepath,
layers=[],
memory=function.memory,
timeout=function.timeout,
env_vars=env_vars,
)
resolve_code_path_patch.assert_called_with(self.cwd, "codeuri")
self.local_lambda._make_env_vars.assert_called_with(function)
class TestLocalLambda_get_invoke_config(TestCase):
def setUp(self):
self.runtime_mock = Mock()
self.function_provider_mock = Mock()
self.cwd = "/my/current/working/directory"
self.aws_profile = "myprofile"
self.debug_context = None
self.env_vars_values = {}
self.aws_region = "region"
self.local_lambda = LocalLambdaRunner(self.runtime_mock,
self.function_provider_mock,
self.cwd,
env_vars_values=self.env_vars_values,
debug_context=self.debug_context)
@patch('samcli.commands.local.lib.local_lambda.resolve_code_path')
@patch('samcli.commands.local.lib.local_lambda.LocalLambdaRunner.is_debugging')
@patch('samcli.commands.local.lib.local_lambda.FunctionConfig')
def test_must_work(self, FunctionConfigMock, is_debugging_mock, resolve_code_path_patch):
is_debugging_mock.return_value = False
env_vars = "envvars"
self.local_lambda._make_env_vars = Mock()
self.local_lambda._make_env_vars.return_value = env_vars
codepath = "codepath"
resolve_code_path_patch.return_value = codepath
layers = ['layer1', 'layer2']
function = Function(name="function_name",
runtime="runtime",
memory=1234,
timeout=12,
handler="handler",
codeuri="codeuri",
environment=None,
rolearn=None,
layers=layers)
config = "someconfig"
FunctionConfigMock.return_value = config
actual = self.local_lambda._get_invoke_config(function)
self.assertEquals(actual, config)
FunctionConfigMock.assert_called_with(name=function.name,
runtime=function.runtime,
handler=function.handler,
code_abs_path=codepath,
layers=layers,
memory=function.memory,
timeout=function.timeout,
env_vars=env_vars)
resolve_code_path_patch.assert_called_with(self.cwd, function.codeuri)
self.local_lambda._make_env_vars.assert_called_with(function)
@patch('samcli.commands.local.lib.local_lambda.resolve_code_path')
@patch('samcli.commands.local.lib.local_lambda.LocalLambdaRunner.is_debugging')
@patch('samcli.commands.local.lib.local_lambda.FunctionConfig')
def test_timeout_set_to_max_during_debugging(self, FunctionConfigMock, is_debugging_mock, resolve_code_path_patch):
is_debugging_mock.return_value = True
env_vars = "envvars"
self.local_lambda._make_env_vars = Mock()
self.local_lambda._make_env_vars.return_value = env_vars
codepath = "codepath"
resolve_code_path_patch.return_value = codepath
function = Function(name="function_name",
runtime="runtime",
memory=1234,
timeout=36000,
handler="handler",
codeuri="codeuri",
environment=None,
rolearn=None,
layers=[])
config = "someconfig"
FunctionConfigMock.return_value = config
actual = self.local_lambda._get_invoke_config(function)
self.assertEquals(actual, config)
FunctionConfigMock.assert_called_with(name=function.name,
runtime=function.runtime,
handler=function.handler,
code_abs_path=codepath,
layers=[],
memory=function.memory,
timeout=function.timeout,
env_vars=env_vars)
resolve_code_path_patch.assert_called_with(self.cwd, function.codeuri)
self.local_lambda._make_env_vars.assert_called_with(function)
