def test_layer_does_not_exist(self): self.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerOneArn", "layer1.zip") non_existent_layer_arn = self.layer_utils.parameters_overrides[ "LayerOneArn"].replace(self.layer_utils.layers_meta[0].layer_name, "non_existent_layer") command_list = self.get_command_list( "LayerVersionDoesNotExistFunction", template_path=self.template_path, no_event=True, region=self.region, parameter_overrides={ "NonExistentLayerArn": non_existent_layer_arn }, ) process = Popen(command_list, stderr=PIPE) process.wait() process_stderr = b"".join(process.stderr.readlines()).strip() error_output = process_stderr.decode("utf-8") expected_error_output = "{} was not found.".format( non_existent_layer_arn) self.assertIn(expected_error_output, error_output) self.layer_utils.delete_layers()
class TestBadLayerVersion(InvokeIntegBase): template = Path("layers", "layer-bad-template.yaml") region = "us-west-2" layer_utils = LayerUtils(region=region) def test_unresolved_layer_due_to_bad_instrinsic(self): command_list = self.get_command_list( "LayerBadInstrinsic", template_path=self.template_path, no_event=True, region=self.region, parameter_overrides={"LayerVersion": "1"}, ) process = Popen(command_list, stderr=PIPE) try: _, stderr = process.communicate(timeout=TIMEOUT) except TimeoutExpired: process.kill() raise process_stderr = stderr.strip() error_output = process_stderr.decode("utf-8") expected_error_output = "Error: arn:aws:lambda:us-west-2:111111111101:layer:layerDoesNotExist:${LayerVersion} is an Invalid Layer Arn." self.assertIn(expected_error_output, error_output)
class TestLayerVersionThatDoNotCreateCache(InvokeIntegBase): template = Path("layers", "layer-template.yml") region = 'us-west-2' layer_utils = LayerUtils(region=region) def setUp(self): self.layer_cache = Path().home().joinpath("integ_layer_cache") def tearDown(self): docker_client = docker.from_env() samcli_images = docker_client.images.list(name='samcli/lambda') for image in samcli_images: docker_client.images.remove(image.id) def test_layer_does_not_exist(self): self.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerOneArn", "layer1.zip") non_existent_layer_arn = self.layer_utils.parameters_overrides[ "LayerOneArn"].replace(self.layer_utils.layers_meta[0].layer_name, 'non_existent_layer') command_list = self.get_command_list( "LayerVersionDoesNotExistFunction", template_path=self.template_path, no_event=True, region=self.region, parameter_overrides={ 'NonExistentLayerArn': non_existent_layer_arn }) process = Popen(command_list, stderr=PIPE) process.wait() process_stderr = b"".join(process.stderr.readlines()).strip() error_output = process_stderr.decode('utf-8') expected_error_output = "{} was not found.".format( non_existent_layer_arn) self.assertIn(expected_error_output, error_output) self.layer_utils.delete_layers() def test_account_does_not_exist_for_layer(self): command_list = self.get_command_list( "LayerVersionAccountDoesNotExistFunction", template_path=self.template_path, no_event=True, region=self.region) process = Popen(command_list, stderr=PIPE) process.wait() process_stderr = b"".join(process.stderr.readlines()).strip() error_output = process_stderr.decode('utf-8') expected_error_output = "Credentials provided are missing lambda:Getlayerversion policy that is needed to " \ "download the layer or you do not have permission to download the layer" self.assertIn(expected_error_output, error_output)
def setUpClass(cls): cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerOneArn", "layer1.zip") cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerTwoArn", "layer2.zip") super(TestLayerVersion, cls).setUpClass()
class TestLayerVersion(InvokeIntegBase): template = Path("layers", "layer-template.yml") region = "us-west-2" layer_utils = LayerUtils(region=region) def setUp(self): self.layer_cache = Path().home().joinpath("integ_layer_cache") def tearDown(self): docker_client = docker.from_env() samcli_images = docker_client.images.list(name="samcli/lambda") for image in samcli_images: docker_client.images.remove(image.id) shutil.rmtree(str(self.layer_cache)) @classmethod def setUpClass(cls): cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerOneArn", "layer1.zip") cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerTwoArn", "layer2.zip") super(TestLayerVersion, cls).setUpClass() @classmethod def tearDownClass(cls): cls.layer_utils.delete_layers() # Added to handle the case where ^C failed the test due to invalid cleanup of layers docker_client = docker.from_env() samcli_images = docker_client.images.list(name="samcli/lambda") for image in samcli_images: docker_client.images.remove(image.id) integ_layer_cache_dir = Path().home().joinpath("integ_layer_cache") if integ_layer_cache_dir.exists(): shutil.rmtree(str(integ_layer_cache_dir)) super(TestLayerVersion, cls).tearDownClass() @parameterized.expand([ ("ReferenceServerlessLayerVersionServerlessFunction"), ("ReferenceLambdaLayerVersionServerlessFunction"), ("ReferenceServerlessLayerVersionLambdaFunction"), ("ReferenceLambdaLayerVersionLambdaFunction"), ("ReferenceServerlessLayerVersionServerlessFunction"), ]) def test_reference_of_layer_version(self, function_logical_id): command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides, ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()).strip() expected_output = '"This is a Layer Ping from simple_python"' self.assertEqual(process_stdout.decode("utf-8"), expected_output) @parameterized.expand([("OneLayerVersionServerlessFunction"), ("OneLayerVersionLambdaFunction")]) def test_download_one_layer(self, function_logical_id): command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides, ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Layer1"' self.assertEqual(process_stdout.decode("utf-8"), expected_output) @parameterized.expand([("ChangedLayerVersionServerlessFunction"), ("ChangedLayerVersionLambdaFunction")]) def test_publish_changed_download_layer(self, function_logical_id): layer_name = self.layer_utils.generate_layer_name() self.layer_utils.upsert_layer(layer_name=layer_name, ref_layer_name="ChangedLayerArn", layer_zip="layer1.zip") command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides, ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Layer1"' self.assertEqual(process_stdout.decode("utf-8"), expected_output) self.layer_utils.upsert_layer(layer_name=layer_name, ref_layer_name="ChangedLayerArn", layer_zip="changedlayer1.zip") command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides, ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Changed_Layer_1"' self.assertEqual(process_stdout.decode("utf-8"), expected_output) @parameterized.expand([("TwoLayerVersionServerlessFunction"), ("TwoLayerVersionLambdaFunction")]) def test_download_two_layers(self, function_logical_id): command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides, ) process = Popen(command_list, stdout=PIPE) process.wait() stdout = process.stdout.readlines() process_stdout = b"".join(stdout[-1:]).strip() expected_output = '"Layer2"' self.assertEqual(process_stdout.decode("utf-8"), expected_output) def test_caching_two_layers(self): command_list = self.get_command_list( "TwoLayerVersionServerlessFunction", template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides, ) process = Popen(command_list, stdout=PIPE) process.wait() self.assertEqual(2, len(os.listdir(str(self.layer_cache)))) def test_caching_two_layers_with_layer_cache_env_set(self): command_list = self.get_command_list( "TwoLayerVersionServerlessFunction", template_path=self.template_path, no_event=True, region=self.region, parameter_overrides=self.layer_utils.parameters_overrides, ) env = os.environ.copy() env["SAM_LAYER_CACHE_BASEDIR"] = str(self.layer_cache) process = Popen(command_list, stdout=PIPE, env=env) process.wait() self.assertEqual(2, len(os.listdir(str(self.layer_cache))))
class TestLayerVersionThatDoNotCreateCache(InvokeIntegBase): template = Path("layers", "layer-template.yml") region = "us-west-2" layer_utils = LayerUtils(region=region) def setUp(self): self.layer_cache = Path().home().joinpath("integ_layer_cache") def tearDown(self): docker_client = docker.from_env() samcli_images = docker_client.images.list(name="samcli/lambda") for image in samcli_images: docker_client.images.remove(image.id) def test_layer_does_not_exist(self): self.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerOneArn", "layer1.zip") non_existent_layer_arn = self.layer_utils.parameters_overrides[ "LayerOneArn"].replace(self.layer_utils.layers_meta[0].layer_name, "non_existent_layer") command_list = self.get_command_list( "LayerVersionDoesNotExistFunction", template_path=self.template_path, no_event=True, region=self.region, parameter_overrides={ "NonExistentLayerArn": non_existent_layer_arn }, ) process = Popen(command_list, stderr=PIPE) try: _, stderr = process.communicate(timeout=TIMEOUT) except TimeoutExpired: process.kill() raise process_stderr = stderr.strip() error_output = process_stderr.decode("utf-8") expected_error_output = "{} was not found.".format( non_existent_layer_arn) self.assertIn(expected_error_output, error_output) self.layer_utils.delete_layers() def test_account_does_not_exist_for_layer(self): command_list = self.get_command_list( "LayerVersionAccountDoesNotExistFunction", template_path=self.template_path, no_event=True, region=self.region, ) process = Popen(command_list, stderr=PIPE) try: _, stderr = process.communicate(timeout=TIMEOUT) except TimeoutExpired: process.kill() raise process_stderr = stderr.strip() error_output = process_stderr.decode("utf-8") expected_error_output = ( "Credentials provided are missing lambda:Getlayerversion policy that is needed to " "download the layer or you do not have permission to download the layer" ) self.assertIn(expected_error_output, error_output)
class TestLayerVersion(InvokeIntegBase): template = Path("layers", "layer-template.yml") region = 'us-west-2' layer_utils = LayerUtils(region=region) def setUp(self): self.layer_cache = Path().home().joinpath("integ_layer_cache") def tearDown(self): docker_client = docker.from_env() samcli_images = docker_client.images.list(name='samcli/lambda') for image in samcli_images: docker_client.images.remove(image.id) shutil.rmtree(str(self.layer_cache)) @classmethod def setUpClass(cls): cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerOneArn", "layer1.zip") cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerTwoArn", "layer2.zip") super(TestLayerVersion, cls).setUpClass() @classmethod def tearDownClass(cls): cls.layer_utils.delete_layers() super(TestLayerVersion, cls).tearDownClass() @parameterized.expand([ ("ReferenceServerlessLayerVersionServerlessFunction"), ("ReferenceLambdaLayerVersionServerlessFunction"), ("ReferenceServerlessLayerVersionLambdaFunction"), ("ReferenceLambdaLayerVersionLambdaFunction"), ("ReferenceServerlessLayerVersionServerlessFunction") ]) def test_reference_of_layer_version(self, function_logical_id): command_list = self.get_command_list(function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()).strip() expected_output = '"This is a Layer Ping from simple_python"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) @parameterized.expand([ ("OneLayerVersionServerlessFunction"), ("OneLayerVersionLambdaFunction") ]) def test_download_one_layer(self, function_logical_id): command_list = self.get_command_list(function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Layer1"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) @parameterized.expand([ ("ChangedLayerVersionServerlessFunction"), ("ChangedLayerVersionLambdaFunction") ]) def test_publish_changed_download_layer(self, function_logical_id): layer_name = self.layer_utils.generate_layer_name() self.layer_utils.upsert_layer(layer_name=layer_name, ref_layer_name="ChangedLayerArn", layer_zip="layer1.zip") command_list = self.get_command_list(function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Layer1"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) self.layer_utils.upsert_layer(layer_name=layer_name, ref_layer_name="ChangedLayerArn", layer_zip="changedlayer1.zip") command_list = self.get_command_list(function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides ) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Changed_Layer_1"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) @parameterized.expand([ ("TwoLayerVersionServerlessFunction"), ("TwoLayerVersionLambdaFunction") ]) def test_download_two_layers(self, function_logical_id): command_list = self.get_command_list(function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides ) process = Popen(command_list, stdout=PIPE) process.wait() stdout = process.stdout.readlines() process_stdout = b"".join(stdout[-1:]).strip() expected_output = '"Layer2"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) def test_caching_two_layers(self): command_list = self.get_command_list("TwoLayerVersionServerlessFunction", template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides ) process = Popen(command_list, stdout=PIPE) process.wait() self.assertEquals(2, len(os.listdir(str(self.layer_cache))))
class TestLayerVersion(InvokeIntegBase): template = Path("layers", "layer-template.yml") region = 'us-west-2' layer_utils = LayerUtils(region=region) def setUp(self): self.layer_cache = Path().home().joinpath("integ_layer_cache") self.layer_cache.mkdir(parents=True, exist_ok=True) def tearDown(self): docker_client = docker.from_env() samcli_images = docker_client.images.list(name='samcli/lambda') for image in samcli_images: docker_client.images.remove(image.id) shutil.rmtree(str(self.layer_cache)) @classmethod def setUpClass(cls): cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerOneArn", "layer1.zip") cls.layer_utils.upsert_layer(LayerUtils.generate_layer_name(), "LayerTwoArn", "layer2.zip") super(TestLayerVersion, cls).setUpClass() @classmethod def tearDownClass(cls): cls.layer_utils.delete_layers() super(TestLayerVersion, cls).tearDownClass() @parameterized.expand([ ("ReferenceServerlessLayerVersionServerlessFunction"), ("ReferenceLambdaLayerVersionServerlessFunction"), ("ReferenceServerlessLayerVersionLambdaFunction"), ("ReferenceLambdaLayerVersionLambdaFunction"), ("ReferenceServerlessLayerVersionServerlessFunction") ]) def test_reference_of_layer_version(self, function_logical_id): command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()).strip() expected_output = '"This is a Layer Ping from simple_python"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) @parameterized.expand([("OneLayerVersionServerlessFunction"), ("OneLayerVersionLambdaFunction")]) def test_download_one_layer(self, function_logical_id): command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Layer1"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) @parameterized.expand([("ChangedLayerVersionServerlessFunction"), ("ChangedLayerVersionLambdaFunction")]) def test_publish_changed_download_layer(self, function_logical_id): layer_name = self.layer_utils.generate_layer_name() self.layer_utils.upsert_layer(layer_name=layer_name, ref_layer_name="ChangedLayerArn", layer_zip="layer1.zip") command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Layer1"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) self.layer_utils.upsert_layer(layer_name=layer_name, ref_layer_name="ChangedLayerArn", layer_zip="changedlayer1.zip") command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides) process = Popen(command_list, stdout=PIPE) process.wait() process_stdout = b"".join(process.stdout.readlines()[-1:]).strip() expected_output = '"Changed_Layer_1"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) @parameterized.expand([("TwoLayerVersionServerlessFunction"), ("TwoLayerVersionLambdaFunction")]) def test_download_two_layers(self, function_logical_id): command_list = self.get_command_list( function_logical_id, template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides) process = Popen(command_list, stdout=PIPE) process.wait() stdout = process.stdout.readlines() process_stdout = b"".join(stdout[-1:]).strip() expected_output = '"Layer2"' self.assertEquals(process_stdout.decode('utf-8'), expected_output) def test_caching_two_layers(self): command_list = self.get_command_list( "TwoLayerVersionServerlessFunction", template_path=self.template_path, no_event=True, region=self.region, layer_cache=str(self.layer_cache), parameter_overrides=self.layer_utils.parameters_overrides) process = Popen(command_list, stdout=PIPE) process.wait() self.assertEquals(2, len(os.listdir(str(self.layer_cache)))) def test_layer_does_not_exist(self): non_existent_layer_arn = self.layer_utils.parameters_overrides[ "LayerOneArn"].replace(self.layer_utils.layers_meta[0].layer_name, 'non_existent_layer') command_list = self.get_command_list( "LayerVersionDoesNotExistFunction", template_path=self.template_path, no_event=True, region=self.region, parameter_overrides={ 'NonExistentLayerArn': non_existent_layer_arn }) process = Popen(command_list, stderr=PIPE) process.wait() process_stderr = b"".join(process.stderr.readlines()).strip() error_output = process_stderr.decode('utf-8') expected_error_output = "{} was not found.".format( non_existent_layer_arn) self.assertIn(expected_error_output, error_output) def test_account_does_not_exist_for_layer(self): command_list = self.get_command_list( "LayerVersionAccountDoesNotExistFunction", template_path=self.template_path, no_event=True, region=self.region) process = Popen(command_list, stderr=PIPE) process.wait() process_stderr = b"".join(process.stderr.readlines()).strip() error_output = process_stderr.decode('utf-8') expected_error_output = "Credentials provided are missing lambda:Getlayerversion policy that is needed to " \ "download the layer or you do not have permission to download the layer" self.assertIn(expected_error_output, error_output)