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

package/lib/core-azure/lib/azapi/schema-mapper/schema-mapper.spec.js

@@ -0,0 +1,630 @@
+"use strict";
+/**
+ * Comprehensive tests for SchemaMapper - Property transformation and validation engine
+ *
+ * This test suite validates all functionality of the SchemaMapper class,
+ * including property validation, transformation, default value application, and error handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_mapper_1 = require("./schema-mapper");
+const version_interfaces_1 = require("../../version-manager/interfaces/version-interfaces");
+describe("SchemaMapper", () => {
+    // Test data setup
+    const createTestSchema = (properties = {}) => ({
+        resourceType: "Microsoft.Test/resources",
+        version: "2024-01-01",
+        properties: {
+            name: {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: true,
+                description: "Resource name",
+                validation: [
+                    {
+                        ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                        message: "Name is required",
+                    },
+                    {
+                        ruleType: version_interfaces_1.ValidationRuleType.PATTERN_MATCH,
+                        value: "^[a-zA-Z0-9-]+$",
+                        message: "Name must contain only alphanumeric characters and hyphens",
+                    },
+                ],
+            },
+            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: [
+            {
+                property: "name",
+                rules: [
+                    {
+                        ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                        message: "Name is required",
+                    },
+                ],
+            },
+        ],
+    });
+    describe("Factory Method", () => {
+        it("should create SchemaMapper instance successfully", () => {
+            const schema = createTestSchema();
+            const mapper = schema_mapper_1.SchemaMapper.create(schema);
+            expect(mapper).toBeInstanceOf(schema_mapper_1.SchemaMapper);
+        });
+        it("should validate schema input", () => {
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(null);
+            }).toThrow("Schema cannot be undefined or null");
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(undefined);
+            }).toThrow("Schema cannot be undefined or null");
+        });
+        it("should validate schema has valid resourceType", () => {
+            const invalidSchema = createTestSchema();
+            invalidSchema.resourceType = "";
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(invalidSchema);
+            }).toThrow("Schema must have a valid resourceType");
+            invalidSchema.resourceType = "   ";
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(invalidSchema);
+            }).toThrow("Schema must have a valid resourceType");
+        });
+        it("should validate schema has valid version", () => {
+            const invalidSchema = createTestSchema();
+            invalidSchema.version = "";
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(invalidSchema);
+            }).toThrow("Schema must have a valid version");
+        });
+        it("should validate schema has properties", () => {
+            const invalidSchema = createTestSchema();
+            invalidSchema.properties = null;
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(invalidSchema);
+            }).toThrow("Schema must have a properties definition");
+        });
+        it("should validate schema has required array", () => {
+            const invalidSchema = createTestSchema();
+            invalidSchema.required = null;
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(invalidSchema);
+            }).toThrow("Schema must have a required properties array");
+            invalidSchema.required = "not-an-array";
+            expect(() => {
+                schema_mapper_1.SchemaMapper.create(invalidSchema);
+            }).toThrow("Schema must have a required properties array");
+        });
+    });
+    describe("Property Validation", () => {
+        let mapper;
+        beforeEach(() => {
+            const schema = createTestSchema();
+            mapper = schema_mapper_1.SchemaMapper.create(schema);
+        });
+        it("should validate valid properties successfully", () => {
+            const properties = {
+                name: "test-resource",
+                location: "eastus",
+                tags: { environment: "test" },
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+            expect(result.warnings).toHaveLength(0);
+        });
+        it("should validate null/undefined input", () => {
+            const result = mapper.validateProperties(null);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain("Properties cannot be undefined or null");
+        });
+        it("should validate required properties", () => {
+            const properties = {
+                tags: { environment: "test" },
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain("Required property 'name' is missing");
+            expect(result.errors).toContain("Required property 'location' is missing");
+            expect(result.propertyErrors).toBeDefined();
+            expect(result.propertyErrors.name).toContain("Required property 'name' is missing");
+        });
+        it("should validate property types", () => {
+            const properties = {
+                name: 123, // Should be string
+                location: "eastus",
+                tags: "not-an-object", // Should be object
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain("Property 'name' must be a string, got: number");
+            expect(result.errors).toContain("Property 'tags' must be an object, got: string");
+        });
+        it("should validate pattern matching", () => {
+            const properties = {
+                name: "invalid name with spaces!", // Doesn't match pattern
+                location: "eastus",
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((error) => error.includes("Name must contain only alphanumeric characters and hyphens"))).toBe(true);
+        });
+        it("should generate warnings for unknown properties", () => {
+            const properties = {
+                name: "test-resource",
+                location: "eastus",
+                unknownProperty: "value",
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+            expect(result.warnings).toContain("Unknown property 'unknownProperty' not defined in schema");
+        });
+        it("should handle deprecated properties", () => {
+            const schemaWithDeprecated = createTestSchema({
+                deprecatedProp: {
+                    dataType: version_interfaces_1.PropertyType.STRING,
+                    required: false,
+                    deprecated: true,
+                    description: "This property is deprecated",
+                },
+            });
+            const mapperWithDeprecated = schema_mapper_1.SchemaMapper.create(schemaWithDeprecated);
+            const properties = {
+                name: "test-resource",
+                location: "eastus",
+                deprecatedProp: "value",
+            };
+            const result = mapperWithDeprecated.validateProperties(properties);
+            expect(result.valid).toBe(true);
+            expect(result.warnings).toContain("Property 'deprecatedProp' is deprecated");
+        });
+    });
+    describe("Property Type Validation", () => {
+        let mapper;
+        beforeEach(() => {
+            const schema = createTestSchema({
+                stringProp: { dataType: version_interfaces_1.PropertyType.STRING, required: false },
+                numberProp: { dataType: version_interfaces_1.PropertyType.NUMBER, required: false },
+                booleanProp: { dataType: version_interfaces_1.PropertyType.BOOLEAN, required: false },
+                arrayProp: { dataType: version_interfaces_1.PropertyType.ARRAY, required: false },
+                objectProp: { dataType: version_interfaces_1.PropertyType.OBJECT, required: false },
+                anyProp: { dataType: version_interfaces_1.PropertyType.ANY, required: false },
+            });
+            mapper = schema_mapper_1.SchemaMapper.create(schema);
+        });
+        it("should validate string properties", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+                stringProp: "valid string",
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+        });
+        it("should validate number properties", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+                numberProp: 42,
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+        });
+        it("should validate boolean properties", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+                booleanProp: true,
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+        });
+        it("should validate array properties", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+                arrayProp: ["item1", "item2"],
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+        });
+        it("should validate object properties", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+                objectProp: { key: "value" },
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+        });
+        it("should accept any type for ANY properties", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+                anyProp: "string",
+            };
+            let result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+            properties.anyProp = 42;
+            result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+            properties.anyProp = { complex: "object" };
+            result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(true);
+        });
+    });
+    describe("Validation Rules", () => {
+        it("should validate VALUE_RANGE rules", () => {
+            const schema = createTestSchema({
+                count: {
+                    dataType: version_interfaces_1.PropertyType.NUMBER,
+                    required: false,
+                    validation: [
+                        {
+                            ruleType: version_interfaces_1.ValidationRuleType.VALUE_RANGE,
+                            value: { min: 1, max: 10 },
+                            message: "Count must be between 1 and 10",
+                        },
+                    ],
+                },
+            });
+            const mapper = schema_mapper_1.SchemaMapper.create(schema);
+            // Valid value
+            let result = mapper.validateProperties({
+                name: "test",
+                location: "eastus",
+                count: 5,
+            });
+            expect(result.valid).toBe(true);
+            // Too low
+            result = mapper.validateProperties({
+                name: "test",
+                location: "eastus",
+                count: 0,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain("Count must be between 1 and 10");
+            // Too high
+            result = mapper.validateProperties({
+                name: "test",
+                location: "eastus",
+                count: 15,
+            });
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain("Count must be between 1 and 10");
+        });
+        it("should handle required validation with null/undefined values", () => {
+            const properties = {
+                name: null,
+                location: undefined,
+            };
+            const mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(false);
+            expect(result.errors.some((error) => error.includes("Property 'name' is required but is null"))).toBe(true);
+            expect(result.errors.some((error) => error.includes("Property 'location' is required but is undefined"))).toBe(true);
+        });
+    });
+    describe("Default Value Application", () => {
+        let mapper;
+        beforeEach(() => {
+            const schema = createTestSchema({
+                defaultString: {
+                    dataType: version_interfaces_1.PropertyType.STRING,
+                    required: false,
+                    defaultValue: "default-value",
+                },
+                defaultNumber: {
+                    dataType: version_interfaces_1.PropertyType.NUMBER,
+                    required: false,
+                    defaultValue: 42,
+                },
+                defaultObject: {
+                    dataType: version_interfaces_1.PropertyType.OBJECT,
+                    required: false,
+                    defaultValue: { default: true },
+                },
+            });
+            mapper = schema_mapper_1.SchemaMapper.create(schema);
+        });
+        it("should apply default values for missing properties", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+            };
+            const result = mapper.applyDefaults(properties);
+            expect(result.name).toBe("test");
+            expect(result.location).toBe("eastus");
+            expect(result.tags).toEqual({});
+            expect(result.defaultString).toBe("default-value");
+            expect(result.defaultNumber).toBe(42);
+            expect(result.defaultObject).toEqual({ default: true });
+        });
+        it("should not override existing values", () => {
+            const properties = {
+                name: "test",
+                location: "eastus",
+                defaultString: "existing-value",
+                defaultNumber: 100,
+            };
+            const result = mapper.applyDefaults(properties);
+            expect(result.defaultString).toBe("existing-value");
+            expect(result.defaultNumber).toBe(100);
+        });
+        it("should handle null/undefined input", () => {
+            const result = mapper.applyDefaults(null);
+            expect(result.tags).toEqual({});
+            expect(result.defaultString).toBe("default-value");
+            expect(result.defaultNumber).toBe(42);
+        });
+        it("should handle errors gracefully", () => {
+            // Create a mapper that might cause errors during default application
+            const invalidMapper = mapper;
+            invalidMapper._schema.properties.invalidProp = {
+                dataType: "invalid-type",
+                defaultValue: "value",
+            };
+            expect(() => {
+                mapper.applyDefaults({ name: "test", location: "eastus" });
+            }).not.toThrow(); // Should handle errors gracefully
+        });
+    });
+    describe("Property Transformation", () => {
+        it("should transform properties between schemas", () => {
+            const sourceSchema = createTestSchema();
+            const targetSchema = {
+                ...createTestSchema(),
+                transformationRules: {
+                    oldName: "name",
+                    oldLocation: "location",
+                },
+            };
+            const mapper = schema_mapper_1.SchemaMapper.create(sourceSchema);
+            const sourceProps = {
+                oldName: "test-resource",
+                oldLocation: "eastus",
+                tags: { env: "test" },
+            };
+            const transformed = mapper.transformProperties(sourceProps, targetSchema);
+            expect(transformed.name).toBe("test-resource");
+            expect(transformed.location).toBe("eastus");
+            expect(transformed.tags).toEqual({ env: "test" });
+        });
+        it("should handle null/undefined source properties", () => {
+            const targetSchema = createTestSchema();
+            const mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+            const result = mapper.transformProperties(null, targetSchema);
+            expect(result).toEqual({});
+            const result2 = mapper.transformProperties(undefined, targetSchema);
+            expect(result2).toEqual({});
+        });
+        it("should validate target schema", () => {
+            const mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+            expect(() => {
+                mapper.transformProperties({ name: "test" }, null);
+            }).toThrow("Target schema cannot be undefined or null");
+        });
+        it("should handle transformation errors", () => {
+            const mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+            const invalidTargetSchema = createTestSchema();
+            invalidTargetSchema.properties = null;
+            expect(() => {
+                mapper.transformProperties({ name: "test" }, invalidTargetSchema);
+            }).toThrow("Property transformation failed");
+        });
+    });
+    describe("Property Mapping", () => {
+        let mapper;
+        beforeEach(() => {
+            mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+        });
+        it("should map individual properties", () => {
+            const targetProperty = {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: true,
+            };
+            const result = mapper.mapProperty("name", "test-value", targetProperty);
+            expect(result).toBe("test-value");
+        });
+        it("should apply default values during mapping", () => {
+            const targetProperty = {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: false,
+                defaultValue: "default-value",
+            };
+            const result = mapper.mapProperty("name", undefined, targetProperty);
+            expect(result).toBe("default-value");
+        });
+        it("should validate property mapping input", () => {
+            const targetProperty = {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: true,
+            };
+            expect(() => {
+                mapper.mapProperty("", "value", targetProperty);
+            }).toThrow("Property name cannot be empty");
+            expect(() => {
+                mapper.mapProperty("name", "value", null);
+            }).toThrow("Target property definition cannot be undefined");
+        });
+        it("should handle property mapping errors", () => {
+            const targetProperty = {
+                dataType: version_interfaces_1.PropertyType.NUMBER,
+                required: true,
+            };
+            expect(() => {
+                mapper.mapProperty("name", { complex: "object" }, targetProperty);
+            }).toThrow("Property mapping failed for 'name'");
+        });
+    });
+    describe("Type Transformation", () => {
+        let mapper;
+        beforeEach(() => {
+            mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+        });
+        it("should transform values to string", () => {
+            const targetProperty = {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: false,
+            };
+            expect(mapper.mapProperty("prop", "string", targetProperty)).toBe("string");
+            expect(mapper.mapProperty("prop", 42, targetProperty)).toBe("42");
+            expect(mapper.mapProperty("prop", true, targetProperty)).toBe("true");
+        });
+        it("should transform values to number", () => {
+            const targetProperty = {
+                dataType: version_interfaces_1.PropertyType.NUMBER,
+                required: false,
+            };
+            expect(mapper.mapProperty("prop", 42, targetProperty)).toBe(42);
+            expect(mapper.mapProperty("prop", "42", targetProperty)).toBe(42);
+            expect(mapper.mapProperty("prop", "42.5", targetProperty)).toBe(42.5);
+        });
+        it("should transform values to boolean", () => {
+            const targetProperty = {
+                dataType: version_interfaces_1.PropertyType.BOOLEAN,
+                required: false,
+            };
+            expect(mapper.mapProperty("prop", true, targetProperty)).toBe(true);
+            expect(mapper.mapProperty("prop", false, targetProperty)).toBe(false);
+            expect(mapper.mapProperty("prop", "true", targetProperty)).toBe(true);
+            expect(mapper.mapProperty("prop", "false", targetProperty)).toBe(false);
+            expect(mapper.mapProperty("prop", "1", targetProperty)).toBe(true);
+            expect(mapper.mapProperty("prop", "0", targetProperty)).toBe(false);
+            expect(mapper.mapProperty("prop", 1, targetProperty)).toBe(true);
+            expect(mapper.mapProperty("prop", 0, targetProperty)).toBe(false);
+        });
+        it("should handle array and object types", () => {
+            const arrayProperty = {
+                dataType: version_interfaces_1.PropertyType.ARRAY,
+                required: false,
+            };
+            const objectProperty = {
+                dataType: version_interfaces_1.PropertyType.OBJECT,
+                required: false,
+            };
+            const array = ["item1", "item2"];
+            const object = { key: "value" };
+            expect(mapper.mapProperty("prop", array, arrayProperty)).toEqual(array);
+            expect(mapper.mapProperty("prop", object, objectProperty)).toEqual(object);
+        });
+        it("should handle transformation errors", () => {
+            const stringProperty = {
+                dataType: version_interfaces_1.PropertyType.STRING,
+                required: false,
+            };
+            expect(() => {
+                mapper.mapProperty("prop", { complex: "object" }, stringProperty);
+            }).toThrow("Cannot convert value at 'prop' to string");
+        });
+    });
+    describe("Error Handling and Edge Cases", () => {
+        let mapper;
+        beforeEach(() => {
+            mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+        });
+        it("should handle validation with empty properties object", () => {
+            const result = mapper.validateProperties({});
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain("Required property 'name' is missing");
+            expect(result.errors).toContain("Required property 'location' is missing");
+        });
+        it("should handle complex nested validation errors", () => {
+            const properties = {
+                name: "",
+                location: null,
+                tags: "invalid",
+            };
+            const result = mapper.validateProperties(properties);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(0);
+            expect(result.propertyErrors).toBeDefined();
+        });
+        it("should handle circular references in objects", () => {
+            const circularObj = { name: "test", location: "eastus" };
+            circularObj.self = circularObj;
+            const result = mapper.validateProperties(circularObj);
+            // Should not crash, even with circular references
+            expect(result).toBeDefined();
+        });
+        it("should handle very large objects", () => {
+            const largeObject = { name: "test", location: "eastus" };
+            for (let i = 0; i < 1000; i++) {
+                largeObject[`prop${i}`] = `value${i}`;
+            }
+            const result = mapper.validateProperties(largeObject);
+            expect(result).toBeDefined();
+            expect(result.warnings.length).toBeGreaterThan(0); // Should warn about unknown properties
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have JSII-compliant static factory method", () => {
+            expect(typeof schema_mapper_1.SchemaMapper.create).toBe("function");
+            const schema = createTestSchema();
+            const mapper = schema_mapper_1.SchemaMapper.create(schema);
+            expect(mapper).toBeInstanceOf(schema_mapper_1.SchemaMapper);
+        });
+        it("should have JSII-compliant instance methods", () => {
+            const mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+            expect(typeof mapper.validateProperties).toBe("function");
+            expect(typeof mapper.transformProperties).toBe("function");
+            expect(typeof mapper.applyDefaults).toBe("function");
+            expect(typeof mapper.mapProperty).toBe("function");
+        });
+        it("should return JSII-compliant types", () => {
+            const mapper = schema_mapper_1.SchemaMapper.create(createTestSchema());
+            const validationResult = mapper.validateProperties({
+                name: "test",
+                location: "eastus",
+            });
+            expect(typeof validationResult.valid).toBe("boolean");
+            expect(Array.isArray(validationResult.errors)).toBe(true);
+            expect(Array.isArray(validationResult.warnings)).toBe(true);
+            const defaults = mapper.applyDefaults({ name: "test" });
+            expect(typeof defaults).toBe("object");
+            const transformed = mapper.transformProperties({ name: "test" }, createTestSchema());
+            expect(typeof transformed).toBe("object");
+        });
+        it("should handle JSII type serialization", () => {
+            const schema = createTestSchema();
+            const mapper = schema_mapper_1.SchemaMapper.create(schema);
+            // Test that complex objects can be serialized/deserialized properly
+            const complexProps = {
+                name: "test",
+                location: "eastus",
+                tags: {
+                    nested: {
+                        deep: {
+                            value: "test",
+                        },
+                    },
+                },
+            };
+            const result = mapper.validateProperties(complexProps);
+            expect(result).toBeDefined();
+            // Should be serializable to JSON (important for JSII)
+            expect(() => JSON.stringify(result)).not.toThrow();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema-mapper.spec.js","sourceRoot":"","sources":["../../../../../src/core-azure/lib/azapi/schema-mapper/schema-mapper.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for SchemaMapper - Property transformation and validation engine\n *\n * This test suite validates all functionality of the SchemaMapper class,\n * including property validation, transformation, default value application, and error handling.\n */\n\nimport { SchemaMapper } from \"./schema-mapper\";\nimport {\n  ApiSchema,\n  PropertyDefinition,\n  PropertyType,\n  ValidationRuleType,\n  // ValidationResult,\n} from \"../../version-manager/interfaces/version-interfaces\";\n\ndescribe(\"SchemaMapper\", () => {\n  // Test data setup\n  const createTestSchema = (\n    properties: { [key: string]: PropertyDefinition } = {},\n  ): ApiSchema => ({\n    resourceType: \"Microsoft.Test/resources\",\n    version: \"2024-01-01\",\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            ruleType: ValidationRuleType.PATTERN_MATCH,\n            value: \"^[a-zA-Z0-9-]+$\",\n            message:\n              \"Name must contain only alphanumeric characters and hyphens\",\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        property: \"name\",\n        rules: [\n          {\n            ruleType: ValidationRuleType.REQUIRED,\n            message: \"Name is required\",\n          },\n        ],\n      },\n    ],\n  });\n\n  describe(\"Factory Method\", () => {\n    it(\"should create SchemaMapper instance successfully\", () => {\n      const schema = createTestSchema();\n      const mapper = SchemaMapper.create(schema);\n\n      expect(mapper).toBeInstanceOf(SchemaMapper);\n    });\n\n    it(\"should validate schema input\", () => {\n      expect(() => {\n        SchemaMapper.create(null as any);\n      }).toThrow(\"Schema cannot be undefined or null\");\n\n      expect(() => {\n        SchemaMapper.create(undefined as any);\n      }).toThrow(\"Schema cannot be undefined or null\");\n    });\n\n    it(\"should validate schema has valid resourceType\", () => {\n      const invalidSchema = createTestSchema();\n      (invalidSchema as any).resourceType = \"\";\n\n      expect(() => {\n        SchemaMapper.create(invalidSchema);\n      }).toThrow(\"Schema must have a valid resourceType\");\n\n      (invalidSchema as any).resourceType = \"   \";\n      expect(() => {\n        SchemaMapper.create(invalidSchema);\n      }).toThrow(\"Schema must have a valid resourceType\");\n    });\n\n    it(\"should validate schema has valid version\", () => {\n      const invalidSchema = createTestSchema();\n      (invalidSchema as any).version = \"\";\n\n      expect(() => {\n        SchemaMapper.create(invalidSchema);\n      }).toThrow(\"Schema must have a valid version\");\n    });\n\n    it(\"should validate schema has properties\", () => {\n      const invalidSchema = createTestSchema();\n      (invalidSchema as any).properties = null;\n\n      expect(() => {\n        SchemaMapper.create(invalidSchema);\n      }).toThrow(\"Schema must have a properties definition\");\n    });\n\n    it(\"should validate schema has required array\", () => {\n      const invalidSchema = createTestSchema();\n      (invalidSchema as any).required = null;\n\n      expect(() => {\n        SchemaMapper.create(invalidSchema);\n      }).toThrow(\"Schema must have a required properties array\");\n\n      (invalidSchema as any).required = \"not-an-array\";\n      expect(() => {\n        SchemaMapper.create(invalidSchema);\n      }).toThrow(\"Schema must have a required properties array\");\n    });\n  });\n\n  describe(\"Property Validation\", () => {\n    let mapper: SchemaMapper;\n\n    beforeEach(() => {\n      const schema = createTestSchema();\n      mapper = SchemaMapper.create(schema);\n    });\n\n    it(\"should validate valid properties successfully\", () => {\n      const properties = {\n        name: \"test-resource\",\n        location: \"eastus\",\n        tags: { environment: \"test\" },\n      };\n\n      const result = mapper.validateProperties(properties);\n\n      expect(result.valid).toBe(true);\n      expect(result.errors).toHaveLength(0);\n      expect(result.warnings).toHaveLength(0);\n    });\n\n    it(\"should validate null/undefined input\", () => {\n      const result = mapper.validateProperties(null);\n\n      expect(result.valid).toBe(false);\n      expect(result.errors).toContain(\"Properties cannot be undefined or null\");\n    });\n\n    it(\"should validate required properties\", () => {\n      const properties = {\n        tags: { environment: \"test\" },\n      };\n\n      const result = mapper.validateProperties(properties);\n\n      expect(result.valid).toBe(false);\n      expect(result.errors).toContain(\"Required property 'name' is missing\");\n      expect(result.errors).toContain(\n        \"Required property 'location' is missing\",\n      );\n      expect(result.propertyErrors).toBeDefined();\n      expect(result.propertyErrors!.name).toContain(\n        \"Required property 'name' is missing\",\n      );\n    });\n\n    it(\"should validate property types\", () => {\n      const properties = {\n        name: 123, // Should be string\n        location: \"eastus\",\n        tags: \"not-an-object\", // Should be object\n      };\n\n      const result = mapper.validateProperties(properties);\n\n      expect(result.valid).toBe(false);\n      expect(result.errors).toContain(\n        \"Property 'name' must be a string, got: number\",\n      );\n      expect(result.errors).toContain(\n        \"Property 'tags' must be an object, got: string\",\n      );\n    });\n\n    it(\"should validate pattern matching\", () => {\n      const properties = {\n        name: \"invalid name with spaces!\", // Doesn't match pattern\n        location: \"eastus\",\n      };\n\n      const result = mapper.validateProperties(properties);\n\n      expect(result.valid).toBe(false);\n      expect(\n        result.errors.some((error) =>\n          error.includes(\n            \"Name must contain only alphanumeric characters and hyphens\",\n          ),\n        ),\n      ).toBe(true);\n    });\n\n    it(\"should generate warnings for unknown properties\", () => {\n      const properties = {\n        name: \"test-resource\",\n        location: \"eastus\",\n        unknownProperty: \"value\",\n      };\n\n      const result = mapper.validateProperties(properties);\n\n      expect(result.valid).toBe(true);\n      expect(result.warnings).toContain(\n        \"Unknown property 'unknownProperty' not defined in schema\",\n      );\n    });\n\n    it(\"should handle deprecated properties\", () => {\n      const schemaWithDeprecated = createTestSchema({\n        deprecatedProp: {\n          dataType: PropertyType.STRING,\n          required: false,\n          deprecated: true,\n          description: \"This property is deprecated\",\n        },\n      });\n\n      const mapperWithDeprecated = SchemaMapper.create(schemaWithDeprecated);\n      const properties = {\n        name: \"test-resource\",\n        location: \"eastus\",\n        deprecatedProp: \"value\",\n      };\n\n      const result = mapperWithDeprecated.validateProperties(properties);\n\n      expect(result.valid).toBe(true);\n      expect(result.warnings).toContain(\n        \"Property 'deprecatedProp' is deprecated\",\n      );\n    });\n  });\n\n  describe(\"Property Type Validation\", () => {\n    let mapper: SchemaMapper;\n\n    beforeEach(() => {\n      const schema = createTestSchema({\n        stringProp: { dataType: PropertyType.STRING, required: false },\n        numberProp: { dataType: PropertyType.NUMBER, required: false },\n        booleanProp: { dataType: PropertyType.BOOLEAN, required: false },\n        arrayProp: { dataType: PropertyType.ARRAY, required: false },\n        objectProp: { dataType: PropertyType.OBJECT, required: false },\n        anyProp: { dataType: PropertyType.ANY, required: false },\n      });\n      mapper = SchemaMapper.create(schema);\n    });\n\n    it(\"should validate string properties\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n        stringProp: \"valid string\",\n      };\n\n      const result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n    });\n\n    it(\"should validate number properties\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n        numberProp: 42,\n      };\n\n      const result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n    });\n\n    it(\"should validate boolean properties\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n        booleanProp: true,\n      };\n\n      const result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n    });\n\n    it(\"should validate array properties\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n        arrayProp: [\"item1\", \"item2\"],\n      };\n\n      const result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n    });\n\n    it(\"should validate object properties\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n        objectProp: { key: \"value\" },\n      };\n\n      const result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n    });\n\n    it(\"should accept any type for ANY properties\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n        anyProp: \"string\",\n      };\n\n      let result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n\n      properties.anyProp = 42 as any;\n      result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n\n      properties.anyProp = { complex: \"object\" } as any;\n      result = mapper.validateProperties(properties);\n      expect(result.valid).toBe(true);\n    });\n  });\n\n  describe(\"Validation Rules\", () => {\n    it(\"should validate VALUE_RANGE rules\", () => {\n      const schema = createTestSchema({\n        count: {\n          dataType: PropertyType.NUMBER,\n          required: false,\n          validation: [\n            {\n              ruleType: ValidationRuleType.VALUE_RANGE,\n              value: { min: 1, max: 10 },\n              message: \"Count must be between 1 and 10\",\n            },\n          ],\n        },\n      });\n\n      const mapper = SchemaMapper.create(schema);\n\n      // Valid value\n      let result = mapper.validateProperties({\n        name: \"test\",\n        location: \"eastus\",\n        count: 5,\n      });\n      expect(result.valid).toBe(true);\n\n      // Too low\n      result = mapper.validateProperties({\n        name: \"test\",\n        location: \"eastus\",\n        count: 0,\n      });\n      expect(result.valid).toBe(false);\n      expect(result.errors).toContain(\"Count must be between 1 and 10\");\n\n      // Too high\n      result = mapper.validateProperties({\n        name: \"test\",\n        location: \"eastus\",\n        count: 15,\n      });\n      expect(result.valid).toBe(false);\n      expect(result.errors).toContain(\"Count must be between 1 and 10\");\n    });\n\n    it(\"should handle required validation with null/undefined values\", () => {\n      const properties = {\n        name: null,\n        location: undefined,\n      };\n\n      const mapper = SchemaMapper.create(createTestSchema());\n      const result = mapper.validateProperties(properties);\n\n      expect(result.valid).toBe(false);\n      expect(\n        result.errors.some((error) =>\n          error.includes(\"Property 'name' is required but is null\"),\n        ),\n      ).toBe(true);\n      expect(\n        result.errors.some((error) =>\n          error.includes(\"Property 'location' is required but is undefined\"),\n        ),\n      ).toBe(true);\n    });\n  });\n\n  describe(\"Default Value Application\", () => {\n    let mapper: SchemaMapper;\n\n    beforeEach(() => {\n      const schema = createTestSchema({\n        defaultString: {\n          dataType: PropertyType.STRING,\n          required: false,\n          defaultValue: \"default-value\",\n        },\n        defaultNumber: {\n          dataType: PropertyType.NUMBER,\n          required: false,\n          defaultValue: 42,\n        },\n        defaultObject: {\n          dataType: PropertyType.OBJECT,\n          required: false,\n          defaultValue: { default: true },\n        },\n      });\n      mapper = SchemaMapper.create(schema);\n    });\n\n    it(\"should apply default values for missing properties\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n      };\n\n      const result = mapper.applyDefaults(properties);\n\n      expect(result.name).toBe(\"test\");\n      expect(result.location).toBe(\"eastus\");\n      expect(result.tags).toEqual({});\n      expect(result.defaultString).toBe(\"default-value\");\n      expect(result.defaultNumber).toBe(42);\n      expect(result.defaultObject).toEqual({ default: true });\n    });\n\n    it(\"should not override existing values\", () => {\n      const properties = {\n        name: \"test\",\n        location: \"eastus\",\n        defaultString: \"existing-value\",\n        defaultNumber: 100,\n      };\n\n      const result = mapper.applyDefaults(properties);\n\n      expect(result.defaultString).toBe(\"existing-value\");\n      expect(result.defaultNumber).toBe(100);\n    });\n\n    it(\"should handle null/undefined input\", () => {\n      const result = mapper.applyDefaults(null);\n\n      expect(result.tags).toEqual({});\n      expect(result.defaultString).toBe(\"default-value\");\n      expect(result.defaultNumber).toBe(42);\n    });\n\n    it(\"should handle errors gracefully\", () => {\n      // Create a mapper that might cause errors during default application\n      const invalidMapper = mapper as any;\n      invalidMapper._schema.properties.invalidProp = {\n        dataType: \"invalid-type\",\n        defaultValue: \"value\",\n      };\n\n      expect(() => {\n        mapper.applyDefaults({ name: \"test\", location: \"eastus\" });\n      }).not.toThrow(); // Should handle errors gracefully\n    });\n  });\n\n  describe(\"Property Transformation\", () => {\n    it(\"should transform properties between schemas\", () => {\n      const sourceSchema = createTestSchema();\n      const targetSchema = {\n        ...createTestSchema(),\n        transformationRules: {\n          oldName: \"name\",\n          oldLocation: \"location\",\n        },\n      };\n\n      const mapper = SchemaMapper.create(sourceSchema);\n      const sourceProps = {\n        oldName: \"test-resource\",\n        oldLocation: \"eastus\",\n        tags: { env: \"test\" },\n      };\n\n      const transformed = mapper.transformProperties(sourceProps, targetSchema);\n\n      expect(transformed.name).toBe(\"test-resource\");\n      expect(transformed.location).toBe(\"eastus\");\n      expect(transformed.tags).toEqual({ env: \"test\" });\n    });\n\n    it(\"should handle null/undefined source properties\", () => {\n      const targetSchema = createTestSchema();\n      const mapper = SchemaMapper.create(createTestSchema());\n\n      const result = mapper.transformProperties(null, targetSchema);\n      expect(result).toEqual({});\n\n      const result2 = mapper.transformProperties(undefined, targetSchema);\n      expect(result2).toEqual({});\n    });\n\n    it(\"should validate target schema\", () => {\n      const mapper = SchemaMapper.create(createTestSchema());\n\n      expect(() => {\n        mapper.transformProperties({ name: \"test\" }, null as any);\n      }).toThrow(\"Target schema cannot be undefined or null\");\n    });\n\n    it(\"should handle transformation errors\", () => {\n      const mapper = SchemaMapper.create(createTestSchema());\n      const invalidTargetSchema = createTestSchema();\n      (invalidTargetSchema as any).properties = null;\n\n      expect(() => {\n        mapper.transformProperties({ name: \"test\" }, invalidTargetSchema);\n      }).toThrow(\"Property transformation failed\");\n    });\n  });\n\n  describe(\"Property Mapping\", () => {\n    let mapper: SchemaMapper;\n\n    beforeEach(() => {\n      mapper = SchemaMapper.create(createTestSchema());\n    });\n\n    it(\"should map individual properties\", () => {\n      const targetProperty: PropertyDefinition = {\n        dataType: PropertyType.STRING,\n        required: true,\n      };\n\n      const result = mapper.mapProperty(\"name\", \"test-value\", targetProperty);\n      expect(result).toBe(\"test-value\");\n    });\n\n    it(\"should apply default values during mapping\", () => {\n      const targetProperty: PropertyDefinition = {\n        dataType: PropertyType.STRING,\n        required: false,\n        defaultValue: \"default-value\",\n      };\n\n      const result = mapper.mapProperty(\"name\", undefined, targetProperty);\n      expect(result).toBe(\"default-value\");\n    });\n\n    it(\"should validate property mapping input\", () => {\n      const targetProperty: PropertyDefinition = {\n        dataType: PropertyType.STRING,\n        required: true,\n      };\n\n      expect(() => {\n        mapper.mapProperty(\"\", \"value\", targetProperty);\n      }).toThrow(\"Property name cannot be empty\");\n\n      expect(() => {\n        mapper.mapProperty(\"name\", \"value\", null as any);\n      }).toThrow(\"Target property definition cannot be undefined\");\n    });\n\n    it(\"should handle property mapping errors\", () => {\n      const targetProperty: PropertyDefinition = {\n        dataType: PropertyType.NUMBER,\n        required: true,\n      };\n\n      expect(() => {\n        mapper.mapProperty(\"name\", { complex: \"object\" }, targetProperty);\n      }).toThrow(\"Property mapping failed for 'name'\");\n    });\n  });\n\n  describe(\"Type Transformation\", () => {\n    let mapper: SchemaMapper;\n\n    beforeEach(() => {\n      mapper = SchemaMapper.create(createTestSchema());\n    });\n\n    it(\"should transform values to string\", () => {\n      const targetProperty: PropertyDefinition = {\n        dataType: PropertyType.STRING,\n        required: false,\n      };\n\n      expect(mapper.mapProperty(\"prop\", \"string\", targetProperty)).toBe(\n        \"string\",\n      );\n      expect(mapper.mapProperty(\"prop\", 42, targetProperty)).toBe(\"42\");\n      expect(mapper.mapProperty(\"prop\", true, targetProperty)).toBe(\"true\");\n    });\n\n    it(\"should transform values to number\", () => {\n      const targetProperty: PropertyDefinition = {\n        dataType: PropertyType.NUMBER,\n        required: false,\n      };\n\n      expect(mapper.mapProperty(\"prop\", 42, targetProperty)).toBe(42);\n      expect(mapper.mapProperty(\"prop\", \"42\", targetProperty)).toBe(42);\n      expect(mapper.mapProperty(\"prop\", \"42.5\", targetProperty)).toBe(42.5);\n    });\n\n    it(\"should transform values to boolean\", () => {\n      const targetProperty: PropertyDefinition = {\n        dataType: PropertyType.BOOLEAN,\n        required: false,\n      };\n\n      expect(mapper.mapProperty(\"prop\", true, targetProperty)).toBe(true);\n      expect(mapper.mapProperty(\"prop\", false, targetProperty)).toBe(false);\n      expect(mapper.mapProperty(\"prop\", \"true\", targetProperty)).toBe(true);\n      expect(mapper.mapProperty(\"prop\", \"false\", targetProperty)).toBe(false);\n      expect(mapper.mapProperty(\"prop\", \"1\", targetProperty)).toBe(true);\n      expect(mapper.mapProperty(\"prop\", \"0\", targetProperty)).toBe(false);\n      expect(mapper.mapProperty(\"prop\", 1, targetProperty)).toBe(true);\n      expect(mapper.mapProperty(\"prop\", 0, targetProperty)).toBe(false);\n    });\n\n    it(\"should handle array and object types\", () => {\n      const arrayProperty: PropertyDefinition = {\n        dataType: PropertyType.ARRAY,\n        required: false,\n      };\n\n      const objectProperty: PropertyDefinition = {\n        dataType: PropertyType.OBJECT,\n        required: false,\n      };\n\n      const array = [\"item1\", \"item2\"];\n      const object = { key: \"value\" };\n\n      expect(mapper.mapProperty(\"prop\", array, arrayProperty)).toEqual(array);\n      expect(mapper.mapProperty(\"prop\", object, objectProperty)).toEqual(\n        object,\n      );\n    });\n\n    it(\"should handle transformation errors\", () => {\n      const stringProperty: PropertyDefinition = {\n        dataType: PropertyType.STRING,\n        required: false,\n      };\n\n      expect(() => {\n        mapper.mapProperty(\"prop\", { complex: \"object\" }, stringProperty);\n      }).toThrow(\"Cannot convert value at 'prop' to string\");\n    });\n  });\n\n  describe(\"Error Handling and Edge Cases\", () => {\n    let mapper: SchemaMapper;\n\n    beforeEach(() => {\n      mapper = SchemaMapper.create(createTestSchema());\n    });\n\n    it(\"should handle validation with empty properties object\", () => {\n      const result = mapper.validateProperties({});\n\n      expect(result.valid).toBe(false);\n      expect(result.errors).toContain(\"Required property 'name' is missing\");\n      expect(result.errors).toContain(\n        \"Required property 'location' is missing\",\n      );\n    });\n\n    it(\"should handle complex nested validation errors\", () => {\n      const properties = {\n        name: \"\",\n        location: null,\n        tags: \"invalid\",\n      };\n\n      const result = mapper.validateProperties(properties);\n\n      expect(result.valid).toBe(false);\n      expect(result.errors.length).toBeGreaterThan(0);\n      expect(result.propertyErrors).toBeDefined();\n    });\n\n    it(\"should handle circular references in objects\", () => {\n      const circularObj: any = { name: \"test\", location: \"eastus\" };\n      circularObj.self = circularObj;\n\n      const result = mapper.validateProperties(circularObj);\n      // Should not crash, even with circular references\n      expect(result).toBeDefined();\n    });\n\n    it(\"should handle very large objects\", () => {\n      const largeObject: any = { name: \"test\", location: \"eastus\" };\n      for (let i = 0; i < 1000; i++) {\n        largeObject[`prop${i}`] = `value${i}`;\n      }\n\n      const result = mapper.validateProperties(largeObject);\n      expect(result).toBeDefined();\n      expect(result.warnings.length).toBeGreaterThan(0); // Should warn about unknown properties\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have JSII-compliant static factory method\", () => {\n      expect(typeof SchemaMapper.create).toBe(\"function\");\n\n      const schema = createTestSchema();\n      const mapper = SchemaMapper.create(schema);\n      expect(mapper).toBeInstanceOf(SchemaMapper);\n    });\n\n    it(\"should have JSII-compliant instance methods\", () => {\n      const mapper = SchemaMapper.create(createTestSchema());\n\n      expect(typeof mapper.validateProperties).toBe(\"function\");\n      expect(typeof mapper.transformProperties).toBe(\"function\");\n      expect(typeof mapper.applyDefaults).toBe(\"function\");\n      expect(typeof mapper.mapProperty).toBe(\"function\");\n    });\n\n    it(\"should return JSII-compliant types\", () => {\n      const mapper = SchemaMapper.create(createTestSchema());\n\n      const validationResult = mapper.validateProperties({\n        name: \"test\",\n        location: \"eastus\",\n      });\n      expect(typeof validationResult.valid).toBe(\"boolean\");\n      expect(Array.isArray(validationResult.errors)).toBe(true);\n      expect(Array.isArray(validationResult.warnings)).toBe(true);\n\n      const defaults = mapper.applyDefaults({ name: \"test\" });\n      expect(typeof defaults).toBe(\"object\");\n\n      const transformed = mapper.transformProperties(\n        { name: \"test\" },\n        createTestSchema(),\n      );\n      expect(typeof transformed).toBe(\"object\");\n    });\n\n    it(\"should handle JSII type serialization\", () => {\n      const schema = createTestSchema();\n      const mapper = SchemaMapper.create(schema);\n\n      // Test that complex objects can be serialized/deserialized properly\n      const complexProps = {\n        name: \"test\",\n        location: \"eastus\",\n        tags: {\n          nested: {\n            deep: {\n              value: \"test\",\n            },\n          },\n        },\n      };\n\n      const result = mapper.validateProperties(complexProps);\n      expect(result).toBeDefined();\n\n      // Should be serializable to JSON (important for JSII)\n      expect(() => JSON.stringify(result)).not.toThrow();\n    });\n  });\n});\n"]}