@microsoft/terraform-cdk-constructs 0.0.3-pre.6 → 1.0.0

package/lib/core-azure/lib/azapi/azapi-resource.spec.js

@@ -0,0 +1,545 @@
+"use strict";
+/**
+ * Comprehensive tests for AzapiResource - Base class for version-aware Azure resources
+ *
+ * This test suite validates the core functionality of the AzapiResource framework,
+ * including version resolution, schema validation, property transformation, and resource creation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const constructs_1 = require("constructs");
+const azapi_resource_1 = require("./azapi-resource");
+const api_version_manager_1 = require("../version-manager/api-version-manager");
+const version_interfaces_1 = require("../version-manager/interfaces/version-interfaces");
+// Test implementation of AzapiResource
+class TestVersionedResource extends azapi_resource_1.AzapiResource {
+    get id() {
+        return `\${${this.terraformResource.fqn}.id}`;
+    }
+    defaultVersion() {
+        return "2024-01-01";
+    }
+    resourceType() {
+        return "Microsoft.Test/resources";
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    createResourceBody(props) {
+        return {
+            name: props.name || "default-name",
+            location: props.location || "eastus",
+            tags: props.tags || {},
+        };
+    }
+}
+describe("AzapiResource", () => {
+    let app;
+    let stack;
+    let manager;
+    // Test data setup
+    const TEST_RESOURCE_TYPE = "Microsoft.Test/resources";
+    const createTestSchema = (version, properties = {}) => ({
+        resourceType: TEST_RESOURCE_TYPE,
+        version,
+        properties: {
+            name: {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: true,
+                description: "Resource name",
+                validation: [
+                    {
+                        ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                        message: "Name is required",
+                    },
+                ],
+            },
+            location: {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: true,
+                description: "Resource location",
+                validation: [
+                    {
+                        ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                        message: "Location is required",
+                    },
+                ],
+            },
+            tags: {
+                dataType: version_interfaces_1.PropertyType.OBJECT,
+                required: false,
+                defaultValue: {},
+                description: "Resource tags",
+            },
+            ...properties,
+        },
+        required: ["name", "location"],
+        optional: ["tags"],
+        deprecated: [],
+        transformationRules: {},
+        validationRules: [],
+    });
+    const createTestVersionConfig = (version, supportLevel = version_interfaces_1.VersionSupportLevel.ACTIVE) => ({
+        version,
+        schema: createTestSchema(version),
+        supportLevel,
+        releaseDate: version,
+        deprecationDate: undefined,
+        sunsetDate: undefined,
+        breakingChanges: [],
+        migrationGuide: `/docs/migration-${version}`,
+        changeLog: [
+            {
+                changeType: "added",
+                description: `Initial release of version ${version}`,
+                breaking: false,
+            },
+        ],
+    });
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Register test versions
+        const versions = [
+            createTestVersionConfig("2024-01-01", version_interfaces_1.VersionSupportLevel.DEPRECATED),
+            createTestVersionConfig("2024-06-01", version_interfaces_1.VersionSupportLevel.ACTIVE),
+            createTestVersionConfig("2024-12-01", version_interfaces_1.VersionSupportLevel.ACTIVE),
+        ];
+        try {
+            manager.registerResourceType(TEST_RESOURCE_TYPE, versions);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Initialization", () => {
+        it("should create resource with automatic version resolution", () => {
+            const props = {
+                name: "test-resource",
+                location: "eastus",
+            };
+            const resource = new TestVersionedResource(stack, "TestResource", props);
+            expect(resource).toBeInstanceOf(TestVersionedResource);
+            expect(resource).toBeInstanceOf(azapi_resource_1.AzapiResource);
+            expect(resource.resolvedApiVersion).toBe("2024-12-01"); // Latest active version
+        });
+        it("should create resource with explicit version pinning", () => {
+            const props = {
+                name: "test-resource",
+                location: "eastus",
+                apiVersion: "2024-06-01",
+            };
+            const resource = new TestVersionedResource(stack, "TestResource", props);
+            expect(resource.resolvedApiVersion).toBe("2024-06-01");
+        });
+        it("should throw error when version is not registered", () => {
+            // Test with a resource type that's not registered
+            class UnregisteredResource extends azapi_resource_1.AzapiResource {
+                get id() {
+                    return `\${${this.terraformResource.fqn}.id}`;
+                }
+                defaultVersion() {
+                    return "2023-01-01";
+                }
+                resourceType() {
+                    return "Microsoft.Unregistered/resources";
+                }
+                apiSchema() {
+                    return createTestSchema("2023-01-01");
+                }
+                createResourceBody(props) {
+                    return { name: props.name };
+                }
+            }
+            expect(() => {
+                new UnregisteredResource(stack, "UnregisteredResource", {
+                    name: "test",
+                    location: "eastus",
+                });
+            }).toThrow("Version configuration not found for Microsoft.Unregistered/resources@2023-01-01");
+        });
+        it("should validate explicit version support", () => {
+            const props = {
+                name: "test-resource",
+                location: "eastus",
+                apiVersion: "2025-01-01", // Unsupported version
+            };
+            expect(() => {
+                new TestVersionedResource(stack, "TestResource", props);
+            }).toThrow("Unsupported API version '2025-01-01'");
+        });
+        it("should throw error when version configuration is missing", () => {
+            // Create a version that's registered but has no config (edge case)
+            class InvalidConfigResource extends TestVersionedResource {
+                apiSchema() {
+                    // This would normally fail when trying to resolve schema
+                    return createTestSchema("invalid-version");
+                }
+            }
+            expect(() => {
+                new InvalidConfigResource(stack, "InvalidResource", {
+                    name: "test",
+                    location: "eastus",
+                    apiVersion: "invalid-version",
+                });
+            }).toThrow("Unsupported API version 'invalid-version'");
+        });
+    });
+    describe("Schema Resolution and Validation", () => {
+        it("should resolve schema correctly", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+            });
+            expect(resource.schema).toBeDefined();
+            expect(resource.schema.resourceType).toBe(TEST_RESOURCE_TYPE);
+            expect(resource.schema.version).toBe("2024-12-01");
+        });
+        it("should load version configuration", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+            });
+            expect(resource.versionConfig).toBeDefined();
+            expect(resource.versionConfig.version).toBe("2024-12-01");
+            expect(resource.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+        it("should validate properties when validation is enabled", () => {
+            const props = {
+                // Missing required properties to trigger validation error
+                enableValidation: true,
+            };
+            expect(() => {
+                new TestVersionedResource(stack, "TestResource", props);
+            }).toThrow("Property validation failed");
+        });
+        it("should skip validation when disabled", () => {
+            const props = {
+                // Missing required properties but validation disabled
+                enableValidation: false,
+            };
+            expect(() => {
+                new TestVersionedResource(stack, "TestResource", props);
+            }).not.toThrow();
+        });
+        it("should have validation results when validation passes", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                enableValidation: true,
+            });
+            expect(resource.validationResult).toBeDefined();
+            expect(resource.validationResult.valid).toBe(true);
+        });
+    });
+    describe("Property Processing and Transformation", () => {
+        it("should apply default values", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                // tags not provided, should get default value
+            });
+            expect(resource).toBeDefined();
+            // The resource should have been created with default tags applied
+        });
+        it("should handle transformation when enabled", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                enableTransformation: true,
+            });
+            expect(resource).toBeDefined();
+        });
+        it("should skip transformation when disabled", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                enableTransformation: false,
+            });
+            expect(resource).toBeDefined();
+        });
+    });
+    describe("Migration Analysis", () => {
+        it("should perform migration analysis when enabled", () => {
+            // Use deprecated version to trigger migration analysis
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                apiVersion: "2024-01-01", // Deprecated version
+                enableMigrationAnalysis: true,
+            });
+            expect(resource.migrationAnalysis).toBeDefined();
+            expect(resource.migrationAnalysis.fromVersion).toBe("2024-01-01");
+            expect(resource.migrationAnalysis.toVersion).toBe("2024-12-01");
+        });
+        it("should skip migration analysis when disabled", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                apiVersion: "2024-01-01",
+                enableMigrationAnalysis: false,
+            });
+            expect(resource.migrationAnalysis).toBeUndefined();
+        });
+        it("should not perform migration analysis for active versions", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                apiVersion: "2024-12-01", // Active version
+                enableMigrationAnalysis: true,
+            });
+            expect(resource.migrationAnalysis).toBeUndefined();
+        });
+    });
+    describe("Version Management Methods", () => {
+        let resource;
+        beforeEach(() => {
+            resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+            });
+        });
+        it("should get latest version", () => {
+            const latest = resource.latestVersion();
+            expect(latest).toBe("2024-12-01");
+        });
+        it("should get supported versions", () => {
+            const versions = resource.supportedVersions();
+            expect(versions).toEqual(["2024-12-01", "2024-06-01", "2024-01-01"]);
+        });
+        it("should analyze migration to target version", () => {
+            const analysis = resource.analyzeMigrationTo("2024-06-01");
+            expect(analysis).toBeDefined();
+            expect(analysis.fromVersion).toBe("2024-12-01");
+            expect(analysis.toVersion).toBe("2024-06-01");
+        });
+    });
+    describe("Resource Creation", () => {
+        it("should create Azure resource with correct body", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "westus",
+                tags: { environment: "test" },
+            });
+            expect(resource).toBeDefined();
+            // The underlying AZAPI resource should be created but we can't access it directly
+        });
+        it("should handle resource creation with minimal properties", () => {
+            const resource = new TestVersionedResource(stack, "TestResource", {
+                name: "minimal-resource",
+                location: "eastus",
+            });
+            expect(resource).toBeDefined();
+        });
+    });
+    describe("Logging and Warning Messages", () => {
+        it("should log deprecation warnings", () => {
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+            new TestVersionedResource(stack, "TestResource", {
+                name: "test-resource",
+                location: "eastus",
+                apiVersion: "2024-01-01", // Deprecated version
+            });
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("API version 2024-01-01 for Microsoft.Test/resources is deprecated"));
+            warnSpy.mockRestore();
+        });
+        it("should log validation warnings", () => {
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+            // Use the existing TestVersionedResource with unknown property to trigger validation warning
+            new TestVersionedResource(stack, "ValidationWarningTest", {
+                name: "test",
+                location: "eastus",
+                unknownProperty: "value", // This should trigger a validation warning
+            });
+            // Should have logged validation warnings about unknown property
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("Property validation warning"));
+            warnSpy.mockRestore();
+        });
+        it("should log migration analysis warnings", () => {
+            const warnSpy = jest.spyOn(console, "warn").mockImplementation();
+            // Use deprecated version to trigger migration analysis
+            new TestVersionedResource(stack, "MigrationWarningTest", {
+                name: "test",
+                location: "eastus",
+                apiVersion: "2024-01-01", // This is a deprecated version
+                enableMigrationAnalysis: true,
+            });
+            // Check for deprecation warning (which is logged)
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("API version 2024-01-01 for Microsoft.Test/resources is deprecated"));
+            warnSpy.mockRestore();
+        });
+    });
+    describe("Abstract Method Implementation", () => {
+        it("should require implementation of abstract methods", () => {
+            // Test that abstract methods must be implemented
+            // This test validates that TypeScript will catch missing implementations at compile time
+            // We can't actually test runtime behavior for abstract classes
+            expect(true).toBe(true); // Placeholder test since TS compilation errors are caught at build time
+        });
+        it("should use resolveSchema helper correctly", () => {
+            class ResourceUsingHelper extends azapi_resource_1.AzapiResource {
+                get id() {
+                    return `\${${this.terraformResource.fqn}.id}`;
+                }
+                defaultVersion() {
+                    return "2024-01-01";
+                }
+                resourceType() {
+                    return TEST_RESOURCE_TYPE;
+                }
+                apiSchema() {
+                    return this.resolveSchema();
+                }
+                createResourceBody(props) {
+                    return { name: props.name };
+                }
+            }
+            const resource = new ResourceUsingHelper(stack, "HelperResource", {
+                name: "test",
+                location: "eastus",
+            });
+            expect(resource.schema).toBeDefined();
+            expect(resource.schema.resourceType).toBe(TEST_RESOURCE_TYPE);
+        });
+        it("should handle schema resolution errors", () => {
+            class BadSchemaResource extends azapi_resource_1.AzapiResource {
+                get id() {
+                    return `\${${this.terraformResource.fqn}.id}`;
+                }
+                defaultVersion() {
+                    return "2024-01-01";
+                }
+                resourceType() {
+                    return "Invalid.Type/resource";
+                }
+                apiSchema() {
+                    return this.resolveSchema();
+                }
+                createResourceBody(props) {
+                    return { name: props.name };
+                }
+            }
+            expect(() => {
+                new BadSchemaResource(stack, "BadResource", {
+                    name: "test",
+                    location: "eastus",
+                });
+            }).toThrow("Cannot resolve schema");
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle validation errors gracefully", () => {
+            const props = {
+                name: "", // Invalid name
+                location: "", // Invalid location
+                enableValidation: true,
+            };
+            expect(() => {
+                new TestVersionedResource(stack, "TestResource", props);
+            }).toThrow("Property validation failed");
+        });
+        it("should handle transformation errors", () => {
+            // Create a resource that might have transformation issues
+            class ProblematicResource extends TestVersionedResource {
+                createResourceBody(props) {
+                    // Simulate an error in resource body creation
+                    if (props.causeError) {
+                        throw new Error("Resource body creation failed");
+                    }
+                    return super.createResourceBody(props);
+                }
+            }
+            expect(() => {
+                new ProblematicResource(stack, "ProblematicResource", {
+                    name: "test",
+                    location: "eastus",
+                    causeError: true,
+                });
+            }).toThrow();
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have JSII-compliant constructor", () => {
+            expect(() => {
+                new TestVersionedResource(stack, "JsiiTest", {
+                    name: "test",
+                    location: "eastus",
+                });
+            }).not.toThrow();
+        });
+        it("should have JSII-compliant public methods", () => {
+            const resource = new TestVersionedResource(stack, "JsiiTest", {
+                name: "test",
+                location: "eastus",
+            });
+            expect(typeof resource.latestVersion).toBe("function");
+            expect(typeof resource.supportedVersions).toBe("function");
+            expect(typeof resource.analyzeMigrationTo).toBe("function");
+        });
+        it("should have JSII-compliant public properties", () => {
+            const resource = new TestVersionedResource(stack, "JsiiTest", {
+                name: "test",
+                location: "eastus",
+            });
+            expect(typeof resource.resolvedApiVersion).toBe("string");
+            expect(typeof resource.schema).toBe("object");
+            expect(typeof resource.versionConfig).toBe("object");
+        });
+        it("should handle JSII serialization of complex objects", () => {
+            const resource = new TestVersionedResource(stack, "JsiiTest", {
+                name: "test",
+                location: "eastus",
+                tags: {
+                    environment: "test",
+                    project: "unit-tests",
+                },
+            });
+            // Should be able to serialize the validation result
+            expect(() => JSON.stringify(resource.validationResult)).not.toThrow();
+            // Should be able to serialize the schema
+            expect(() => JSON.stringify(resource.schema)).not.toThrow();
+        });
+    });
+    describe("Integration with CDK Terraform", () => {
+        it("should synthesize correctly", () => {
+            new TestVersionedResource(stack, "SynthTest", {
+                name: "test-resource",
+                location: "eastus",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should work within CDK constructs", () => {
+            class CompositeConstruct extends constructs_1.Construct {
+                constructor(scope, id) {
+                    super(scope, id);
+                    new TestVersionedResource(this, "NestedResource", {
+                        name: "nested-resource",
+                        location: "westus",
+                    });
+                }
+            }
+            expect(() => {
+                new CompositeConstruct(stack, "CompositeTest");
+            }).not.toThrow();
+        });
+        it("should handle multiple resources in the same stack", () => {
+            new TestVersionedResource(stack, "Resource1", {
+                name: "resource-1",
+                location: "eastus",
+            });
+            new TestVersionedResource(stack, "Resource2", {
+                name: "resource-2",
+                location: "westus",
+                apiVersion: "2024-06-01",
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"azapi-resource.spec.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/azapi/azapi-resource.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for AzapiResource - Base class for version-aware Azure resources\n *\n * This test suite validates the core functionality of the AzapiResource framework,\n * including version resolution, schema validation, property transformation, and resource creation.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AzapiResource, AzapiResourceProps } from \"./azapi-resource\";\nimport { ApiVersionManager } from \"../version-manager/api-version-manager\";\nimport {\n  ApiSchema,\n  VersionConfig,\n  PropertyDefinition,\n  PropertyType,\n  ValidationRuleType,\n  VersionSupportLevel,\n} from \"../version-manager/interfaces/version-interfaces\";\n\n// Test implementation of AzapiResource\nclass TestVersionedResource extends AzapiResource {\n  public get id(): string {\n    return `\\${${this.terraformResource.fqn}.id}`;\n  }\n\n  protected defaultVersion(): string {\n    return \"2024-01-01\";\n  }\n\n  protected resourceType(): string {\n    return \"Microsoft.Test/resources\";\n  }\n\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  protected createResourceBody(props: any): any {\n    return {\n      name: props.name || \"default-name\",\n      location: props.location || \"eastus\",\n      tags: props.tags || {},\n    };\n  }\n}\n\ndescribe(\"AzapiResource\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n  let manager: ApiVersionManager;\n\n  // Test data setup\n  const TEST_RESOURCE_TYPE = \"Microsoft.Test/resources\";\n\n  const createTestSchema = (\n    version: string,\n    properties: { [key: string]: PropertyDefinition } = {},\n  ): ApiSchema => ({\n    resourceType: TEST_RESOURCE_TYPE,\n    version,\n    properties: {\n      name: {\n        dataType: PropertyType.STRING,\n        required: true,\n        description: \"Resource name\",\n        validation: [\n          {\n            ruleType: ValidationRuleType.REQUIRED,\n            message: \"Name is required\",\n          },\n        ],\n      },\n      location: {\n        dataType: PropertyType.STRING,\n        required: true,\n        description: \"Resource location\",\n        validation: [\n          {\n            ruleType: ValidationRuleType.REQUIRED,\n            message: \"Location is required\",\n          },\n        ],\n      },\n      tags: {\n        dataType: PropertyType.OBJECT,\n        required: false,\n        defaultValue: {},\n        description: \"Resource tags\",\n      },\n      ...properties,\n    },\n    required: [\"name\", \"location\"],\n    optional: [\"tags\"],\n    deprecated: [],\n    transformationRules: {},\n    validationRules: [],\n  });\n\n  const createTestVersionConfig = (\n    version: string,\n    supportLevel: string = VersionSupportLevel.ACTIVE,\n  ): VersionConfig => ({\n    version,\n    schema: createTestSchema(version),\n    supportLevel,\n    releaseDate: version,\n    deprecationDate: undefined,\n    sunsetDate: undefined,\n    breakingChanges: [],\n    migrationGuide: `/docs/migration-${version}`,\n    changeLog: [\n      {\n        changeType: \"added\",\n        description: `Initial release of version ${version}`,\n        breaking: false,\n      },\n    ],\n  });\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    // Register test versions\n    const versions = [\n      createTestVersionConfig(\"2024-01-01\", VersionSupportLevel.DEPRECATED),\n      createTestVersionConfig(\"2024-06-01\", VersionSupportLevel.ACTIVE),\n      createTestVersionConfig(\"2024-12-01\", VersionSupportLevel.ACTIVE),\n    ];\n\n    try {\n      manager.registerResourceType(TEST_RESOURCE_TYPE, versions);\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Initialization\", () => {\n    it(\"should create resource with automatic version resolution\", () => {\n      const props: AzapiResourceProps = {\n        name: \"test-resource\",\n        location: \"eastus\",\n      };\n\n      const resource = new TestVersionedResource(stack, \"TestResource\", props);\n\n      expect(resource).toBeInstanceOf(TestVersionedResource);\n      expect(resource).toBeInstanceOf(AzapiResource);\n      expect(resource.resolvedApiVersion).toBe(\"2024-12-01\"); // Latest active version\n    });\n\n    it(\"should create resource with explicit version pinning\", () => {\n      const props: AzapiResourceProps = {\n        name: \"test-resource\",\n        location: \"eastus\",\n        apiVersion: \"2024-06-01\",\n      };\n\n      const resource = new TestVersionedResource(stack, \"TestResource\", props);\n\n      expect(resource.resolvedApiVersion).toBe(\"2024-06-01\");\n    });\n\n    it(\"should throw error when version is not registered\", () => {\n      // Test with a resource type that's not registered\n      class UnregisteredResource extends AzapiResource {\n        public get id(): string {\n          return `\\${${this.terraformResource.fqn}.id}`;\n        }\n\n        protected defaultVersion(): string {\n          return \"2023-01-01\";\n        }\n\n        protected resourceType(): string {\n          return \"Microsoft.Unregistered/resources\";\n        }\n\n        protected apiSchema(): ApiSchema {\n          return createTestSchema(\"2023-01-01\");\n        }\n\n        protected createResourceBody(props: any): any {\n          return { name: props.name };\n        }\n      }\n\n      expect(() => {\n        new UnregisteredResource(stack, \"UnregisteredResource\", {\n          name: \"test\",\n          location: \"eastus\",\n        });\n      }).toThrow(\n        \"Version configuration not found for Microsoft.Unregistered/resources@2023-01-01\",\n      );\n    });\n\n    it(\"should validate explicit version support\", () => {\n      const props: AzapiResourceProps = {\n        name: \"test-resource\",\n        location: \"eastus\",\n        apiVersion: \"2025-01-01\", // Unsupported version\n      };\n\n      expect(() => {\n        new TestVersionedResource(stack, \"TestResource\", props);\n      }).toThrow(\"Unsupported API version '2025-01-01'\");\n    });\n\n    it(\"should throw error when version configuration is missing\", () => {\n      // Create a version that's registered but has no config (edge case)\n      class InvalidConfigResource extends TestVersionedResource {\n        protected apiSchema(): ApiSchema {\n          // This would normally fail when trying to resolve schema\n          return createTestSchema(\"invalid-version\");\n        }\n      }\n\n      expect(() => {\n        new InvalidConfigResource(stack, \"InvalidResource\", {\n          name: \"test\",\n          location: \"eastus\",\n          apiVersion: \"invalid-version\",\n        });\n      }).toThrow(\"Unsupported API version 'invalid-version'\");\n    });\n  });\n\n  describe(\"Schema Resolution and Validation\", () => {\n    it(\"should resolve schema correctly\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n      });\n\n      expect(resource.schema).toBeDefined();\n      expect(resource.schema.resourceType).toBe(TEST_RESOURCE_TYPE);\n      expect(resource.schema.version).toBe(\"2024-12-01\");\n    });\n\n    it(\"should load version configuration\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n      });\n\n      expect(resource.versionConfig).toBeDefined();\n      expect(resource.versionConfig.version).toBe(\"2024-12-01\");\n      expect(resource.versionConfig.supportLevel).toBe(\n        VersionSupportLevel.ACTIVE,\n      );\n    });\n\n    it(\"should validate properties when validation is enabled\", () => {\n      const props: AzapiResourceProps = {\n        // Missing required properties to trigger validation error\n        enableValidation: true,\n      };\n\n      expect(() => {\n        new TestVersionedResource(stack, \"TestResource\", props);\n      }).toThrow(\"Property validation failed\");\n    });\n\n    it(\"should skip validation when disabled\", () => {\n      const props: AzapiResourceProps = {\n        // Missing required properties but validation disabled\n        enableValidation: false,\n      };\n\n      expect(() => {\n        new TestVersionedResource(stack, \"TestResource\", props);\n      }).not.toThrow();\n    });\n\n    it(\"should have validation results when validation passes\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        enableValidation: true,\n      });\n\n      expect(resource.validationResult).toBeDefined();\n      expect(resource.validationResult!.valid).toBe(true);\n    });\n  });\n\n  describe(\"Property Processing and Transformation\", () => {\n    it(\"should apply default values\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        // tags not provided, should get default value\n      });\n\n      expect(resource).toBeDefined();\n      // The resource should have been created with default tags applied\n    });\n\n    it(\"should handle transformation when enabled\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        enableTransformation: true,\n      });\n\n      expect(resource).toBeDefined();\n    });\n\n    it(\"should skip transformation when disabled\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        enableTransformation: false,\n      });\n\n      expect(resource).toBeDefined();\n    });\n  });\n\n  describe(\"Migration Analysis\", () => {\n    it(\"should perform migration analysis when enabled\", () => {\n      // Use deprecated version to trigger migration analysis\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        apiVersion: \"2024-01-01\", // Deprecated version\n        enableMigrationAnalysis: true,\n      });\n\n      expect(resource.migrationAnalysis).toBeDefined();\n      expect(resource.migrationAnalysis!.fromVersion).toBe(\"2024-01-01\");\n      expect(resource.migrationAnalysis!.toVersion).toBe(\"2024-12-01\");\n    });\n\n    it(\"should skip migration analysis when disabled\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        apiVersion: \"2024-01-01\",\n        enableMigrationAnalysis: false,\n      });\n\n      expect(resource.migrationAnalysis).toBeUndefined();\n    });\n\n    it(\"should not perform migration analysis for active versions\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        apiVersion: \"2024-12-01\", // Active version\n        enableMigrationAnalysis: true,\n      });\n\n      expect(resource.migrationAnalysis).toBeUndefined();\n    });\n  });\n\n  describe(\"Version Management Methods\", () => {\n    let resource: TestVersionedResource;\n\n    beforeEach(() => {\n      resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n      });\n    });\n\n    it(\"should get latest version\", () => {\n      const latest = resource.latestVersion();\n      expect(latest).toBe(\"2024-12-01\");\n    });\n\n    it(\"should get supported versions\", () => {\n      const versions = resource.supportedVersions();\n      expect(versions).toEqual([\"2024-12-01\", \"2024-06-01\", \"2024-01-01\"]);\n    });\n\n    it(\"should analyze migration to target version\", () => {\n      const analysis = resource.analyzeMigrationTo(\"2024-06-01\");\n\n      expect(analysis).toBeDefined();\n      expect(analysis.fromVersion).toBe(\"2024-12-01\");\n      expect(analysis.toVersion).toBe(\"2024-06-01\");\n    });\n  });\n\n  describe(\"Resource Creation\", () => {\n    it(\"should create Azure resource with correct body\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"westus\",\n        tags: { environment: \"test\" },\n      });\n\n      expect(resource).toBeDefined();\n      // The underlying AZAPI resource should be created but we can't access it directly\n    });\n\n    it(\"should handle resource creation with minimal properties\", () => {\n      const resource = new TestVersionedResource(stack, \"TestResource\", {\n        name: \"minimal-resource\",\n        location: \"eastus\",\n      });\n\n      expect(resource).toBeDefined();\n    });\n  });\n\n  describe(\"Logging and Warning Messages\", () => {\n    it(\"should log deprecation warnings\", () => {\n      const warnSpy = jest.spyOn(console, \"warn\").mockImplementation();\n\n      new TestVersionedResource(stack, \"TestResource\", {\n        name: \"test-resource\",\n        location: \"eastus\",\n        apiVersion: \"2024-01-01\", // Deprecated version\n      });\n\n      expect(warnSpy).toHaveBeenCalledWith(\n        expect.stringContaining(\n          \"API version 2024-01-01 for Microsoft.Test/resources is deprecated\",\n        ),\n      );\n\n      warnSpy.mockRestore();\n    });\n\n    it(\"should log validation warnings\", () => {\n      const warnSpy = jest.spyOn(console, \"warn\").mockImplementation();\n\n      // Use the existing TestVersionedResource with unknown property to trigger validation warning\n      new TestVersionedResource(stack, \"ValidationWarningTest\", {\n        name: \"test\",\n        location: \"eastus\",\n        unknownProperty: \"value\", // This should trigger a validation warning\n      } as any);\n\n      // Should have logged validation warnings about unknown property\n      expect(warnSpy).toHaveBeenCalledWith(\n        expect.stringContaining(\"Property validation warning\"),\n      );\n\n      warnSpy.mockRestore();\n    });\n\n    it(\"should log migration analysis warnings\", () => {\n      const warnSpy = jest.spyOn(console, \"warn\").mockImplementation();\n\n      // Use deprecated version to trigger migration analysis\n      new TestVersionedResource(stack, \"MigrationWarningTest\", {\n        name: \"test\",\n        location: \"eastus\",\n        apiVersion: \"2024-01-01\", // This is a deprecated version\n        enableMigrationAnalysis: true,\n      });\n\n      // Check for deprecation warning (which is logged)\n      expect(warnSpy).toHaveBeenCalledWith(\n        expect.stringContaining(\n          \"API version 2024-01-01 for Microsoft.Test/resources is deprecated\",\n        ),\n      );\n\n      warnSpy.mockRestore();\n    });\n  });\n\n  describe(\"Abstract Method Implementation\", () => {\n    it(\"should require implementation of abstract methods\", () => {\n      // Test that abstract methods must be implemented\n      // This test validates that TypeScript will catch missing implementations at compile time\n      // We can't actually test runtime behavior for abstract classes\n      expect(true).toBe(true); // Placeholder test since TS compilation errors are caught at build time\n    });\n\n    it(\"should use resolveSchema helper correctly\", () => {\n      class ResourceUsingHelper extends AzapiResource {\n        public get id(): string {\n          return `\\${${this.terraformResource.fqn}.id}`;\n        }\n        protected defaultVersion(): string {\n          return \"2024-01-01\";\n        }\n        protected resourceType(): string {\n          return TEST_RESOURCE_TYPE;\n        }\n        protected apiSchema(): ApiSchema {\n          return this.resolveSchema();\n        }\n        protected createResourceBody(props: any): any {\n          return { name: props.name };\n        }\n      }\n\n      const resource = new ResourceUsingHelper(stack, \"HelperResource\", {\n        name: \"test\",\n        location: \"eastus\",\n      });\n\n      expect(resource.schema).toBeDefined();\n      expect(resource.schema.resourceType).toBe(TEST_RESOURCE_TYPE);\n    });\n\n    it(\"should handle schema resolution errors\", () => {\n      class BadSchemaResource extends AzapiResource {\n        public get id(): string {\n          return `\\${${this.terraformResource.fqn}.id}`;\n        }\n        protected defaultVersion(): string {\n          return \"2024-01-01\";\n        }\n        protected resourceType(): string {\n          return \"Invalid.Type/resource\";\n        }\n        protected apiSchema(): ApiSchema {\n          return this.resolveSchema();\n        }\n        protected createResourceBody(props: any): any {\n          return { name: props.name };\n        }\n      }\n\n      expect(() => {\n        new BadSchemaResource(stack, \"BadResource\", {\n          name: \"test\",\n          location: \"eastus\",\n        });\n      }).toThrow(\"Cannot resolve schema\");\n    });\n  });\n\n  describe(\"Error Handling\", () => {\n    it(\"should handle validation errors gracefully\", () => {\n      const props: AzapiResourceProps = {\n        name: \"\", // Invalid name\n        location: \"\", // Invalid location\n        enableValidation: true,\n      };\n\n      expect(() => {\n        new TestVersionedResource(stack, \"TestResource\", props);\n      }).toThrow(\"Property validation failed\");\n    });\n\n    it(\"should handle transformation errors\", () => {\n      // Create a resource that might have transformation issues\n      class ProblematicResource extends TestVersionedResource {\n        protected createResourceBody(props: any): any {\n          // Simulate an error in resource body creation\n          if (props.causeError) {\n            throw new Error(\"Resource body creation failed\");\n          }\n          return super.createResourceBody(props);\n        }\n      }\n\n      expect(() => {\n        new ProblematicResource(stack, \"ProblematicResource\", {\n          name: \"test\",\n          location: \"eastus\",\n          causeError: true,\n        } as any);\n      }).toThrow();\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have JSII-compliant constructor\", () => {\n      expect(() => {\n        new TestVersionedResource(stack, \"JsiiTest\", {\n          name: \"test\",\n          location: \"eastus\",\n        });\n      }).not.toThrow();\n    });\n\n    it(\"should have JSII-compliant public methods\", () => {\n      const resource = new TestVersionedResource(stack, \"JsiiTest\", {\n        name: \"test\",\n        location: \"eastus\",\n      });\n\n      expect(typeof resource.latestVersion).toBe(\"function\");\n      expect(typeof resource.supportedVersions).toBe(\"function\");\n      expect(typeof resource.analyzeMigrationTo).toBe(\"function\");\n    });\n\n    it(\"should have JSII-compliant public properties\", () => {\n      const resource = new TestVersionedResource(stack, \"JsiiTest\", {\n        name: \"test\",\n        location: \"eastus\",\n      });\n\n      expect(typeof resource.resolvedApiVersion).toBe(\"string\");\n      expect(typeof resource.schema).toBe(\"object\");\n      expect(typeof resource.versionConfig).toBe(\"object\");\n    });\n\n    it(\"should handle JSII serialization of complex objects\", () => {\n      const resource = new TestVersionedResource(stack, \"JsiiTest\", {\n        name: \"test\",\n        location: \"eastus\",\n        tags: {\n          environment: \"test\",\n          project: \"unit-tests\",\n        },\n      });\n\n      // Should be able to serialize the validation result\n      expect(() => JSON.stringify(resource.validationResult)).not.toThrow();\n\n      // Should be able to serialize the schema\n      expect(() => JSON.stringify(resource.schema)).not.toThrow();\n    });\n  });\n\n  describe(\"Integration with CDK Terraform\", () => {\n    it(\"should synthesize correctly\", () => {\n      new TestVersionedResource(stack, \"SynthTest\", {\n        name: \"test-resource\",\n        location: \"eastus\",\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 within CDK constructs\", () => {\n      class CompositeConstruct extends Construct {\n        constructor(scope: Construct, id: string) {\n          super(scope, id);\n\n          new TestVersionedResource(this, \"NestedResource\", {\n            name: \"nested-resource\",\n            location: \"westus\",\n          });\n        }\n      }\n\n      expect(() => {\n        new CompositeConstruct(stack, \"CompositeTest\");\n      }).not.toThrow();\n    });\n\n    it(\"should handle multiple resources in the same stack\", () => {\n      new TestVersionedResource(stack, \"Resource1\", {\n        name: \"resource-1\",\n        location: \"eastus\",\n      });\n\n      new TestVersionedResource(stack, \"Resource2\", {\n        name: \"resource-2\",\n        location: \"westus\",\n        apiVersion: \"2024-06-01\",\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n});\n"]}