added new unit tests to validate forEach entities

Author: Deep Furiya

src/context/semantic/Entity.ts

@@ -181,9 +181,9 @@ export class Unknown extends Entity {
 export class ForEachResource extends Entity {
     constructor(
         public readonly name: string,
-        public readonly identifier: string,
-        public readonly collection: CfnValue,
-        public readonly resource: Resource,
+        public readonly identifier?: string,
+        public readonly collection?: CfnValue,
+        public readonly resource?: Resource,
     ) {
         super(EntityType.ForEachResource);
     }

src/context/semantic/EntityBuilder.ts

@@ -62,11 +62,11 @@ export function createEntityFromObject(logicalId: string, entityObject: any, sec
         case TopLevelSection.Resources: {
             if (logicalId.startsWith('Fn::ForEach')) {
                 const loopName = logicalId.replace('Fn::ForEach::', '');
-                const identifier = Array.isArray(entityObject) ? entityObject[0] : '';
+                const identifier = Array.isArray(entityObject) ? entityObject[0] : undefined;
                 const collection = Array.isArray(entityObject) ? entityObject[1] : undefined;
                 const outputMap = Array.isArray(entityObject) ? entityObject[2] : {};
-                const [key, value]: [string, any] = Object.entries(outputMap ?? {})[0] || ['', {}];
-                const resource = new Resource(
+                const [key, value]: [string, any] = Object.entries(outputMap ?? {})[0] || [undefined, {}];
+                const resourceInsideForEach = new Resource(
                     key,
                     value?.Type,
                     value?.Properties,
@@ -78,7 +78,7 @@ export function createEntityFromObject(logicalId: string, entityObject: any, sec
                     value?.UpdatePolicy,
                     value?.UpdateReplacePolicy,
                 );
-                return new ForEachResource(loopName, identifier, collection, resource);
+                return new ForEachResource(loopName, identifier, collection, resourceInsideForEach);
             }
             return new Resource(
                 logicalId,

tst/resources/templates/foreach_template.json

@@ -0,0 +1,44 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Description": "Template with Fn::ForEach examples",
+  "Transform": "AWS::LanguageExtensions",
+  "Parameters": {
+    "BucketNames": {
+      "Type": "CommaDelimitedList",
+      "Default": "bucket1,bucket2,bucket3",
+      "Description": "List of bucket names for ForEach"
+    }
+  },
+  "Resources": {
+    "Fn::ForEach::Buckets": [
+      "BucketName",
+      { "Ref": "BucketNames" },
+      {
+        "S3Bucket${BucketName}": {
+          "Type": "AWS::S3::Bucket",
+          "Properties": {
+            "BucketName": { "Fn::Sub": "${BucketName}-${AWS::AccountId}-${AWS::Region}" },
+            "VersioningConfiguration": {
+              "Status": "Enabled"
+            },
+            "BucketEncryption": {
+              "ServerSideEncryptionConfiguration": [
+                {
+                  "ServerSideEncryptionByDefault": {
+                    "SSEAlgorithm": "AES256"
+                  }
+                }
+              ]
+            }
+          }
+        }
+      }
+    ],
+    "RegularResource": {
+      "Type": "AWS::S3::Bucket",
+      "Properties": {
+        "BucketName": "regular-bucket"
+      }
+    }
+  }
+}

tst/resources/templates/foreach_template.yaml

@@ -0,0 +1,29 @@
+AWSTemplateFormatVersion: "2010-09-09"
+Description: "Template with Fn::ForEach examples"
+Transform: AWS::LanguageExtensions
+
+Parameters:
+  BucketNames:
+    Type: CommaDelimitedList
+    Default: "bucket1,bucket2,bucket3"
+    Description: "List of bucket names for ForEach"
+
+Resources:
+  Fn::ForEach::Buckets:
+    - BucketName
+    - !Ref BucketNames
+    - S3Bucket${BucketName}:
+        Type: AWS::S3::Bucket
+        Properties:
+          BucketName: !Sub "${BucketName}-${AWS::AccountId}-${AWS::Region}"
+          VersioningConfiguration:
+            Status: Enabled
+          BucketEncryption:
+            ServerSideEncryptionConfiguration:
+              - ServerSideEncryptionByDefault:
+                  SSEAlgorithm: AES256
+
+  RegularResource:
+    Type: AWS::S3::Bucket
+    Properties:
+      BucketName: regular-bucket

tst/unit/context/Context.test.ts

@@ -2,7 +2,14 @@ import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { Context } from '../../../src/context/Context';
 import { ContextManager } from '../../../src/context/ContextManager';
 import { TopLevelSection } from '../../../src/context/ContextType';
-import { Parameter, Resource, Condition, Mapping, Unknown } from '../../../src/context/semantic/Entity';
+import {
+    Parameter,
+    Resource,
+    Condition,
+    Mapping,
+    Unknown,
+    ForEachResource,
+} from '../../../src/context/semantic/Entity';
 import { SyntaxTreeManager } from '../../../src/context/syntaxtree/SyntaxTreeManager';
 import { docPosition, Templates } from '../../utils/TemplateUtils';
 
@@ -679,4 +686,111 @@ Resources:
             expect(context!.textInQuotes()).toBeUndefined();
         });
     });
+
+    describe('ForEachResource Entity Parsing', () => {
+        const foreachYamlUri = Templates.foreach.yaml.fileName;
+        const foreachJsonUri = Templates.foreach.json.fileName;
+        const foreachYaml = Templates.foreach.yaml.contents;
+        const foreachJson = Templates.foreach.json.contents;
+
+        beforeAll(() => {
+            syntaxTreeManager.add(foreachYamlUri, foreachYaml);
+            syntaxTreeManager.add(foreachJsonUri, foreachJson);
+        });
+
+        describe('YAML ForEach', () => {
+            it('should parse ForEach resource name', () => {
+                const context = getContextAt(11, 4, foreachYamlUri); // Position at "Fn::ForEach::Buckets:"
+
+                expect(context).toBeDefined();
+                expect(context!.section).toBe(TopLevelSection.Resources);
+                expect(context!.logicalId).toBe('Fn::ForEach::Buckets');
+                expect(context!.text).toBe('Fn::ForEach::Buckets');
+            });
+
+            it('should create ForEachResource entity with correct properties', () => {
+                const context = getContextAt(11, 4, foreachYamlUri); // Fn::ForEach::Buckets
+
+                expect(context).toBeDefined();
+                const entity = context!.entity;
+                expect(entity).toBeInstanceOf(ForEachResource);
+
+                const forEachResource = entity as ForEachResource;
+                expect(forEachResource.name).toBe('Buckets');
+                expect(forEachResource.identifier).toBe('BucketName');
+                expect(forEachResource.collection).toBeDefined();
+                expect(forEachResource.collection).toHaveProperty('!Ref', 'BucketNames');
+                expect(forEachResource.resource).toBeInstanceOf(Resource);
+            });
+
+            it('should parse nested resource in ForEach', () => {
+                const context = getContextAt(11, 4, foreachYamlUri);
+
+                expect(context).toBeDefined();
+                const entity = context!.entity as ForEachResource;
+                const nestedResource = entity.resource;
+
+                expect(nestedResource).toBeInstanceOf(Resource);
+                expect(nestedResource?.name).toBe('S3Bucket${BucketName}');
+                expect(nestedResource?.Type).toBe('AWS::S3::Bucket');
+                expect(nestedResource?.Properties).toBeDefined();
+                expect(nestedResource?.Properties).toHaveProperty('BucketName');
+                expect(nestedResource?.Properties).toHaveProperty('VersioningConfiguration');
+                expect(nestedResource?.Properties?.VersioningConfiguration).toHaveProperty('Status', 'Enabled');
+                expect(nestedResource?.Properties).toHaveProperty('BucketEncryption');
+            });
+
+            it('should parse regular resource after ForEach', () => {
+                const context = getContextAt(26, 4, foreachYamlUri); // Position at "RegularResource:"
+
+                expect(context).toBeDefined();
+                expect(context!.section).toBe(TopLevelSection.Resources);
+                expect(context!.logicalId).toBe('RegularResource');
+                expect(context!.entity).toBeInstanceOf(Resource);
+                expect(context!.entity).not.toBeInstanceOf(ForEachResource);
+            });
+        });
+
+        describe('JSON ForEach', () => {
+            it('should parse ForEach resource name in JSON', () => {
+                const context = getContextAt(12, 8, foreachJsonUri); // Position at "Fn::ForEach::Buckets"
+
+                expect(context).toBeDefined();
+                expect(context!.section).toBe(TopLevelSection.Resources);
+                expect(context!.logicalId).toBe('Fn::ForEach::Buckets');
+            });
+
+            it('should create ForEachResource entity from JSON', () => {
+                const context = getContextAt(12, 8, foreachJsonUri);
+
+                expect(context).toBeDefined();
+                const entity = context!.entity;
+                expect(entity).toBeInstanceOf(ForEachResource);
+
+                const forEachResource = entity as ForEachResource;
+                expect(forEachResource.name).toBe('Buckets');
+                expect(forEachResource.identifier).toBe('BucketName');
+                expect(forEachResource.collection).toBeDefined();
+                expect(forEachResource.collection).toHaveProperty('Ref', 'BucketNames');
+                expect(forEachResource.resource).toBeInstanceOf(Resource);
+            });
+
+            it('should parse nested resource in JSON ForEach', () => {
+                const context = getContextAt(12, 8, foreachJsonUri);
+
+                expect(context).toBeDefined();
+                const entity = context!.entity as ForEachResource;
+                const nestedResource = entity.resource;
+
+                expect(nestedResource).toBeInstanceOf(Resource);
+                expect(nestedResource?.name).toBe('S3Bucket${BucketName}');
+                expect(nestedResource?.Type).toBe('AWS::S3::Bucket');
+                expect(nestedResource?.Properties).toBeDefined();
+                expect(nestedResource?.Properties).toHaveProperty('BucketName');
+                expect(nestedResource?.Properties?.BucketName).toHaveProperty('Fn::Sub');
+                expect(nestedResource?.Properties).toHaveProperty('VersioningConfiguration');
+                expect(nestedResource?.Properties?.VersioningConfiguration).toHaveProperty('Status', 'Enabled');
+            });
+        });
+    });
 });

tst/utils/TemplateUtils.ts

@@ -89,6 +89,20 @@ export const Templates: Record<string, Record<'json' | 'yaml', { fileName: strin
             },
         },
     },
+    foreach: {
+        json: {
+            fileName: 'file://foreach_template.json',
+            get contents() {
+                return readFileSync(join(__dirname, '..', 'resources', 'templates', 'foreach_template.json'), 'utf8');
+            },
+        },
+        yaml: {
+            fileName: 'file://foreach_template.yaml',
+            get contents() {
+                return readFileSync(join(__dirname, '..', 'resources', 'templates', 'foreach_template.yaml'), 'utf8');
+            },
+        },
+    },
 };
 
 export function point(row: number, column: number): Point {