@microsoft/terraform-cdk-constructs 0.0.3-pre.7 → 1.2.0

package/lib/azure-resourcegroup/test/resource-group.spec.js

@@ -0,0 +1,554 @@
+"use strict";
+/**
+ * Comprehensive tests for the unified ResourceGroup implementation
+ *
+ * This test suite validates the unified ResourceGroup class that replaces all
+ * version-specific implementations using the VersionedAzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * property transformation, and full backward compatibility.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const resource_group_1 = require("../lib/resource-group");
+const resource_group_schemas_1 = require("../lib/resource-group-schemas");
+describe("ResourceGroup - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Ensure Resource Group schemas are registered
+        try {
+            manager.registerResourceType(resource_group_schemas_1.RESOURCE_GROUP_TYPE, resource_group_schemas_1.ALL_RESOURCE_GROUP_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create resource group with automatic latest version resolution", () => {
+            const props = {
+                name: "test-rg",
+                location: "eastus",
+            };
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", props);
+            expect(resourceGroup).toBeInstanceOf(resource_group_1.ResourceGroup);
+            expect(resourceGroup.resolvedApiVersion).toBe("2025-03-01"); // Latest version
+            expect(resourceGroup.props).toBe(props);
+            expect(resourceGroup.name).toBe("test-rg");
+            expect(resourceGroup.location).toBe("eastus");
+        });
+        it("should create resource group with explicit version pinning", () => {
+            const props = {
+                name: "test-rg-pinned",
+                location: "westus",
+                apiVersion: "2024-11-01", // Pin to specific version
+                tags: { environment: "test" },
+            };
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", props);
+            expect(resourceGroup.resolvedApiVersion).toBe("2024-11-01");
+            expect(resourceGroup.tags).toEqual({ environment: "test" });
+        });
+        it("should create resource group with all optional properties", () => {
+            const props = {
+                name: "test-rg-full",
+                location: "centralus",
+                tags: {
+                    environment: "production",
+                    project: "cdktf-constructs",
+                    owner: "team@company.com",
+                },
+                managedBy: "/subscriptions/test-sub/resourceGroups/management-rg",
+                ignoreChanges: ["tags", "managedBy"],
+                enableValidation: true,
+                enableMigrationAnalysis: true,
+                enableTransformation: true,
+            };
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", props);
+            expect(resourceGroup.props.tags).toEqual(props.tags);
+            expect(resourceGroup.props.managedBy).toBe(props.managedBy);
+            expect(resourceGroup.props.ignoreChanges).toEqual(props.ignoreChanges);
+        });
+        it("should use default name when name is not provided", () => {
+            const props = {
+                location: "eastus",
+            };
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", props);
+            expect(resourceGroup.name).toBe("TestResourceGroup"); // Should use construct id
+        });
+        it("should require location to be provided", () => {
+            const props = {
+                name: "test-rg",
+            };
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "TestResourceGroup", props);
+            }).toThrow("Required property 'location' is missing");
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            expect(resourceGroup.resolvedApiVersion).toBe("2025-03-01");
+            expect(resourceGroup.latestVersion()).toBe("2025-03-01");
+        });
+        it("should support all registered API versions", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            const supportedVersions = resourceGroup.supportedVersions();
+            expect(supportedVersions).toContain("2024-11-01");
+            expect(supportedVersions).toContain("2025-01-01");
+            expect(supportedVersions).toContain("2025-03-01");
+        });
+        it("should validate version support", () => {
+            // Valid version
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "ValidVersion", {
+                    name: "test-rg",
+                    location: "eastus",
+                    apiVersion: "2025-01-01",
+                });
+            }).not.toThrow();
+            // Invalid version
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "InvalidVersion", {
+                    name: "test-rg",
+                    location: "eastus",
+                    apiVersion: "2026-01-01",
+                });
+            }).toThrow("Unsupported API version '2026-01-01'");
+        });
+        it("should load correct schema for resolved version", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+                apiVersion: "2024-11-01",
+            });
+            expect(resourceGroup.schema).toBeDefined();
+            expect(resourceGroup.schema.resourceType).toBe(resource_group_schemas_1.RESOURCE_GROUP_TYPE);
+            expect(resourceGroup.schema.version).toBe("2024-11-01");
+            expect(resourceGroup.schema.properties).toBeDefined();
+        });
+        it("should load version configuration correctly", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            expect(resourceGroup.versionConfig).toBeDefined();
+            expect(resourceGroup.versionConfig.version).toBe("2025-03-01");
+            expect(resourceGroup.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+    });
+    describe("Property Validation", () => {
+        it("should validate properties when validation is enabled", () => {
+            const props = {
+                name: "test-rg",
+                location: "eastus",
+                enableValidation: true,
+            };
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "TestResourceGroup", props);
+            }).not.toThrow();
+        });
+        it("should have validation results for valid properties", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "valid-name",
+                location: "eastus",
+                enableValidation: true,
+            });
+            expect(resourceGroup.validationResult).toBeDefined();
+            expect(resourceGroup.validationResult.valid).toBe(true);
+            expect(resourceGroup.validationResult.errors).toHaveLength(0);
+        });
+        it("should skip validation when disabled", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+                enableValidation: false,
+            });
+            expect(resourceGroup).toBeDefined();
+        });
+    });
+    describe("Migration Analysis", () => {
+        it("should perform migration analysis between versions", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+                apiVersion: "2024-11-01",
+            });
+            const analysis = resourceGroup.analyzeMigrationTo("2025-03-01");
+            expect(analysis).toBeDefined();
+            expect(analysis.fromVersion).toBe("2024-11-01");
+            expect(analysis.toVersion).toBe("2025-03-01");
+            expect(analysis.compatible).toBe(true); // Resource Group versions are compatible
+        });
+        it("should skip migration analysis when disabled", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+                enableMigrationAnalysis: false,
+            });
+            expect(resourceGroup.migrationAnalysis).toBeUndefined();
+        });
+    });
+    describe("Resource Creation and Body", () => {
+        it("should create correct resource body", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "westus",
+                tags: { environment: "test" },
+                managedBy: "/subscriptions/test/resourceGroups/mgmt",
+            });
+            // Test the createResourceBody method indirectly through the framework
+            expect(resourceGroup).toBeDefined();
+            expect(resourceGroup.props.tags).toEqual({ environment: "test" });
+            expect(resourceGroup.props.managedBy).toBe("/subscriptions/test/resourceGroups/mgmt");
+        });
+        it("should handle minimal resource creation", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "MinimalResourceGroup", {
+                name: "minimal-rg",
+                location: "eastus",
+            });
+            expect(resourceGroup).toBeDefined();
+            expect(resourceGroup.name).toBe("minimal-rg");
+            expect(resourceGroup.location).toBe("eastus");
+        });
+        it("should create Terraform outputs", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg-outputs",
+                location: "eastus",
+            });
+            expect(resourceGroup.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(resourceGroup.locationOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(resourceGroup.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(resourceGroup.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+    });
+    describe("Public Methods and Properties", () => {
+        let resourceGroup;
+        beforeEach(() => {
+            resourceGroup = new resource_group_1.ResourceGroup(stack, "TestResourceGroup", {
+                name: "test-rg",
+                location: "eastus",
+                tags: { environment: "test" },
+            });
+        });
+        it("should have correct id format", () => {
+            expect(resourceGroup.id).toMatch(/^\$\{.*\.id\}$/);
+        });
+        it("should have resourceId property matching id", () => {
+            expect(resourceGroup.resourceId).toBe(resourceGroup.id);
+        });
+        it("should extract subscription ID from resource ID", () => {
+            // We can't directly test this without mocking the terraform resource
+            // but we can test the error case
+            expect(() => {
+                resourceGroup.id = "invalid-id-format";
+                resourceGroup.subscriptionId;
+            }).toThrow("Unable to extract subscription ID from Resource Group ID");
+        });
+        it("should support tag management", () => {
+            // Test addTag
+            resourceGroup.addTag("newTag", "newValue");
+            expect(resourceGroup.props.tags.newTag).toBe("newValue");
+            expect(resourceGroup.props.tags.environment).toBe("test");
+            // Test removeTag
+            resourceGroup.removeTag("environment");
+            expect(resourceGroup.props.tags.environment).toBeUndefined();
+            expect(resourceGroup.props.tags.newTag).toBe("newValue");
+        });
+        it("should add tags when no tags exist", () => {
+            const rgNoTags = new resource_group_1.ResourceGroup(stack, "NoTagsRG", {
+                name: "no-tags-rg",
+                location: "eastus",
+            });
+            rgNoTags.addTag("firstTag", "firstValue");
+            expect(rgNoTags.props.tags.firstTag).toBe("firstValue");
+        });
+        it("should handle removing non-existent tags gracefully", () => {
+            expect(() => {
+                resourceGroup.removeTag("nonExistentTag");
+            }).not.toThrow();
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "IgnoreChangesRG", {
+                name: "test-rg",
+                location: "eastus",
+                ignoreChanges: ["tags", "location"],
+            });
+            expect(resourceGroup).toBeInstanceOf(resource_group_1.ResourceGroup);
+            // The ignore_changes should be applied to the underlying terraform resource
+        });
+        it("should filter out invalid ignore changes", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "FilteredIgnoreRG", {
+                name: "test-rg",
+                location: "eastus",
+                ignoreChanges: ["tags", "managedBy", "location"], // managedBy should be filtered
+            });
+            expect(resourceGroup).toBeInstanceOf(resource_group_1.ResourceGroup);
+        });
+        it("should handle empty ignore changes array", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "EmptyIgnoreRG", {
+                name: "test-rg",
+                location: "eastus",
+                ignoreChanges: [],
+            });
+            expect(resourceGroup).toBeInstanceOf(resource_group_1.ResourceGroup);
+        });
+    });
+    describe("Version Compatibility", () => {
+        it("should work with all supported API versions", () => {
+            const versions = ["2024-11-01", "2025-01-01", "2025-03-01"];
+            versions.forEach((version) => {
+                const resourceGroup = new resource_group_1.ResourceGroup(stack, `RG-${version.replace(/-/g, "")}`, {
+                    name: `test-rg-${version}`,
+                    location: "eastus",
+                    apiVersion: version,
+                });
+                expect(resourceGroup.resolvedApiVersion).toBe(version);
+                expect(resourceGroup.schema.version).toBe(version);
+            });
+        });
+        it("should handle schema differences across versions", () => {
+            // All Resource Group versions should have the same core schema
+            const versions = ["2024-11-01", "2025-01-01", "2025-03-01"];
+            versions.forEach((version) => {
+                const resourceGroup = new resource_group_1.ResourceGroup(stack, `Schema-${version.replace(/-/g, "")}`, {
+                    name: `schema-test-${version}`,
+                    location: "eastus",
+                    apiVersion: version,
+                });
+                expect(resourceGroup.schema.properties.location).toBeDefined();
+                expect(resourceGroup.schema.properties.tags).toBeDefined();
+                expect(resourceGroup.schema.properties.managedBy).toBeDefined();
+            });
+        });
+    });
+    describe("Backward Compatibility", () => {
+        it("should maintain compatibility with original GroupProps interface", () => {
+            // Test using the deprecated Group export
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { Group } = require("../lib/resource-group");
+            const group = new Group(stack, "BackwardCompatGroup", {
+                name: "compat-test",
+                location: "eastus",
+                tags: { compatibility: "test" },
+            });
+            expect(group).toBeInstanceOf(resource_group_1.ResourceGroup);
+            expect(group.name).toBe("compat-test");
+        });
+        it("should work with existing ResourceGroup patterns", () => {
+            // Test patterns that would have worked with version-specific implementations
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "ExistingPattern", {
+                name: "existing-rg",
+                location: "westus2",
+                tags: {
+                    environment: "production",
+                    cost: "center1",
+                },
+                managedBy: "/subscriptions/test-sub/resourceGroups/management",
+            });
+            expect(resourceGroup.props.tags).toEqual({
+                environment: "production",
+                cost: "center1",
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle invalid API versions gracefully", () => {
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "InvalidAPI", {
+                    name: "test-rg",
+                    location: "eastus",
+                    apiVersion: "invalid-version",
+                });
+            }).toThrow("Unsupported API version 'invalid-version'");
+        });
+        it("should handle validation errors when validation is enabled", () => {
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "ValidationError", {
+                    name: "", // Invalid empty name
+                    location: "", // Invalid empty location
+                    enableValidation: true,
+                });
+            }).toThrow("Property validation failed");
+        });
+        it("should handle schema registration errors gracefully", () => {
+            // The ResourceGroup constructor should handle already-registered schemas
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "SchemaTest", {
+                    name: "test-rg",
+                    location: "eastus",
+                });
+            }).not.toThrow();
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have JSII-compliant constructor", () => {
+            expect(() => {
+                new resource_group_1.ResourceGroup(stack, "JsiiTest", {
+                    name: "jsii-test",
+                    location: "eastus",
+                });
+            }).not.toThrow();
+        });
+        it("should have JSII-compliant properties", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "JsiiProps", {
+                name: "jsii-props",
+                location: "eastus",
+            });
+            expect(typeof resourceGroup.id).toBe("string");
+            expect(typeof resourceGroup.name).toBe("string");
+            expect(typeof resourceGroup.location).toBe("string");
+            expect(typeof resourceGroup.tags).toBe("object");
+            expect(typeof resourceGroup.resolvedApiVersion).toBe("string");
+        });
+        it("should have JSII-compliant methods", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "JsiiMethods", {
+                name: "jsii-methods",
+                location: "eastus",
+            });
+            expect(typeof resourceGroup.addTag).toBe("function");
+            expect(typeof resourceGroup.removeTag).toBe("function");
+            expect(typeof resourceGroup.latestVersion).toBe("function");
+            expect(typeof resourceGroup.supportedVersions).toBe("function");
+            expect(typeof resourceGroup.analyzeMigrationTo).toBe("function");
+        });
+        it("should serialize complex objects correctly", () => {
+            const resourceGroup = new resource_group_1.ResourceGroup(stack, "JsiiSerialization", {
+                name: "jsii-serialization",
+                location: "eastus",
+                tags: {
+                    complex: "value",
+                    nested: "data",
+                },
+            });
+            // Should be able to serialize validation results
+            expect(() => JSON.stringify(resourceGroup.validationResult)).not.toThrow();
+            // Should be able to serialize schema
+            expect(() => JSON.stringify(resourceGroup.schema)).not.toThrow();
+            // Should be able to serialize version config
+            expect(() => JSON.stringify(resourceGroup.versionConfig)).not.toThrow();
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new resource_group_1.ResourceGroup(stack, "SynthTest", {
+                name: "synth-test",
+                location: "eastus",
+                tags: { test: "synthesis" },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should work in complex CDK constructs", () => {
+            class ComplexConstruct extends cdktf.TerraformStack {
+                constructor(scope, id) {
+                    super(scope, id);
+                    // Create multiple resource groups
+                    const rg1 = new resource_group_1.ResourceGroup(this, "PrimaryRG", {
+                        name: "primary-rg",
+                        location: "eastus",
+                        tags: { tier: "primary" },
+                    });
+                    const rg2 = new resource_group_1.ResourceGroup(this, "SecondaryRG", {
+                        name: "secondary-rg",
+                        location: "westus",
+                        apiVersion: "2024-11-01",
+                        tags: { tier: "secondary" },
+                    });
+                    // Create outputs that reference the resource groups
+                    new cdktf.TerraformOutput(this, "PrimaryRGId", {
+                        value: rg1.id,
+                    });
+                    new cdktf.TerraformOutput(this, "SecondaryRGId", {
+                        value: rg2.id,
+                    });
+                }
+            }
+            expect(() => {
+                new ComplexConstruct(app, "ComplexStack");
+            }).not.toThrow();
+        });
+        it("should handle multiple resource groups in the same stack", () => {
+            const rg1 = new resource_group_1.ResourceGroup(stack, "ResourceGroup1", {
+                name: "rg-1",
+                location: "eastus",
+            });
+            const rg2 = new resource_group_1.ResourceGroup(stack, "ResourceGroup2", {
+                name: "rg-2",
+                location: "westus",
+                apiVersion: "2025-01-01",
+            });
+            expect(rg1.resolvedApiVersion).toBe("2025-03-01");
+            expect(rg2.resolvedApiVersion).toBe("2025-01-01");
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("Performance and Code Reduction", () => {
+        it("should reduce code complexity compared to version-specific implementations", () => {
+            // This test validates that the unified implementation is simpler
+            // than maintaining separate version-specific classes
+            const startTime = Date.now();
+            // Create multiple resource groups with different versions
+            const resourceGroups = [];
+            const versions = ["2024-11-01", "2025-01-01", "2025-03-01"];
+            versions.forEach((version, index) => {
+                resourceGroups.push(new resource_group_1.ResourceGroup(stack, `PerformanceTest${index}`, {
+                    name: `perf-test-${index}`,
+                    location: "eastus",
+                    apiVersion: version,
+                }));
+            });
+            const endTime = Date.now();
+            expect(resourceGroups).toHaveLength(3);
+            expect(endTime - startTime).toBeLessThan(1000); // Should be fast
+            // Verify all instances are created correctly
+            resourceGroups.forEach((rg, index) => {
+                expect(rg).toBeInstanceOf(resource_group_1.ResourceGroup);
+                expect(rg.resolvedApiVersion).toBe(versions[index]);
+            });
+        });
+        it("should validate code reduction claims", () => {
+            // This test demonstrates that a single class replaces multiple version-specific classes
+            // Previous implementation would have required:
+            // - ResourceGroup2024_11_01 class
+            // - ResourceGroup2025_01_01 class
+            // - ResourceGroup2025_03_01 class
+            // - Separate test files for each
+            // - Separate schema definitions
+            // Now we have:
+            // - Single ResourceGroup class
+            // - Single test file
+            // - Unified schema management
+            const unifiedClass = resource_group_1.ResourceGroup;
+            expect(unifiedClass).toBeDefined();
+            expect(typeof unifiedClass).toBe("function");
+            // Can handle all versions with the same interface
+            const allVersionTests = ["2024-11-01", "2025-01-01", "2025-03-01"].map((version, index) => new resource_group_1.ResourceGroup(stack, `CodeReduction${index}`, {
+                name: `code-reduction-${index}`,
+                location: "eastus",
+                apiVersion: version,
+            }));
+            expect(allVersionTests).toHaveLength(3);
+            allVersionTests.forEach((rg) => {
+                expect(rg).toBeInstanceOf(resource_group_1.ResourceGroup);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource-group.spec.js","sourceRoot":"","sources":["../../../src/azure-resourcegroup/test/resource-group.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the unified ResourceGroup implementation\n *\n * This test suite validates the unified ResourceGroup class that replaces all\n * version-specific implementations using the VersionedAzapiResource framework.\n * Tests cover automatic version resolution, explicit version pinning, schema validation,\n * property transformation, and full backward compatibility.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport { ResourceGroup, ResourceGroupProps } from \"../lib/resource-group\";\nimport {\n  ALL_RESOURCE_GROUP_VERSIONS,\n  RESOURCE_GROUP_TYPE,\n} from \"../lib/resource-group-schemas\";\n\ndescribe(\"ResourceGroup - Unified Implementation\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n  let manager: ApiVersionManager;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    // Ensure Resource Group schemas are registered\n    try {\n      manager.registerResourceType(\n        RESOURCE_GROUP_TYPE,\n        ALL_RESOURCE_GROUP_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create resource group with automatic latest version resolution\", () => {\n      const props: ResourceGroupProps = {\n        name: \"test-rg\",\n        location: \"eastus\",\n      };\n\n      const resourceGroup = new ResourceGroup(\n        stack,\n        \"TestResourceGroup\",\n        props,\n      );\n\n      expect(resourceGroup).toBeInstanceOf(ResourceGroup);\n      expect(resourceGroup.resolvedApiVersion).toBe(\"2025-03-01\"); // Latest version\n      expect(resourceGroup.props).toBe(props);\n      expect(resourceGroup.name).toBe(\"test-rg\");\n      expect(resourceGroup.location).toBe(\"eastus\");\n    });\n\n    it(\"should create resource group with explicit version pinning\", () => {\n      const props: ResourceGroupProps = {\n        name: \"test-rg-pinned\",\n        location: \"westus\",\n        apiVersion: \"2024-11-01\", // Pin to specific version\n        tags: { environment: \"test\" },\n      };\n\n      const resourceGroup = new ResourceGroup(\n        stack,\n        \"TestResourceGroup\",\n        props,\n      );\n\n      expect(resourceGroup.resolvedApiVersion).toBe(\"2024-11-01\");\n      expect(resourceGroup.tags).toEqual({ environment: \"test\" });\n    });\n\n    it(\"should create resource group with all optional properties\", () => {\n      const props: ResourceGroupProps = {\n        name: \"test-rg-full\",\n        location: \"centralus\",\n        tags: {\n          environment: \"production\",\n          project: \"cdktf-constructs\",\n          owner: \"team@company.com\",\n        },\n        managedBy: \"/subscriptions/test-sub/resourceGroups/management-rg\",\n        ignoreChanges: [\"tags\", \"managedBy\"],\n        enableValidation: true,\n        enableMigrationAnalysis: true,\n        enableTransformation: true,\n      };\n\n      const resourceGroup = new ResourceGroup(\n        stack,\n        \"TestResourceGroup\",\n        props,\n      );\n\n      expect(resourceGroup.props.tags).toEqual(props.tags);\n      expect(resourceGroup.props.managedBy).toBe(props.managedBy);\n      expect(resourceGroup.props.ignoreChanges).toEqual(props.ignoreChanges);\n    });\n\n    it(\"should use default name when name is not provided\", () => {\n      const props: ResourceGroupProps = {\n        location: \"eastus\",\n      };\n\n      const resourceGroup = new ResourceGroup(\n        stack,\n        \"TestResourceGroup\",\n        props,\n      );\n\n      expect(resourceGroup.name).toBe(\"TestResourceGroup\"); // Should use construct id\n    });\n\n    it(\"should require location to be provided\", () => {\n      const props: ResourceGroupProps = {\n        name: \"test-rg\",\n      };\n\n      expect(() => {\n        new ResourceGroup(stack, \"TestResourceGroup\", props);\n      }).toThrow(\"Required property 'location' is missing\");\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      expect(resourceGroup.resolvedApiVersion).toBe(\"2025-03-01\");\n      expect(resourceGroup.latestVersion()).toBe(\"2025-03-01\");\n    });\n\n    it(\"should support all registered API versions\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      const supportedVersions = resourceGroup.supportedVersions();\n      expect(supportedVersions).toContain(\"2024-11-01\");\n      expect(supportedVersions).toContain(\"2025-01-01\");\n      expect(supportedVersions).toContain(\"2025-03-01\");\n    });\n\n    it(\"should validate version support\", () => {\n      // Valid version\n      expect(() => {\n        new ResourceGroup(stack, \"ValidVersion\", {\n          name: \"test-rg\",\n          location: \"eastus\",\n          apiVersion: \"2025-01-01\",\n        });\n      }).not.toThrow();\n\n      // Invalid version\n      expect(() => {\n        new ResourceGroup(stack, \"InvalidVersion\", {\n          name: \"test-rg\",\n          location: \"eastus\",\n          apiVersion: \"2026-01-01\",\n        });\n      }).toThrow(\"Unsupported API version '2026-01-01'\");\n    });\n\n    it(\"should load correct schema for resolved version\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        apiVersion: \"2024-11-01\",\n      });\n\n      expect(resourceGroup.schema).toBeDefined();\n      expect(resourceGroup.schema.resourceType).toBe(RESOURCE_GROUP_TYPE);\n      expect(resourceGroup.schema.version).toBe(\"2024-11-01\");\n      expect(resourceGroup.schema.properties).toBeDefined();\n    });\n\n    it(\"should load version configuration correctly\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      expect(resourceGroup.versionConfig).toBeDefined();\n      expect(resourceGroup.versionConfig.version).toBe(\"2025-03-01\");\n      expect(resourceGroup.versionConfig.supportLevel).toBe(\n        VersionSupportLevel.ACTIVE,\n      );\n    });\n  });\n\n  describe(\"Property Validation\", () => {\n    it(\"should validate properties when validation is enabled\", () => {\n      const props: ResourceGroupProps = {\n        name: \"test-rg\",\n        location: \"eastus\",\n        enableValidation: true,\n      };\n\n      expect(() => {\n        new ResourceGroup(stack, \"TestResourceGroup\", props);\n      }).not.toThrow();\n    });\n\n    it(\"should have validation results for valid properties\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"valid-name\",\n        location: \"eastus\",\n        enableValidation: true,\n      });\n\n      expect(resourceGroup.validationResult).toBeDefined();\n      expect(resourceGroup.validationResult!.valid).toBe(true);\n      expect(resourceGroup.validationResult!.errors).toHaveLength(0);\n    });\n\n    it(\"should skip validation when disabled\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        enableValidation: false,\n      });\n\n      expect(resourceGroup).toBeDefined();\n    });\n  });\n\n  describe(\"Migration Analysis\", () => {\n    it(\"should perform migration analysis between versions\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        apiVersion: \"2024-11-01\",\n      });\n\n      const analysis = resourceGroup.analyzeMigrationTo(\"2025-03-01\");\n\n      expect(analysis).toBeDefined();\n      expect(analysis.fromVersion).toBe(\"2024-11-01\");\n      expect(analysis.toVersion).toBe(\"2025-03-01\");\n      expect(analysis.compatible).toBe(true); // Resource Group versions are compatible\n    });\n\n    it(\"should skip migration analysis when disabled\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        enableMigrationAnalysis: false,\n      });\n\n      expect(resourceGroup.migrationAnalysis).toBeUndefined();\n    });\n  });\n\n  describe(\"Resource Creation and Body\", () => {\n    it(\"should create correct resource body\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"westus\",\n        tags: { environment: \"test\" },\n        managedBy: \"/subscriptions/test/resourceGroups/mgmt\",\n      });\n\n      // Test the createResourceBody method indirectly through the framework\n      expect(resourceGroup).toBeDefined();\n      expect(resourceGroup.props.tags).toEqual({ environment: \"test\" });\n      expect(resourceGroup.props.managedBy).toBe(\n        \"/subscriptions/test/resourceGroups/mgmt\",\n      );\n    });\n\n    it(\"should handle minimal resource creation\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"MinimalResourceGroup\", {\n        name: \"minimal-rg\",\n        location: \"eastus\",\n      });\n\n      expect(resourceGroup).toBeDefined();\n      expect(resourceGroup.name).toBe(\"minimal-rg\");\n      expect(resourceGroup.location).toBe(\"eastus\");\n    });\n\n    it(\"should create Terraform outputs\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg-outputs\",\n        location: \"eastus\",\n      });\n\n      expect(resourceGroup.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(resourceGroup.locationOutput).toBeInstanceOf(\n        cdktf.TerraformOutput,\n      );\n      expect(resourceGroup.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(resourceGroup.tagsOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n  });\n\n  describe(\"Public Methods and Properties\", () => {\n    let resourceGroup: ResourceGroup;\n\n    beforeEach(() => {\n      resourceGroup = new ResourceGroup(stack, \"TestResourceGroup\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { environment: \"test\" },\n      });\n    });\n\n    it(\"should have correct id format\", () => {\n      expect(resourceGroup.id).toMatch(/^\\$\\{.*\\.id\\}$/);\n    });\n\n    it(\"should have resourceId property matching id\", () => {\n      expect(resourceGroup.resourceId).toBe(resourceGroup.id);\n    });\n\n    it(\"should extract subscription ID from resource ID\", () => {\n      // We can't directly test this without mocking the terraform resource\n      // but we can test the error case\n      expect(() => {\n        (resourceGroup as any).id = \"invalid-id-format\";\n        resourceGroup.subscriptionId;\n      }).toThrow(\"Unable to extract subscription ID from Resource Group ID\");\n    });\n\n    it(\"should support tag management\", () => {\n      // Test addTag\n      resourceGroup.addTag(\"newTag\", \"newValue\");\n      expect(resourceGroup.props.tags!.newTag).toBe(\"newValue\");\n      expect(resourceGroup.props.tags!.environment).toBe(\"test\");\n\n      // Test removeTag\n      resourceGroup.removeTag(\"environment\");\n      expect(resourceGroup.props.tags!.environment).toBeUndefined();\n      expect(resourceGroup.props.tags!.newTag).toBe(\"newValue\");\n    });\n\n    it(\"should add tags when no tags exist\", () => {\n      const rgNoTags = new ResourceGroup(stack, \"NoTagsRG\", {\n        name: \"no-tags-rg\",\n        location: \"eastus\",\n      });\n\n      rgNoTags.addTag(\"firstTag\", \"firstValue\");\n      expect(rgNoTags.props.tags!.firstTag).toBe(\"firstValue\");\n    });\n\n    it(\"should handle removing non-existent tags gracefully\", () => {\n      expect(() => {\n        resourceGroup.removeTag(\"nonExistentTag\");\n      }).not.toThrow();\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"IgnoreChangesRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        ignoreChanges: [\"tags\", \"location\"],\n      });\n\n      expect(resourceGroup).toBeInstanceOf(ResourceGroup);\n      // The ignore_changes should be applied to the underlying terraform resource\n    });\n\n    it(\"should filter out invalid ignore changes\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"FilteredIgnoreRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        ignoreChanges: [\"tags\", \"managedBy\", \"location\"], // managedBy should be filtered\n      });\n\n      expect(resourceGroup).toBeInstanceOf(ResourceGroup);\n    });\n\n    it(\"should handle empty ignore changes array\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"EmptyIgnoreRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        ignoreChanges: [],\n      });\n\n      expect(resourceGroup).toBeInstanceOf(ResourceGroup);\n    });\n  });\n\n  describe(\"Version Compatibility\", () => {\n    it(\"should work with all supported API versions\", () => {\n      const versions = [\"2024-11-01\", \"2025-01-01\", \"2025-03-01\"];\n\n      versions.forEach((version) => {\n        const resourceGroup = new ResourceGroup(\n          stack,\n          `RG-${version.replace(/-/g, \"\")}`,\n          {\n            name: `test-rg-${version}`,\n            location: \"eastus\",\n            apiVersion: version,\n          },\n        );\n\n        expect(resourceGroup.resolvedApiVersion).toBe(version);\n        expect(resourceGroup.schema.version).toBe(version);\n      });\n    });\n\n    it(\"should handle schema differences across versions\", () => {\n      // All Resource Group versions should have the same core schema\n      const versions = [\"2024-11-01\", \"2025-01-01\", \"2025-03-01\"];\n\n      versions.forEach((version) => {\n        const resourceGroup = new ResourceGroup(\n          stack,\n          `Schema-${version.replace(/-/g, \"\")}`,\n          {\n            name: `schema-test-${version}`,\n            location: \"eastus\",\n            apiVersion: version,\n          },\n        );\n\n        expect(resourceGroup.schema.properties.location).toBeDefined();\n        expect(resourceGroup.schema.properties.tags).toBeDefined();\n        expect(resourceGroup.schema.properties.managedBy).toBeDefined();\n      });\n    });\n  });\n\n  describe(\"Backward Compatibility\", () => {\n    it(\"should maintain compatibility with original GroupProps interface\", () => {\n      // Test using the deprecated Group export\n      // eslint-disable-next-line @typescript-eslint/no-require-imports\n      const { Group } = require(\"../lib/resource-group\");\n\n      const group = new Group(stack, \"BackwardCompatGroup\", {\n        name: \"compat-test\",\n        location: \"eastus\",\n        tags: { compatibility: \"test\" },\n      });\n\n      expect(group).toBeInstanceOf(ResourceGroup);\n      expect(group.name).toBe(\"compat-test\");\n    });\n\n    it(\"should work with existing ResourceGroup patterns\", () => {\n      // Test patterns that would have worked with version-specific implementations\n      const resourceGroup = new ResourceGroup(stack, \"ExistingPattern\", {\n        name: \"existing-rg\",\n        location: \"westus2\",\n        tags: {\n          environment: \"production\",\n          cost: \"center1\",\n        },\n        managedBy: \"/subscriptions/test-sub/resourceGroups/management\",\n      });\n\n      expect(resourceGroup.props.tags).toEqual({\n        environment: \"production\",\n        cost: \"center1\",\n      });\n    });\n  });\n\n  describe(\"Error Handling\", () => {\n    it(\"should handle invalid API versions gracefully\", () => {\n      expect(() => {\n        new ResourceGroup(stack, \"InvalidAPI\", {\n          name: \"test-rg\",\n          location: \"eastus\",\n          apiVersion: \"invalid-version\",\n        });\n      }).toThrow(\"Unsupported API version 'invalid-version'\");\n    });\n\n    it(\"should handle validation errors when validation is enabled\", () => {\n      expect(() => {\n        new ResourceGroup(stack, \"ValidationError\", {\n          name: \"\", // Invalid empty name\n          location: \"\", // Invalid empty location\n          enableValidation: true,\n        });\n      }).toThrow(\"Property validation failed\");\n    });\n\n    it(\"should handle schema registration errors gracefully\", () => {\n      // The ResourceGroup constructor should handle already-registered schemas\n      expect(() => {\n        new ResourceGroup(stack, \"SchemaTest\", {\n          name: \"test-rg\",\n          location: \"eastus\",\n        });\n      }).not.toThrow();\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have JSII-compliant constructor\", () => {\n      expect(() => {\n        new ResourceGroup(stack, \"JsiiTest\", {\n          name: \"jsii-test\",\n          location: \"eastus\",\n        });\n      }).not.toThrow();\n    });\n\n    it(\"should have JSII-compliant properties\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"JsiiProps\", {\n        name: \"jsii-props\",\n        location: \"eastus\",\n      });\n\n      expect(typeof resourceGroup.id).toBe(\"string\");\n      expect(typeof resourceGroup.name).toBe(\"string\");\n      expect(typeof resourceGroup.location).toBe(\"string\");\n      expect(typeof resourceGroup.tags).toBe(\"object\");\n      expect(typeof resourceGroup.resolvedApiVersion).toBe(\"string\");\n    });\n\n    it(\"should have JSII-compliant methods\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"JsiiMethods\", {\n        name: \"jsii-methods\",\n        location: \"eastus\",\n      });\n\n      expect(typeof resourceGroup.addTag).toBe(\"function\");\n      expect(typeof resourceGroup.removeTag).toBe(\"function\");\n      expect(typeof resourceGroup.latestVersion).toBe(\"function\");\n      expect(typeof resourceGroup.supportedVersions).toBe(\"function\");\n      expect(typeof resourceGroup.analyzeMigrationTo).toBe(\"function\");\n    });\n\n    it(\"should serialize complex objects correctly\", () => {\n      const resourceGroup = new ResourceGroup(stack, \"JsiiSerialization\", {\n        name: \"jsii-serialization\",\n        location: \"eastus\",\n        tags: {\n          complex: \"value\",\n          nested: \"data\",\n        },\n      });\n\n      // Should be able to serialize validation results\n      expect(() =>\n        JSON.stringify(resourceGroup.validationResult),\n      ).not.toThrow();\n\n      // Should be able to serialize schema\n      expect(() => JSON.stringify(resourceGroup.schema)).not.toThrow();\n\n      // Should be able to serialize version config\n      expect(() => JSON.stringify(resourceGroup.versionConfig)).not.toThrow();\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new ResourceGroup(stack, \"SynthTest\", {\n        name: \"synth-test\",\n        location: \"eastus\",\n        tags: { test: \"synthesis\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n    });\n\n    it(\"should work in complex CDK constructs\", () => {\n      class ComplexConstruct extends cdktf.TerraformStack {\n        constructor(scope: cdktf.App, id: string) {\n          super(scope, id);\n\n          // Create multiple resource groups\n          const rg1 = new ResourceGroup(this, \"PrimaryRG\", {\n            name: \"primary-rg\",\n            location: \"eastus\",\n            tags: { tier: \"primary\" },\n          });\n\n          const rg2 = new ResourceGroup(this, \"SecondaryRG\", {\n            name: \"secondary-rg\",\n            location: \"westus\",\n            apiVersion: \"2024-11-01\",\n            tags: { tier: \"secondary\" },\n          });\n\n          // Create outputs that reference the resource groups\n          new cdktf.TerraformOutput(this, \"PrimaryRGId\", {\n            value: rg1.id,\n          });\n\n          new cdktf.TerraformOutput(this, \"SecondaryRGId\", {\n            value: rg2.id,\n          });\n        }\n      }\n\n      expect(() => {\n        new ComplexConstruct(app, \"ComplexStack\");\n      }).not.toThrow();\n    });\n\n    it(\"should handle multiple resource groups in the same stack\", () => {\n      const rg1 = new ResourceGroup(stack, \"ResourceGroup1\", {\n        name: \"rg-1\",\n        location: \"eastus\",\n      });\n\n      const rg2 = new ResourceGroup(stack, \"ResourceGroup2\", {\n        name: \"rg-2\",\n        location: \"westus\",\n        apiVersion: \"2025-01-01\",\n      });\n\n      expect(rg1.resolvedApiVersion).toBe(\"2025-03-01\");\n      expect(rg2.resolvedApiVersion).toBe(\"2025-01-01\");\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"Performance and Code Reduction\", () => {\n    it(\"should reduce code complexity compared to version-specific implementations\", () => {\n      // This test validates that the unified implementation is simpler\n      // than maintaining separate version-specific classes\n\n      const startTime = Date.now();\n\n      // Create multiple resource groups with different versions\n      const resourceGroups: ResourceGroup[] = [];\n      const versions = [\"2024-11-01\", \"2025-01-01\", \"2025-03-01\"];\n\n      versions.forEach((version, index) => {\n        resourceGroups.push(\n          new ResourceGroup(stack, `PerformanceTest${index}`, {\n            name: `perf-test-${index}`,\n            location: \"eastus\",\n            apiVersion: version,\n          }),\n        );\n      });\n\n      const endTime = Date.now();\n\n      expect(resourceGroups).toHaveLength(3);\n      expect(endTime - startTime).toBeLessThan(1000); // Should be fast\n\n      // Verify all instances are created correctly\n      resourceGroups.forEach((rg, index) => {\n        expect(rg).toBeInstanceOf(ResourceGroup);\n        expect(rg.resolvedApiVersion).toBe(versions[index]);\n      });\n    });\n\n    it(\"should validate code reduction claims\", () => {\n      // This test demonstrates that a single class replaces multiple version-specific classes\n      // Previous implementation would have required:\n      // - ResourceGroup2024_11_01 class\n      // - ResourceGroup2025_01_01 class\n      // - ResourceGroup2025_03_01 class\n      // - Separate test files for each\n      // - Separate schema definitions\n\n      // Now we have:\n      // - Single ResourceGroup class\n      // - Single test file\n      // - Unified schema management\n\n      const unifiedClass = ResourceGroup;\n      expect(unifiedClass).toBeDefined();\n      expect(typeof unifiedClass).toBe(\"function\");\n\n      // Can handle all versions with the same interface\n      const allVersionTests = [\"2024-11-01\", \"2025-01-01\", \"2025-03-01\"].map(\n        (version, index) =>\n          new ResourceGroup(stack, `CodeReduction${index}`, {\n            name: `code-reduction-${index}`,\n            location: \"eastus\",\n            apiVersion: version,\n          }),\n      );\n\n      expect(allVersionTests).toHaveLength(3);\n      allVersionTests.forEach((rg) => {\n        expect(rg).toBeInstanceOf(ResourceGroup);\n      });\n    });\n  });\n});\n"]}