test: remove integration tests referencing deleted test data

Remove 9 integration tests whose test data directories were removed in
an earlier commit: validate/language-extensions/, buildcmd/language-
extensions-dynamic-imageuri/, language-extensions-foreach/, and
language-extensions-nested-foreach-{valid,invalid}/.

Author: bnusunny

tests/integration/deploy/test_deploy_command.py

@@ -1790,109 +1790,6 @@ def test_deploy_lmi_function(self):
         deploy_process_execute = self.run_command(deploy_command_list)
         self.assertEqual(deploy_process_execute.process.returncode, 0)
 
-    def test_deploy_with_language_extensions_dynamic_imageuri(self):
-        """
-        Test that sam deploy works with Fn::ForEach and dynamic ImageUri.
-
-        This test verifies:
-        1. Deploy succeeds with dynamic ImageUri template
-        2. CloudFormation correctly processes the Fn::ForEach with Mappings
-        3. Both Alpha and Beta functions are created
-
-        Validates Requirements: 12.1, 19.2
-        """
-        # Reuse the image already pulled in setUpClass (latest-x86_64)
-        # and tag it for the alpha/beta function names used by the template.
-        repo = "public.ecr.aws/sam/emulation-python3.9"
-        src_tag = "latest-x86_64"
-        self.docker_client.api.tag(f"{repo}:{src_tag}", "emulation-python3.9-alpha", tag="latest")
-        self.docker_client.api.tag(f"{repo}:{src_tag}", "emulation-python3.9-beta", tag="latest")
-
-        template = (
-            Path(__file__)
-            .resolve()
-            .parents[1]
-            .joinpath("testdata", "buildcmd", "language-extensions-dynamic-imageuri", "template.yaml")
-        )
-        stack_name = self._method_to_stack_name(self.id())
-        self.stacks.append({"name": stack_name})
-
-        deploy_command_list = self.get_deploy_command_list(
-            template_file=template,
-            stack_name=stack_name,
-            s3_prefix=self.s3_prefix,
-            capabilities="CAPABILITY_IAM",
-            image_repository=self.ecr_repo_name,
-        )
-        deploy_process_execute = self.run_command(deploy_command_list)
-        self.assertEqual(deploy_process_execute.process.returncode, 0)
-
-    def test_package_and_deploy_language_extensions_static_codeuri(self):
-        """
-        Test the full package→deploy flow with Fn::ForEach and static CodeUri.
-
-        This test verifies:
-        1. sam package preserves Fn::ForEach structure (not expanded)
-        2. CodeUri is replaced with an S3 URI
-        3. sam deploy succeeds with the packaged template
-        """
-        template_path = self.test_data_path.joinpath("language-extensions-foreach", "template.yaml")
-
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".yaml") as output_template_file:
-            # Package the template
-            package_command_list = self.get_command_list(
-                template=template_path,
-                s3_bucket=self.s3_bucket.name,
-                s3_prefix=self.s3_prefix,
-                output_template_file=output_template_file.name,
-            )
-            package_process = self.run_command(command_list=package_command_list)
-            self.assertEqual(package_process.process.returncode, 0)
-
-            # Read and verify the packaged template
-            with open(output_template_file.name, "r") as f:
-                packaged_template = yaml_parse(f.read())
-
-            # Verify Fn::ForEach structure is preserved
-            resources = packaged_template.get("Resources", {})
-            self.assertIn(
-                "Fn::ForEach::Functions",
-                resources,
-                "Packaged template should preserve Fn::ForEach::Functions structure",
-            )
-
-            # Verify CodeUri was replaced with S3 URI
-            foreach_block = resources["Fn::ForEach::Functions"]
-            body_template = foreach_block[2]
-            function_template = body_template["${FunctionName}Function"]
-            code_uri = function_template["Properties"]["CodeUri"]
-            self.assertIsInstance(code_uri, str, "CodeUri should be a string (S3 URI)")
-            self.assertTrue(
-                code_uri.startswith("s3://"),
-                f"CodeUri should be an S3 URI, got: {code_uri}",
-            )
-
-            # Deploy the packaged template
-            stack_name = self._method_to_stack_name(self.id())
-            self.stacks.append({"name": stack_name})
-
-            deploy_command_list = self.get_deploy_command_list(
-                template_file=output_template_file.name,
-                stack_name=stack_name,
-                capabilities="CAPABILITY_IAM",
-                s3_prefix=self.s3_prefix,
-                s3_bucket=self.s3_bucket.name,
-                force_upload=True,
-                notification_arns=self.sns_arn,
-                kms_key_id=self.kms_key,
-                no_execute_changeset=False,
-                tags="integ=true clarity=yes foo_bar=baz",
-                confirm_changeset=False,
-            )
-
-            deploy_process = self.run_command(deploy_command_list)
-            self.assertEqual(deploy_process.process.returncode, 0)
-
     def test_package_and_deploy_language_extensions_dynamic_codeuri(self):
         """
         Test the full package→deploy flow with Fn::ForEach and dynamic CodeUri.

tests/integration/validate/test_validate_command.py

@@ -285,279 +285,3 @@ def test_lint_invalid_template(self):
 
         self.assertIn(warning_message, output)
         self.assertEqual(command_result.process.returncode, 1)
-
-    def test_validate_language_extensions_valid_foreach(self):
-        """
-        Test that sam validate passes for valid Fn::ForEach syntax.
-
-        Validates: Requirements 7.1, 12.3
-        - 7.1: WHEN `sam validate` processes a template with valid `Fn::ForEach` syntax,
-               THE Validate_Command SHALL report the template as valid
-        - 12.3: THE Integration_Tests SHALL verify `sam validate` correctly validates
-                templates with language extensions
-        """
-        test_data_path = (
-            Path(__file__).resolve().parents[2] / "integration" / "testdata" / "validate" / "language-extensions"
-        )
-        template_file = "valid-foreach.yaml"
-        template_path = test_data_path / template_file
-
-        command_result = run_command(self.command_list(template_file=template_path))
-        output = command_result.stdout.decode("utf-8")
-
-        # Verify the command succeeds (exit code 0)
-        self.assertEqual(
-            command_result.process.returncode,
-            0,
-            f"Expected exit code 0 but got {command_result.process.returncode}. Output: {output}",
-        )
-
-        # Verify the output indicates the template is valid
-        # The output should contain a message indicating the template is valid
-        valid_pattern = re.compile(
-            r"valid-foreach\.yaml is a valid SAM Template\. This is according to basic SAM Validation, "
-            'for additional validation, please run with "--lint" option(\r\n)?$'
-        )
-        self.assertRegex(
-            output,
-            valid_pattern,
-            f"Expected output to indicate template is valid. Actual output: {output}",
-        )
-
-    def test_validate_language_extensions_invalid_foreach(self):
-        """
-        Test that sam validate fails with clear error message for invalid Fn::ForEach syntax.
-
-        Validates: Requirements 7.2, 12.4
-        - 7.2: WHEN `sam validate` processes a template with invalid `Fn::ForEach` syntax
-               (e.g., wrong number of arguments), THE Validate_Command SHALL report a
-               clear error message
-        - 12.4: THE Integration_Tests SHALL verify `sam validate` reports errors for
-                invalid language extension syntax
-        """
-        test_data_path = (
-            Path(__file__).resolve().parents[2] / "integration" / "testdata" / "validate" / "language-extensions"
-        )
-        template_file = "invalid-foreach.yaml"
-        template_path = test_data_path / template_file
-
-        command_result = run_command(self.command_list(template_file=template_path))
-        # Combine stdout and stderr for error message checking
-        stdout_output = command_result.stdout.decode("utf-8")
-        stderr_output = command_result.stderr.decode("utf-8")
-        combined_output = stdout_output + stderr_output
-
-        # Verify the command fails (non-zero exit code)
-        self.assertNotEqual(
-            command_result.process.returncode,
-            0,
-            f"Expected non-zero exit code but got {command_result.process.returncode}. Output: {combined_output}",
-        )
-
-        # Verify the output contains the specific error about invalid ForEach layout
-        self.assertIn(
-            "layout is incorrect",
-            combined_output,
-            f"Expected 'layout is incorrect' error for invalid Fn::ForEach syntax. Actual output: {combined_output}",
-        )
-
-    def test_validate_language_extensions_valid_dynamic_codeuri(self):
-        """
-        Test that sam validate passes for valid Fn::ForEach with dynamic CodeUri.
-
-        Validates: Requirements 4.1, 10.1
-        - 4.1: Dynamic artifact properties (e.g., CodeUri: ./${Name}) are supported
-        - 10.1: sam validate should pass for valid templates with dynamic CodeUri
-        """
-        test_data_path = (
-            Path(__file__).resolve().parents[2] / "integration" / "testdata" / "validate" / "language-extensions"
-        )
-        template_file = "valid-dynamic-codeuri.yaml"
-        template_path = test_data_path / template_file
-
-        command_result = run_command(self.command_list(template_file=template_path))
-        output = command_result.stdout.decode("utf-8")
-
-        # Verify the command succeeds (exit code 0)
-        self.assertEqual(
-            command_result.process.returncode,
-            0,
-            f"Expected exit code 0 but got {command_result.process.returncode}. Output: {output}",
-        )
-
-        # Verify the output indicates the template is valid
-        valid_pattern = re.compile(
-            r"valid-dynamic-codeuri\.yaml is a valid SAM Template\. This is according to basic SAM Validation, "
-            'for additional validation, please run with "--lint" option(\r\n)?$'
-        )
-        self.assertRegex(
-            output,
-            valid_pattern,
-            f"Expected output to indicate template is valid. Actual output: {output}",
-        )
-
-    def test_validate_language_extensions_cloud_dependent_collection(self):
-        """
-        Test that sam validate fails with clear error for cloud-dependent collection.
-
-        Validates: Requirements 5.1, 5.4, 5.5
-        - 5.1: Fn::GetAtt in collection should raise error with clear message
-        - 5.4: Error message should include which Fn::ForEach block has the issue
-        - 5.5: Error message should suggest using parameter with --parameter-overrides
-        """
-        test_data_path = (
-            Path(__file__).resolve().parents[2] / "integration" / "testdata" / "validate" / "language-extensions"
-        )
-        template_file = "cloud-dependent-collection.yaml"
-        template_path = test_data_path / template_file
-
-        command_result = run_command(self.command_list(template_file=template_path))
-        # Combine stdout and stderr for error message checking
-        stdout_output = command_result.stdout.decode("utf-8")
-        stderr_output = command_result.stderr.decode("utf-8")
-        combined_output = stdout_output + stderr_output
-
-        # Verify the command fails (non-zero exit code)
-        self.assertNotEqual(
-            command_result.process.returncode,
-            0,
-            f"Expected non-zero exit code but got {command_result.process.returncode}. Output: {combined_output}",
-        )
-
-        # Verify the output contains the specific error about unresolvable collection
-        self.assertIn(
-            "Unable to resolve Fn::ForEach collection locally",
-            combined_output,
-            f"Expected 'Unable to resolve Fn::ForEach collection locally' error. Actual output: {combined_output}",
-        )
-
-    def test_validate_language_extensions_missing_dynamic_artifact_dir(self):
-        """
-        Test that sam validate handles templates with dynamic CodeUri pointing to non-existent directories.
-
-        Validates: Requirements 4.1
-        - 4.1: Dynamic artifact properties should be validated
-
-        Note: sam validate performs basic SAM validation which may not check if directories exist.
-        This test verifies the behavior when dynamic CodeUri points to non-existent directories.
-        """
-        test_data_path = (
-            Path(__file__).resolve().parents[2] / "integration" / "testdata" / "validate" / "language-extensions"
-        )
-        template_file = "missing-dynamic-artifact-dir.yaml"
-        template_path = test_data_path / template_file
-
-        command_result = run_command(self.command_list(template_file=template_path))
-        stdout_output = command_result.stdout.decode("utf-8")
-        stderr_output = command_result.stderr.decode("utf-8")
-        combined_output = stdout_output + stderr_output
-
-        # sam validate performs basic SAM template validation only — it does not check
-        # whether artifact directories exist on disk. Directory validation happens at
-        # build time. The template is syntactically valid, so validate should pass.
-        self.assertEqual(
-            command_result.process.returncode,
-            0,
-            f"sam validate should pass for syntactically valid template (directory checks happen at build time). "
-            f"Output: {combined_output}",
-        )
-
-    def test_validate_language_extensions_nested_foreach_valid_depth_5(self):
-        """
-        Test that sam validate passes for templates with 5 levels of nested Fn::ForEach.
-
-        Validates: Requirements 18.2, 18.6
-        - 18.2: WHEN a template contains 5 or fewer levels of nested Fn::ForEach loops,
-                THE SAM_CLI SHALL process the template successfully
-        - 18.6: WHEN `sam validate` processes a template exceeding the nested loop limit,
-                THE Validate_Command SHALL report the nesting depth error
-        """
-        test_data_path = (
-            Path(__file__).resolve().parents[2]
-            / "integration"
-            / "testdata"
-            / "buildcmd"
-            / "language-extensions-nested-foreach-valid"
-        )
-        template_file = "template.yaml"
-        template_path = test_data_path / template_file
-
-        command_result = run_command(self.command_list(template_file=template_path))
-        output = command_result.stdout.decode("utf-8")
-
-        # Verify the command succeeds (exit code 0)
-        self.assertEqual(
-            command_result.process.returncode,
-            0,
-            f"Expected exit code 0 but got {command_result.process.returncode}. Output: {output}",
-        )
-
-        # Verify the output indicates the template is valid
-        valid_pattern = re.compile(
-            r"template\.yaml is a valid SAM Template\. This is according to basic SAM Validation, "
-            'for additional validation, please run with "--lint" option(\r\n)?$'
-        )
-        self.assertRegex(
-            output,
-            valid_pattern,
-            f"Expected output to indicate template is valid. Actual output: {output}",
-        )
-
-    def test_validate_language_extensions_nested_foreach_invalid_depth_6(self):
-        """
-        Test that sam validate fails for templates with 6 levels of nested Fn::ForEach.
-
-        Validates: Requirements 18.3, 18.4, 18.5, 18.6
-        - 18.3: WHEN a template contains more than 5 levels of nested Fn::ForEach loops,
-                THE SAM_CLI SHALL raise an error before processing
-        - 18.4: WHEN the nested loop limit is exceeded, THE error message SHALL clearly
-                indicate that the maximum nesting depth of 5 has been exceeded
-        - 18.5: WHEN the nested loop limit is exceeded, THE error message SHALL indicate
-                the actual nesting depth found in the template
-        - 18.6: WHEN `sam validate` processes a template exceeding the nested loop limit,
-                THE Validate_Command SHALL report the nesting depth error
-        """
-        test_data_path = (
-            Path(__file__).resolve().parents[2]
-            / "integration"
-            / "testdata"
-            / "buildcmd"
-            / "language-extensions-nested-foreach-invalid"
-        )
-        template_file = "template.yaml"
-        template_path = test_data_path / template_file
-
-        command_result = run_command(self.command_list(template_file=template_path))
-        # Combine stdout and stderr for error message checking
-        stdout_output = command_result.stdout.decode("utf-8")
-        stderr_output = command_result.stderr.decode("utf-8")
-        combined_output = stdout_output + stderr_output
-
-        # Verify the command fails (non-zero exit code)
-        self.assertNotEqual(
-            command_result.process.returncode,
-            0,
-            f"Expected non-zero exit code but got {command_result.process.returncode}. Output: {combined_output}",
-        )
-
-        # Requirement 18.4: Error message indicates maximum nesting depth of 5
-        self.assertIn(
-            "5",
-            combined_output,
-            f"Expected error message to mention maximum depth of 5. Actual output: {combined_output}",
-        )
-
-        # Requirement 18.5: Error message indicates actual nesting depth found (6)
-        self.assertIn(
-            "6",
-            combined_output,
-            f"Expected error message to mention actual depth of 6. Actual output: {combined_output}",
-        )
-
-        # Verify the error message mentions nesting or depth
-        nesting_indicators = ["nesting", "depth", "exceeds", "maximum", "nested"]
-        has_nesting_indicator = any(indicator.lower() in combined_output.lower() for indicator in nesting_indicators)
-        self.assertTrue(
-            has_nesting_indicator,
-            f"Expected error message about nesting depth. Actual output: {combined_output}",
-        )