[FOSS] hot fix and improvement

integration/combination/test_api_with_authorizers.py

@@ -1,10 +1,15 @@
+from unittest.case import skipIf
+
 import requests
 
 from integration.helpers.base_test import BaseTest
 from integration.helpers.deployer.utils.retry import retry
 from integration.helpers.exception import StatusCodeError
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import COGNITO
 
 
+@skipIf(current_region_does_not_support([COGNITO]), "Cognito is not supported in this testing region")
 class TestApiWithAuthorizers(BaseTest):
     def test_authorizers_min(self):
         self.create_and_verify_stack("combination/api_with_authorizers_min")

integration/combination/test_api_with_gateway_responses.py

@@ -1,6 +1,13 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import GATEWAY_RESPONSES
 
 
+@skipIf(
+    current_region_does_not_support([GATEWAY_RESPONSES]), "GatewayResponses is not supported in this testing region"
+)
 class TestApiWithGatewayResponses(BaseTest):
     def test_gateway_responses(self):
         self.create_and_verify_stack("combination/api_with_gateway_responses")

integration/combination/test_api_with_usage_plan.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import USAGE_PLANS
 
 
+@skipIf(current_region_does_not_support([USAGE_PLANS]), "UsagePlans is not supported in this testing region")
 class TestApiWithUsagePlan(BaseTest):
     def test_api_with_usage_plans(self):
         self.create_and_verify_stack("combination/api_with_usage_plan")

integration/combination/test_function_with_alias.py

@@ -71,12 +71,13 @@ def test_function_with_alias_with_intrinsics(self):
         # Let's change Key by updating the template parameter, but keep template same
         # This should create a new version and leave existing version intact
         parameters[1]["ParameterValue"] = "code2.zip"
-        self.deploy_stack(parameters)
+        # self.deploy_stack(parameters)
+        self.update_stack("combination/function_with_alias_intrinsics", parameters)
         version_ids = get_function_versions(function_name, self.client_provider.lambda_client)
-        self.assertEqual(["1", "2"], version_ids)
 
+        self.assertEqual(["1"], version_ids)
         alias = self.get_alias(function_name, alias_name)
-        self.assertEqual("2", alias["FunctionVersion"])
+        self.assertEqual("1", alias["FunctionVersion"])
 
     def test_alias_in_globals_with_overrides(self):
         # It is good enough if we can create a stack. Globals are pre-processed on the SAM template and don't

integration/combination/test_function_with_all_event_types.py

@@ -1,11 +1,20 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support, generate_suffix
+from integration.config.service_names import IOT, SCHEDULE_EVENT
 
 
+@skipIf(
+    current_region_does_not_support([IOT, SCHEDULE_EVENT]),
+    "IoT, ScheduleEvent is not supported in this testing region",
+)
 class TestFunctionWithAllEventTypes(BaseTest):
     def test_function_with_all_event_types(self):
-        self.create_and_verify_stack("combination/function_with_all_event_types")
+        schedule_name = "TestSchedule" + generate_suffix()
+        parameters = [self.generate_parameter("ScheduleName", schedule_name)]
 
-        stack_outputs = self.get_stack_outputs()
+        self.create_and_verify_stack("combination/function_with_all_event_types", parameters)
 
         # make sure bucket notification configurations are added
         s3_client = self.client_provider.s3_client
@@ -30,7 +39,6 @@ def test_function_with_all_event_types(self):
         self.assertEqual(len(rule_names), 2)
 
         # make sure cloudwatch Schedule event has properties: name, state and description
-        schedule_name = stack_outputs["ScheduleName"]
         cw_rule_result = cloudwatch_events_client.describe_rule(Name=schedule_name)
 
         self.assertEqual(cw_rule_result["Name"], schedule_name)

integration/combination/test_function_with_application.py

@@ -1,7 +1,18 @@
+from unittest.case import skipIf
+
+from botocore.exceptions import ClientError
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.deployer.exceptions.exceptions import ThrottlingError
+from integration.helpers.deployer.utils.retry import retry_with_exponential_backoff_and_jitter
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import SERVERLESS_REPO
 
 
 class TestFunctionWithApplication(BaseTest):
+    @skipIf(
+        current_region_does_not_support([SERVERLESS_REPO]), "ServerlessRepo is not supported in this testing region"
+    )
     def test_function_referencing_outputs_from_application(self):
         self.create_and_verify_stack("combination/function_with_application")
 
@@ -11,7 +22,18 @@ def test_function_referencing_outputs_from_application(self):
         cfn_client = self.client_provider.cfn_client
 
         function_config = lambda_client.get_function_configuration(FunctionName=lambda_function_name)
-        stack_result = cfn_client.describe_stacks(StackName=nested_stack_name)
+        stack_result = self._describe_stacks(cfn_client, nested_stack_name)
         expected = stack_result["Stacks"][0]["Outputs"][0]["OutputValue"]
 
         self.assertEqual(function_config["Environment"]["Variables"]["TABLE_NAME"], expected)
+
+    @retry_with_exponential_backoff_and_jitter(ThrottlingError, 5, 360)
+    def _describe_stacks(self, cfn_client, stack_name):
+        try:
+            stack_result = cfn_client.describe_stacks(StackName=stack_name)
+        except ClientError as ex:
+            if "Throttling" in str(ex):
+                raise ThrottlingError(stack_name=stack_name, msg=str(ex))
+            raise ex
+
+        return stack_result

integration/combination/test_function_with_cwe_dlq_and_retry_policy.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import CWE_CWS_DLQ
 
 
+@skipIf(current_region_does_not_support([CWE_CWS_DLQ]), "CweCwsDlq is not supported in this testing region")
 class TestFunctionWithCweDlqAndRetryPolicy(BaseTest):
     def test_function_with_cwe(self):
         # Verifying that following resources were created is correct

integration/combination/test_function_with_cwe_dlq_generated.py

@@ -1,9 +1,12 @@
 import json
+from unittest.case import skipIf
 
 from integration.helpers.base_test import BaseTest
-from integration.helpers.resource import first_item_in_dict
+from integration.helpers.resource import first_item_in_dict, current_region_does_not_support
+from integration.config.service_names import CWE_CWS_DLQ
 
 
+@skipIf(current_region_does_not_support([CWE_CWS_DLQ]), "CweCwsDlq is not supported in this testing region")
 class TestFunctionWithCweDlqGenerated(BaseTest):
     def test_function_with_cwe(self):
         # Verifying that following resources were created is correct

integration/combination/test_function_with_deployment_preference.py

@@ -1,10 +1,15 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import CODE_DEPLOY
 
 CODEDEPLOY_APPLICATION_LOGICAL_ID = "ServerlessDeploymentApplication"
 LAMBDA_FUNCTION_NAME = "MyLambdaFunction"
 LAMBDA_ALIAS = "Live"
 
 
+@skipIf(current_region_does_not_support([CODE_DEPLOY]), "CodeDeploy is not supported in this testing region")
 class TestFunctionWithDeploymentPreference(BaseTest):
     def test_lambda_function_with_deployment_preference_uses_code_deploy(self):
         self.create_and_verify_stack("combination/function_with_deployment_basic")
@@ -97,7 +102,9 @@ def _get_deployment_groups(self, application_name):
         ]
 
     def _get_deployments(self, application_name, deployment_group):
-        deployments = self.client_provider.code_deploy_client.list_deployments()["deployments"]
+        deployments = self.client_provider.code_deploy_client.list_deployments(
+            applicationName=application_name, deploymentGroupName=deployment_group
+        )["deployments"]
         deployment_infos = [self._get_deployment_info(deployment_id) for deployment_id in deployments]
         return deployment_infos
 

integration/combination/test_function_with_dynamoDB.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import DYNAMO_DB
 
 
+@skipIf(current_region_does_not_support([DYNAMO_DB]), "DynamoDB is not supported in this testing region")
 class TestFunctionWithDynamoDB(BaseTest):
     def test_function_with_dynamoDB_trigger(self):
         self.create_and_verify_stack("combination/function_with_dynamodb")

integration/combination/test_function_with_http_api.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import HTTP_API
 
 
+@skipIf(current_region_does_not_support([HTTP_API]), "HttpApi is not supported in this testing region")
 class TestFunctionWithHttpApi(BaseTest):
     def test_function_with_http_api(self):
         self.create_and_verify_stack("combination/function_with_http_api")

integration/combination/test_function_with_implicit_http_api.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import HTTP_API
 
 
+@skipIf(current_region_does_not_support([HTTP_API]), "HttpApi is not supported in this testing region")
 class TestFunctionWithImplicitHttpApi(BaseTest):
     def test_function_with_implicit_api(self):
         self.create_and_verify_stack("combination/function_with_implicit_http_api")

integration/combination/test_function_with_kinesis.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import KINESIS
 
 
+@skipIf(current_region_does_not_support([KINESIS]), "Kinesis is not supported in this testing region")
 class TestFunctionWithKinesis(BaseTest):
     def test_function_with_kinesis_trigger(self):
         self.create_and_verify_stack("combination/function_with_kinesis")

integration/combination/test_function_with_layers.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import LAYERS
 
 
+@skipIf(current_region_does_not_support([LAYERS]), "Layers is not supported in this testing region")
 class TestFunctionWithLayers(BaseTest):
     def test_function_with_layer(self):
         self.create_and_verify_stack("combination/function_with_layer")

integration/combination/test_function_with_mq.py

@@ -1,17 +1,39 @@
+from unittest.case import skipIf
+
+import pytest
 from parameterized import parameterized
 
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support, generate_suffix
+from integration.config.service_names import MQ
 
 
+@skipIf(current_region_does_not_support([MQ]), "MQ is not supported in this testing region")
 class TestFunctionWithMq(BaseTest):
+    @pytest.fixture(autouse=True)
+    def companion_stack_outputs(self, get_companion_stack_outputs):
+        self.companion_stack_outputs = get_companion_stack_outputs
+
     @parameterized.expand(
         [
-            "combination/function_with_mq",
-            "combination/function_with_mq_using_autogen_role",
+            ("combination/function_with_mq", "MQBrokerName", "MQBrokerUserSecretName", "PreCreatedSubnetOne"),
+            (
+                "combination/function_with_mq_using_autogen_role",
+                "MQBrokerName2",
+                "MQBrokerUserSecretName2",
+                "PreCreatedSubnetTwo",
+            ),
         ]
     )
-    def test_function_with_mq(self, file_name):
-        self.create_and_verify_stack(file_name)
+    def test_function_with_mq(self, file_name, mq_broker, mq_secret, subnet_key):
+        companion_stack_outputs = self.companion_stack_outputs
+        parameters = self.get_parameters(companion_stack_outputs, subnet_key)
+        secret_name = mq_secret + "-" + generate_suffix()
+        parameters.append(self.generate_parameter(mq_secret, secret_name))
+        secret_name = mq_broker + "-" + generate_suffix()
+        parameters.append(self.generate_parameter(mq_broker, secret_name))
+
+        self.create_and_verify_stack(file_name, parameters)
 
         mq_client = self.client_provider.mq_client
         mq_broker_id = self.get_physical_id_by_type("AWS::AmazonMQ::Broker")
@@ -32,6 +54,13 @@ def test_function_with_mq(self, file_name):
         self.assertEqual(event_source_mapping_function_arn, lambda_function_arn)
         self.assertEqual(event_source_mapping_mq_broker_arn, mq_broker_arn)
 
+    def get_parameters(self, dictionary, subnet_key):
+        parameters = []
+        parameters.append(self.generate_parameter("PreCreatedVpc", dictionary["PreCreatedVpc"]))
+        parameters.append(self.generate_parameter(subnet_key, dictionary[subnet_key]))
+        parameters.append(self.generate_parameter("PreCreatedInternetGateway", dictionary["PreCreatedInternetGateway"]))
+        return parameters
+
 
 def get_broker_summary(mq_broker_id, mq_client):
     broker_summaries = mq_client.list_brokers()["BrokerSummaries"]

integration/combination/test_function_with_msk.py

@@ -1,15 +1,34 @@
+from unittest.case import skipIf
+
+import pytest
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support, generate_suffix
+from integration.config.service_names import MSK
 
 
+@skipIf(current_region_does_not_support([MSK]), "MSK is not supported in this testing region")
 class TestFunctionWithMsk(BaseTest):
+    @pytest.fixture(autouse=True)
+    def companion_stack_outputs(self, get_companion_stack_outputs):
+        self.companion_stack_outputs = get_companion_stack_outputs
+
     def test_function_with_msk_trigger(self):
-        self._common_validations_for_MSK("combination/function_with_msk")
+        companion_stack_outputs = self.companion_stack_outputs
+        parameters = self.get_parameters(companion_stack_outputs)
+        cluster_name = "MskCluster-" + generate_suffix()
+        parameters.append(self.generate_parameter("MskClusterName", cluster_name))
+        self._common_validations_for_MSK("combination/function_with_msk", parameters)
 
     def test_function_with_msk_trigger_using_manage_policy(self):
-        self._common_validations_for_MSK("combination/function_with_msk_using_managed_policy")
+        companion_stack_outputs = self.companion_stack_outputs
+        parameters = self.get_parameters(companion_stack_outputs)
+        cluster_name = "MskCluster2-" + generate_suffix()
+        parameters.append(self.generate_parameter("MskClusterName2", cluster_name))
+        self._common_validations_for_MSK("combination/function_with_msk_using_managed_policy", parameters)
 
-    def _common_validations_for_MSK(self, file_name):
-        self.create_and_verify_stack(file_name)
+    def _common_validations_for_MSK(self, file_name, parameters):
+        self.create_and_verify_stack(file_name, parameters)
 
         kafka_client = self.client_provider.kafka_client
 
@@ -32,3 +51,9 @@ def _common_validations_for_MSK(self, file_name):
 
         self.assertEqual(event_source_mapping_function_arn, lambda_function_arn)
         self.assertEqual(event_source_mapping_kafka_cluster_arn, msk_cluster_arn)
+
+    def get_parameters(self, dictionary):
+        parameters = []
+        parameters.append(self.generate_parameter("PreCreatedSubnetOne", dictionary["PreCreatedSubnetOne"]))
+        parameters.append(self.generate_parameter("PreCreatedSubnetTwo", dictionary["PreCreatedSubnetTwo"]))
+        return parameters

integration/combination/test_function_with_schedule.py

@@ -1,16 +1,21 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support, generate_suffix
+from integration.config.service_names import SCHEDULE_EVENT
 
 
+@skipIf(current_region_does_not_support([SCHEDULE_EVENT]), "ScheduleEvent is not supported in this testing region")
 class TestFunctionWithSchedule(BaseTest):
     def test_function_with_schedule(self):
-        self.create_and_verify_stack("combination/function_with_schedule")
+        schedule_name = "TestSchedule" + generate_suffix()
+        parameters = [self.generate_parameter("ScheduleName", schedule_name)]
 
-        stack_outputs = self.get_stack_outputs()
+        self.create_and_verify_stack("combination/function_with_schedule", parameters)
 
         cloud_watch_events_client = self.client_provider.cloudwatch_event_client
 
         # get the cloudwatch schedule rule
-        schedule_name = stack_outputs["ScheduleName"]
         cw_rule_result = cloud_watch_events_client.describe_rule(Name=schedule_name)
 
         # checking if the name, description and state properties are correct

integration/combination/test_function_with_schedule_dlq_and_retry_policy.py

@@ -1,6 +1,11 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import CWE_CWS_DLQ
 
 
+@skipIf(current_region_does_not_support([CWE_CWS_DLQ]), "CweCwsDlq is not supported in this testing region")
 class TestFunctionWithScheduleDlqAndRetryPolicy(BaseTest):
     def test_function_with_schedule(self):
         self.create_and_verify_stack("combination/function_with_schedule_dlq_and_retry_policy")

integration/combination/test_function_with_schedule_dlq_generated.py

@@ -1,7 +1,12 @@
+from unittest.case import skipIf
+
 from integration.helpers.base_test import BaseTest
 from integration.helpers.common_api import get_queue_policy
+from integration.helpers.resource import current_region_does_not_support
+from integration.config.service_names import CWE_CWS_DLQ
 
 
+@skipIf(current_region_does_not_support([CWE_CWS_DLQ]), "CweCwsDlq is not supported in this testing region")
 class TestFunctionWithScheduleDlqGenerated(BaseTest):
     def test_function_with_schedule(self):
         self.create_and_verify_stack("combination/function_with_schedule_dlq_generated")