@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.1

package/lib/azure-policydefinition/test/policy-definition.spec.js

@@ -0,0 +1,806 @@
+"use strict";
+/**
+ * Comprehensive tests for the unified PolicyDefinition implementation
+ *
+ * This test suite validates the unified PolicyDefinition class that uses
+ * the VersionedAzapiResource framework. Tests cover automatic version resolution,
+ * explicit version pinning, schema validation, property transformation, and
+ * policy-specific functionality.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const policy_definition_1 = require("../lib/policy-definition");
+const policy_definition_schemas_1 = require("../lib/policy-definition-schemas");
+describe("PolicyDefinition - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        // Ensure Policy Definition schemas are registered
+        try {
+            manager.registerResourceType(policy_definition_schemas_1.POLICY_DEFINITION_TYPE, policy_definition_schemas_1.ALL_POLICY_DEFINITION_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create policy definition with automatic latest version resolution", () => {
+            const props = {
+                name: "test-policy",
+                policyRule: {
+                    if: {
+                        field: "tags['Environment']",
+                        exists: "false",
+                    },
+                    then: {
+                        effect: "deny",
+                    },
+                },
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", props);
+            expect(policyDefinition).toBeInstanceOf(policy_definition_1.PolicyDefinition);
+            expect(policyDefinition.resolvedApiVersion).toBe("2021-06-01"); // Latest version
+            expect(policyDefinition.props).toBe(props);
+            expect(policyDefinition.name).toBe("test-policy");
+        });
+        it("should create policy definition with explicit version pinning", () => {
+            const props = {
+                name: "test-policy-pinned",
+                apiVersion: "2021-06-01",
+                policyRule: {
+                    if: {
+                        field: "type",
+                        equals: "Microsoft.Compute/virtualMachines",
+                    },
+                    then: {
+                        effect: "audit",
+                    },
+                },
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", props);
+            expect(policyDefinition.resolvedApiVersion).toBe("2021-06-01");
+        });
+        it("should create policy definition with all optional properties", () => {
+            const props = {
+                name: "test-policy-full",
+                displayName: "Test Policy Definition",
+                description: "A test policy definition for unit testing",
+                policyType: "Custom",
+                mode: "All",
+                policyRule: {
+                    if: {
+                        field: "location",
+                        notIn: ["eastus", "westus"],
+                    },
+                    then: {
+                        effect: "deny",
+                    },
+                },
+                parameters: {
+                    allowedLocations: {
+                        type: "Array",
+                        metadata: {
+                            displayName: "Allowed locations",
+                            description: "The list of allowed locations for resources",
+                        },
+                    },
+                },
+                metadata: {
+                    category: "General",
+                    version: "1.0.0",
+                },
+                ignoreChanges: ["metadata"],
+                enableValidation: true,
+                enableMigrationAnalysis: true,
+                enableTransformation: true,
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", props);
+            expect(policyDefinition.props.displayName).toBe("Test Policy Definition");
+            expect(policyDefinition.props.description).toBe("A test policy definition for unit testing");
+            expect(policyDefinition.props.policyType).toBe("Custom");
+            expect(policyDefinition.props.mode).toBe("All");
+            expect(policyDefinition.props.parameters).toBeDefined();
+            expect(policyDefinition.props.metadata).toBeDefined();
+        });
+        it("should use default name when name is not provided", () => {
+            const props = {
+                policyRule: {
+                    if: {
+                        field: "type",
+                        equals: "Microsoft.Storage/storageAccounts",
+                    },
+                    then: {
+                        effect: "audit",
+                    },
+                },
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", props);
+            expect(policyDefinition.name).toBe("TestPolicyDefinition");
+        });
+        it("should require policyRule to be provided", () => {
+            const props = {
+                name: "test-policy",
+            };
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", props);
+            }).toThrow("Required property 'policyRule' is missing");
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            expect(policyDefinition.resolvedApiVersion).toBe("2021-06-01");
+            expect(policyDefinition.latestVersion()).toBe("2021-06-01");
+        });
+        it("should support all registered API versions", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            const supportedVersions = policyDefinition.supportedVersions();
+            expect(supportedVersions).toContain("2021-06-01");
+        });
+        it("should validate version support", () => {
+            // Valid version
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "ValidVersion", {
+                    name: "test-policy",
+                    policyRule: { if: {}, then: { effect: "deny" } },
+                    apiVersion: "2021-06-01",
+                });
+            }).not.toThrow();
+            // Invalid version
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "InvalidVersion", {
+                    name: "test-policy",
+                    policyRule: { if: {}, then: { effect: "deny" } },
+                    apiVersion: "2022-01-01",
+                });
+            }).toThrow("Unsupported API version '2022-01-01'");
+        });
+        it("should load correct schema for resolved version", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                apiVersion: "2021-06-01",
+            });
+            expect(policyDefinition.schema).toBeDefined();
+            expect(policyDefinition.schema.resourceType).toBe(policy_definition_schemas_1.POLICY_DEFINITION_TYPE);
+            expect(policyDefinition.schema.version).toBe("2021-06-01");
+            expect(policyDefinition.schema.properties).toBeDefined();
+        });
+        it("should load version configuration correctly", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            expect(policyDefinition.versionConfig).toBeDefined();
+            expect(policyDefinition.versionConfig.version).toBe("2021-06-01");
+            expect(policyDefinition.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+    });
+    describe("Property Validation", () => {
+        it("should validate properties when validation is enabled", () => {
+            const props = {
+                name: "test-policy",
+                policyRule: {
+                    if: {
+                        field: "type",
+                        equals: "Microsoft.Compute/virtualMachines",
+                    },
+                    then: {
+                        effect: "audit",
+                    },
+                },
+                enableValidation: true,
+            };
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", props);
+            }).not.toThrow();
+        });
+        it("should have validation results for valid properties", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "valid-policy",
+                displayName: "Valid Policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                enableValidation: true,
+            });
+            expect(policyDefinition.validationResult).toBeDefined();
+            expect(policyDefinition.validationResult.valid).toBe(true);
+            expect(policyDefinition.validationResult.errors).toHaveLength(0);
+        });
+        it("should skip validation when disabled", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                enableValidation: false,
+            });
+            expect(policyDefinition).toBeDefined();
+        });
+    });
+    describe("Migration Analysis", () => {
+        it("should skip migration analysis for single version", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                apiVersion: "2021-06-01",
+            });
+            // Since there's only one version, migration analysis should be skipped
+            expect(policyDefinition).toBeDefined();
+        });
+        it("should skip migration analysis when disabled", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                enableMigrationAnalysis: false,
+            });
+            expect(policyDefinition.migrationAnalysis).toBeUndefined();
+        });
+    });
+    describe("Resource Creation and Body", () => {
+        it("should create correct resource body with minimal properties", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                policyRule: {
+                    if: {
+                        field: "tags['Environment']",
+                        exists: "false",
+                    },
+                    then: {
+                        effect: "deny",
+                    },
+                },
+            });
+            expect(policyDefinition).toBeDefined();
+            expect(policyDefinition.props.policyRule).toBeDefined();
+        });
+        it("should create correct resource body with all properties", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                displayName: "Test Policy",
+                description: "A test policy",
+                policyType: "Custom",
+                mode: "Indexed",
+                policyRule: {
+                    if: {
+                        field: "location",
+                        notIn: ["eastus", "westus"],
+                    },
+                    then: {
+                        effect: "deny",
+                    },
+                },
+                parameters: {
+                    allowedLocations: {
+                        type: "Array",
+                    },
+                },
+                metadata: {
+                    category: "Compliance",
+                },
+            });
+            expect(policyDefinition).toBeDefined();
+            expect(policyDefinition.props.displayName).toBe("Test Policy");
+            expect(policyDefinition.props.policyType).toBe("Custom");
+            expect(policyDefinition.props.mode).toBe("Indexed");
+        });
+        it("should create Terraform outputs", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy-outputs",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            expect(policyDefinition.idOutput).toBeInstanceOf(cdktf.TerraformOutput);
+            expect(policyDefinition.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);
+        });
+    });
+    describe("Public Methods and Properties", () => {
+        let policyDefinition;
+        beforeEach(() => {
+            policyDefinition = new policy_definition_1.PolicyDefinition(stack, "TestPolicyDefinition", {
+                name: "test-policy",
+                displayName: "Test Policy",
+                policyType: "Custom",
+                mode: "All",
+                policyRule: {
+                    if: {
+                        field: "type",
+                        equals: "Microsoft.Compute/virtualMachines",
+                    },
+                    then: {
+                        effect: "audit",
+                    },
+                },
+            });
+        });
+        it("should have correct id format", () => {
+            expect(policyDefinition.id).toMatch(/^\$\{.*\.id\}$/);
+        });
+        it("should have resourceId property matching id", () => {
+            expect(policyDefinition.resourceId).toBe(policyDefinition.id);
+        });
+        it("should return correct policyType", () => {
+            expect(policyDefinition.policyType).toBe("Custom");
+        });
+        it("should return correct policyMode", () => {
+            expect(policyDefinition.policyMode).toBe("All");
+        });
+        it("should use default policyType when not provided", () => {
+            const defaultPolicy = new policy_definition_1.PolicyDefinition(stack, "DefaultTypePolicy", {
+                name: "default-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            expect(defaultPolicy.policyType).toBe("Custom");
+        });
+        it("should use default mode when not provided", () => {
+            const defaultPolicy = new policy_definition_1.PolicyDefinition(stack, "DefaultModePolicy", {
+                name: "default-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            expect(defaultPolicy.policyMode).toBe("All");
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "IgnoreChangesPolicy", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                ignoreChanges: ["metadata", "description"],
+            });
+            expect(policyDefinition).toBeInstanceOf(policy_definition_1.PolicyDefinition);
+        });
+        it("should handle empty ignore changes array", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "EmptyIgnorePolicy", {
+                name: "test-policy",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                ignoreChanges: [],
+            });
+            expect(policyDefinition).toBeInstanceOf(policy_definition_1.PolicyDefinition);
+        });
+    });
+    describe("Policy Rule Validation", () => {
+        it("should accept complex policy rules", () => {
+            const complexRule = {
+                if: {
+                    allOf: [
+                        {
+                            field: "type",
+                            equals: "Microsoft.Storage/storageAccounts",
+                        },
+                        {
+                            field: "Microsoft.Storage/storageAccounts/enableHttpsTrafficOnly",
+                            notEquals: "true",
+                        },
+                    ],
+                },
+                then: {
+                    effect: "deny",
+                },
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "ComplexRulePolicy", {
+                name: "complex-policy",
+                policyRule: complexRule,
+            });
+            expect(policyDefinition).toBeDefined();
+            expect(policyDefinition.props.policyRule).toEqual(complexRule);
+        });
+        it("should accept policy rules with parameters", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "ParameterizedPolicy", {
+                name: "parameterized-policy",
+                policyRule: {
+                    if: {
+                        field: "[concat('tags[', parameters('tagName'), ']')]",
+                        exists: "false",
+                    },
+                    then: {
+                        effect: "[parameters('effect')]",
+                    },
+                },
+                parameters: {
+                    tagName: {
+                        type: "String",
+                        metadata: {
+                            displayName: "Tag Name",
+                            description: "Name of the tag to check",
+                        },
+                    },
+                    effect: {
+                        type: "String",
+                        allowedValues: ["audit", "deny"],
+                        defaultValue: "audit",
+                    },
+                },
+            });
+            expect(policyDefinition).toBeDefined();
+            expect(policyDefinition.props.parameters).toBeDefined();
+        });
+        it("should preserve complex allOf conditions with multiple field comparisons", () => {
+            const complexRule = {
+                if: {
+                    allOf: [
+                        {
+                            field: "type",
+                            equals: "Microsoft.Storage/storageAccounts",
+                        },
+                        {
+                            field: "Microsoft.Storage/storageAccounts/networkAcls.defaultAction",
+                            notEquals: "Deny",
+                        },
+                    ],
+                },
+                then: {
+                    effect: "audit",
+                },
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "ComplexAllOf", {
+                name: "complex-allof-policy",
+                displayName: "Complex AllOf Policy",
+                policyRule: complexRule,
+            });
+            expect(policyDefinition).toBeDefined();
+            expect(policyDefinition.props.policyRule).toEqual(complexRule);
+            // Synthesize and verify the structure is preserved
+            const synthesized = cdktf_1.Testing.synth(stack);
+            const stackConfig = JSON.parse(synthesized);
+            const azapiResource = Object.values(stackConfig.resource.azapi_resource)[0];
+            // The body is jsonencode() wrapped, so we need to parse the actual policy rule from props
+            expect(policyDefinition.props.policyRule.if.allOf).toHaveLength(2);
+            expect(policyDefinition.props.policyRule.if.allOf[0].field).toBe("type");
+            expect(policyDefinition.props.policyRule.if.allOf[0].equals).toBe("Microsoft.Storage/storageAccounts");
+            expect(policyDefinition.props.policyRule.if.allOf[1].field).toBe("Microsoft.Storage/storageAccounts/networkAcls.defaultAction");
+            expect(policyDefinition.props.policyRule.if.allOf[1].notEquals).toBe("Deny");
+            expect(policyDefinition.props.policyRule.then.effect).toBe("audit");
+            // Verify the synthesized config has the body property set
+            expect(azapiResource.body).toBeDefined();
+        });
+        it("should preserve Azure Policy expressions without converting them", () => {
+            const rule = {
+                if: {
+                    field: "location",
+                    notIn: "[parameters('allowedLocations')]",
+                },
+                then: {
+                    effect: "[parameters('effect')]",
+                },
+            };
+            new policy_definition_1.PolicyDefinition(stack, "AzurePolicyExpressions", {
+                name: "azure-expressions-policy",
+                policyRule: rule,
+                parameters: {
+                    allowedLocations: { type: "Array" },
+                    effect: { type: "String" },
+                },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            const stackConfig = JSON.parse(synthesized);
+            const azapiResource = Object.values(stackConfig.resource.azapi_resource)[0];
+            // Verify Azure Policy expressions are preserved in the construct's props
+            expect(rule.if.notIn).toBe("[parameters('allowedLocations')]");
+            expect(rule.then.effect).toBe("[parameters('effect')]");
+            // Verify the synthesized config has the body property set
+            expect(azapiResource.body).toBeDefined();
+        });
+        it("should preserve DeployIfNotExists policy with ARM template", () => {
+            const complexRule = {
+                if: {
+                    field: "type",
+                    equals: "Microsoft.Network/virtualNetworks",
+                },
+                then: {
+                    effect: "DeployIfNotExists",
+                    details: {
+                        type: "Microsoft.Network/networkManagers/networkGroups/staticMembers",
+                        deploymentScope: "subscription",
+                        existenceScope: "subscription",
+                        roleDefinitionIds: [
+                            "/providers/Microsoft.Authorization/roleDefinitions/b24988ac-6180-42a0-ab88-20f7382dd24c",
+                        ],
+                        deployment: {
+                            location: "[field('location')]",
+                            properties: {
+                                mode: "incremental",
+                                resourceGroup: "[variables('avnmResourceGroup')]",
+                                subscriptionId: "[parameters('avnmSubscriptionId')]",
+                                template: {
+                                    $schema: "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
+                                    contentVersion: "1.0.0.0",
+                                    parameters: {
+                                        vnetId: {
+                                            type: "string",
+                                        },
+                                    },
+                                    variables: {
+                                        staticMemberName: "[guid(parameters('vnetId'))]",
+                                    },
+                                    resources: [
+                                        {
+                                            type: "Microsoft.Network/networkManagers/networkGroups/staticMembers",
+                                            apiVersion: "2023-04-01",
+                                            name: "[concat(parameters('avnmId'), '/', variables('staticMemberName'))]",
+                                            properties: {
+                                                resourceId: "[parameters('vnetId')]",
+                                            },
+                                        },
+                                    ],
+                                    outputs: {
+                                        memberId: {
+                                            type: "string",
+                                            value: "[resourceId('Microsoft.Network/networkManagers/networkGroups/staticMembers', variables('staticMemberName'))]",
+                                        },
+                                    },
+                                },
+                                parameters: {
+                                    vnetId: {
+                                        value: "[field('id')]",
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "DeployIfNotExistsPolicy", {
+                name: "deploy-if-not-exists-policy",
+                displayName: "Deploy If Not Exists with ARM Template",
+                policyRule: complexRule,
+                parameters: {
+                    avnmSubscriptionId: { type: "String" },
+                },
+            });
+            expect(policyDefinition).toBeDefined();
+            const synthesized = cdktf_1.Testing.synth(stack);
+            const stackConfig = JSON.parse(synthesized);
+            const azapiResource = Object.values(stackConfig.resource.azapi_resource)[0];
+            const details = policyDefinition.props.policyRule.then.details;
+            // Verify deployment structure is preserved (not converted to null)
+            expect(details.deployment).toBeDefined();
+            expect(details.deployment.location).toBe("[field('location')]");
+            expect(details.deployment.properties).toBeDefined();
+            expect(details.deployment.properties.mode).toBe("incremental");
+            expect(details.deployment.properties.resourceGroup).toBe("[variables('avnmResourceGroup')]");
+            expect(details.deployment.properties.subscriptionId).toBe("[parameters('avnmSubscriptionId')]");
+            // Verify ARM template is fully preserved (not converted to null)
+            const template = details.deployment.properties.template;
+            expect(template).toBeDefined();
+            expect(template.$schema).toBe("https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#");
+            expect(template.contentVersion).toBe("1.0.0.0");
+            expect(template.parameters).toBeDefined();
+            expect(template.parameters.vnetId).toBeDefined();
+            expect(template.variables).toBeDefined();
+            expect(template.variables.staticMemberName).toBe("[guid(parameters('vnetId'))]");
+            expect(template.resources).toHaveLength(1);
+            expect(template.resources[0].name).toBe("[concat(parameters('avnmId'), '/', variables('staticMemberName'))]");
+            expect(template.outputs).toBeDefined();
+            expect(template.outputs.memberId.value).toBe("[resourceId('Microsoft.Network/networkManagers/networkGroups/staticMembers', variables('staticMemberName'))]");
+            // Verify ARM template parameters are preserved
+            const deploymentParams = details.deployment.properties.parameters;
+            expect(deploymentParams).toBeDefined();
+            expect(deploymentParams.vnetId.value).toBe("[field('id')]");
+            // Verify schema validation is disabled to allow complex nested structures
+            expect(azapiResource.schema_validation_enabled).toBe(false);
+            expect(azapiResource.ignore_missing_property).toBe(true);
+            // Verify the synthesized config has the body property set
+            expect(azapiResource.body).toBeDefined();
+        });
+        it("should preserve deeply nested logical operators", () => {
+            const complexRule = {
+                if: {
+                    allOf: [
+                        {
+                            field: "type",
+                            equals: "Microsoft.Network/virtualNetworks",
+                        },
+                        {
+                            anyOf: [
+                                {
+                                    field: "Microsoft.Network/virtualNetworks/enableDdosProtection",
+                                    equals: "false",
+                                },
+                                {
+                                    not: {
+                                        field: "Microsoft.Network/virtualNetworks/subnets[*].serviceEndpoints[*].service",
+                                        contains: "Microsoft.Storage",
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+                then: {
+                    effect: "audit",
+                },
+            };
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "DeeplyNested", {
+                name: "deeply-nested-policy",
+                policyRule: complexRule,
+            });
+            expect(policyDefinition.props.policyRule).toEqual(complexRule);
+            const synthesized = cdktf_1.Testing.synth(stack);
+            const stackConfig = JSON.parse(synthesized);
+            const azapiResource = Object.values(stackConfig.resource.azapi_resource)[0];
+            // Verify the deeply nested structure is preserved in the construct's props
+            expect(policyDefinition.props.policyRule.if.allOf[1].anyOf[1].not).toBeDefined();
+            expect(policyDefinition.props.policyRule.if.allOf[1].anyOf[1].not.field).toBe("Microsoft.Network/virtualNetworks/subnets[*].serviceEndpoints[*].service");
+            // Verify the synthesized config has the body property set
+            expect(azapiResource.body).toBeDefined();
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle invalid API versions gracefully", () => {
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "InvalidAPI", {
+                    name: "test-policy",
+                    policyRule: { if: {}, then: { effect: "deny" } },
+                    apiVersion: "invalid-version",
+                });
+            }).toThrow("Unsupported API version 'invalid-version'");
+        });
+        it("should handle validation errors when validation is enabled", () => {
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "ValidationError", {
+                    name: "test-policy",
+                    policyRule: undefined, // Missing required policyRule
+                    enableValidation: true,
+                });
+            }).toThrow("Required property 'policyRule' is missing");
+        });
+        it("should handle schema registration errors gracefully", () => {
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "SchemaTest", {
+                    name: "test-policy",
+                    policyRule: { if: {}, then: { effect: "deny" } },
+                });
+            }).not.toThrow();
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have JSII-compliant constructor", () => {
+            expect(() => {
+                new policy_definition_1.PolicyDefinition(stack, "JsiiTest", {
+                    name: "jsii-test",
+                    policyRule: { if: {}, then: { effect: "deny" } },
+                });
+            }).not.toThrow();
+        });
+        it("should have JSII-compliant properties", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "JsiiProps", {
+                name: "jsii-props",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            expect(typeof policyDefinition.id).toBe("string");
+            expect(typeof policyDefinition.name).toBe("string");
+            expect(typeof policyDefinition.resolvedApiVersion).toBe("string");
+            expect(typeof policyDefinition.policyType).toBe("string");
+            expect(typeof policyDefinition.policyMode).toBe("string");
+        });
+        it("should have JSII-compliant methods", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "JsiiMethods", {
+                name: "jsii-methods",
+                policyRule: { if: {}, then: { effect: "deny" } },
+            });
+            expect(typeof policyDefinition.latestVersion).toBe("function");
+            expect(typeof policyDefinition.supportedVersions).toBe("function");
+        });
+        it("should serialize complex objects correctly", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "JsiiSerialization", {
+                name: "jsii-serialization",
+                policyRule: {
+                    if: { field: "location", equals: "eastus" },
+                    then: { effect: "deny" },
+                },
+                parameters: {
+                    testParam: {
+                        type: "String",
+                    },
+                },
+            });
+            expect(() => JSON.stringify(policyDefinition.validationResult)).not.toThrow();
+            expect(() => JSON.stringify(policyDefinition.schema)).not.toThrow();
+            expect(() => JSON.stringify(policyDefinition.versionConfig)).not.toThrow();
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new policy_definition_1.PolicyDefinition(stack, "SynthTest", {
+                name: "synth-test",
+                policyRule: {
+                    if: {
+                        field: "type",
+                        equals: "Microsoft.Compute/virtualMachines",
+                    },
+                    then: {
+                        effect: "audit",
+                    },
+                },
+            });
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should work in complex CDK constructs", () => {
+            class ComplexConstruct extends cdktf.TerraformStack {
+                constructor(scope, id) {
+                    super(scope, id);
+                    const policy1 = new policy_definition_1.PolicyDefinition(this, "Policy1", {
+                        name: "policy-1",
+                        displayName: "First Policy",
+                        policyRule: { if: {}, then: { effect: "audit" } },
+                    });
+                    const policy2 = new policy_definition_1.PolicyDefinition(this, "Policy2", {
+                        name: "policy-2",
+                        displayName: "Second Policy",
+                        policyRule: { if: {}, then: { effect: "deny" } },
+                        apiVersion: "2021-06-01",
+                    });
+                    new cdktf.TerraformOutput(this, "Policy1Id", {
+                        value: policy1.id,
+                    });
+                    new cdktf.TerraformOutput(this, "Policy2Id", {
+                        value: policy2.id,
+                    });
+                }
+            }
+            expect(() => {
+                new ComplexConstruct(app, "ComplexStack");
+            }).not.toThrow();
+        });
+        it("should handle multiple policy definitions in the same stack", () => {
+            const policy1 = new policy_definition_1.PolicyDefinition(stack, "PolicyDefinition1", {
+                name: "policy-1",
+                policyRule: { if: {}, then: { effect: "audit" } },
+            });
+            const policy2 = new policy_definition_1.PolicyDefinition(stack, "PolicyDefinition2", {
+                name: "policy-2",
+                policyRule: { if: {}, then: { effect: "deny" } },
+                apiVersion: "2021-06-01",
+            });
+            expect(policy1.resolvedApiVersion).toBe("2021-06-01");
+            expect(policy2.resolvedApiVersion).toBe("2021-06-01");
+            const synthesized = cdktf_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+    describe("Policy Definition Types", () => {
+        it("should support BuiltIn policy type", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "BuiltInPolicy", {
+                name: "builtin-policy",
+                policyType: "BuiltIn",
+                policyRule: { if: {}, then: { effect: "audit" } },
+            });
+            expect(policyDefinition.policyType).toBe("BuiltIn");
+        });
+        it("should support Static policy type", () => {
+            const policyDefinition = new policy_definition_1.PolicyDefinition(stack, "StaticPolicy", {
+                name: "static-policy",
+                policyType: "Static",
+                policyRule: { if: {}, then: { effect: "audit" } },
+            });
+            expect(policyDefinition.policyType).toBe("Static");
+        });
+        it("should support different policy modes", () => {
+            const indexedPolicy = new policy_definition_1.PolicyDefinition(stack, "IndexedPolicy", {
+                name: "indexed-policy",
+                mode: "Indexed",
+                policyRule: { if: {}, then: { effect: "audit" } },
+            });
+            expect(indexedPolicy.policyMode).toBe("Indexed");
+            const resourceProviderPolicy = new policy_definition_1.PolicyDefinition(stack, "ResourceProviderPolicy", {
+                name: "resource-provider-policy",
+                mode: "Microsoft.KeyVault.Data",
+                policyRule: { if: {}, then: { effect: "audit" } },
+            });
+            expect(resourceProviderPolicy.policyMode).toBe("Microsoft.KeyVault.Data");
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-definition.spec.js","sourceRoot":"","sources":["../../../src/azure-policydefinition/test/policy-definition.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Comprehensive tests for the unified PolicyDefinition implementation\n *\n * This test suite validates the unified PolicyDefinition class that uses\n * the VersionedAzapiResource framework. Tests cover automatic version resolution,\n * explicit version pinning, schema validation, property transformation, and\n * policy-specific functionality.\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport {\n  PolicyDefinition,\n  PolicyDefinitionProps,\n} from \"../lib/policy-definition\";\nimport {\n  ALL_POLICY_DEFINITION_VERSIONS,\n  POLICY_DEFINITION_TYPE,\n} from \"../lib/policy-definition-schemas\";\n\ndescribe(\"PolicyDefinition - Unified Implementation\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n  let manager: ApiVersionManager;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    // Ensure Policy Definition schemas are registered\n    try {\n      manager.registerResourceType(\n        POLICY_DEFINITION_TYPE,\n        ALL_POLICY_DEFINITION_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create policy definition with automatic latest version resolution\", () => {\n      const props: PolicyDefinitionProps = {\n        name: \"test-policy\",\n        policyRule: {\n          if: {\n            field: \"tags['Environment']\",\n            exists: \"false\",\n          },\n          then: {\n            effect: \"deny\",\n          },\n        },\n      };\n\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        props,\n      );\n\n      expect(policyDefinition).toBeInstanceOf(PolicyDefinition);\n      expect(policyDefinition.resolvedApiVersion).toBe(\"2021-06-01\"); // Latest version\n      expect(policyDefinition.props).toBe(props);\n      expect(policyDefinition.name).toBe(\"test-policy\");\n    });\n\n    it(\"should create policy definition with explicit version pinning\", () => {\n      const props: PolicyDefinitionProps = {\n        name: \"test-policy-pinned\",\n        apiVersion: \"2021-06-01\",\n        policyRule: {\n          if: {\n            field: \"type\",\n            equals: \"Microsoft.Compute/virtualMachines\",\n          },\n          then: {\n            effect: \"audit\",\n          },\n        },\n      };\n\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        props,\n      );\n\n      expect(policyDefinition.resolvedApiVersion).toBe(\"2021-06-01\");\n    });\n\n    it(\"should create policy definition with all optional properties\", () => {\n      const props: PolicyDefinitionProps = {\n        name: \"test-policy-full\",\n        displayName: \"Test Policy Definition\",\n        description: \"A test policy definition for unit testing\",\n        policyType: \"Custom\",\n        mode: \"All\",\n        policyRule: {\n          if: {\n            field: \"location\",\n            notIn: [\"eastus\", \"westus\"],\n          },\n          then: {\n            effect: \"deny\",\n          },\n        },\n        parameters: {\n          allowedLocations: {\n            type: \"Array\",\n            metadata: {\n              displayName: \"Allowed locations\",\n              description: \"The list of allowed locations for resources\",\n            },\n          },\n        },\n        metadata: {\n          category: \"General\",\n          version: \"1.0.0\",\n        },\n        ignoreChanges: [\"metadata\"],\n        enableValidation: true,\n        enableMigrationAnalysis: true,\n        enableTransformation: true,\n      };\n\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        props,\n      );\n\n      expect(policyDefinition.props.displayName).toBe(\"Test Policy Definition\");\n      expect(policyDefinition.props.description).toBe(\n        \"A test policy definition for unit testing\",\n      );\n      expect(policyDefinition.props.policyType).toBe(\"Custom\");\n      expect(policyDefinition.props.mode).toBe(\"All\");\n      expect(policyDefinition.props.parameters).toBeDefined();\n      expect(policyDefinition.props.metadata).toBeDefined();\n    });\n\n    it(\"should use default name when name is not provided\", () => {\n      const props: PolicyDefinitionProps = {\n        policyRule: {\n          if: {\n            field: \"type\",\n            equals: \"Microsoft.Storage/storageAccounts\",\n          },\n          then: {\n            effect: \"audit\",\n          },\n        },\n      };\n\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        props,\n      );\n\n      expect(policyDefinition.name).toBe(\"TestPolicyDefinition\");\n    });\n\n    it(\"should require policyRule to be provided\", () => {\n      const props: any = {\n        name: \"test-policy\",\n      };\n\n      expect(() => {\n        new PolicyDefinition(stack, \"TestPolicyDefinition\", props);\n      }).toThrow(\"Required property 'policyRule' is missing\");\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n        },\n      );\n\n      expect(policyDefinition.resolvedApiVersion).toBe(\"2021-06-01\");\n      expect(policyDefinition.latestVersion()).toBe(\"2021-06-01\");\n    });\n\n    it(\"should support all registered API versions\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n        },\n      );\n\n      const supportedVersions = policyDefinition.supportedVersions();\n      expect(supportedVersions).toContain(\"2021-06-01\");\n    });\n\n    it(\"should validate version support\", () => {\n      // Valid version\n      expect(() => {\n        new PolicyDefinition(stack, \"ValidVersion\", {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          apiVersion: \"2021-06-01\",\n        });\n      }).not.toThrow();\n\n      // Invalid version\n      expect(() => {\n        new PolicyDefinition(stack, \"InvalidVersion\", {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          apiVersion: \"2022-01-01\",\n        });\n      }).toThrow(\"Unsupported API version '2022-01-01'\");\n    });\n\n    it(\"should load correct schema for resolved version\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          apiVersion: \"2021-06-01\",\n        },\n      );\n\n      expect(policyDefinition.schema).toBeDefined();\n      expect(policyDefinition.schema.resourceType).toBe(POLICY_DEFINITION_TYPE);\n      expect(policyDefinition.schema.version).toBe(\"2021-06-01\");\n      expect(policyDefinition.schema.properties).toBeDefined();\n    });\n\n    it(\"should load version configuration correctly\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n        },\n      );\n\n      expect(policyDefinition.versionConfig).toBeDefined();\n      expect(policyDefinition.versionConfig.version).toBe(\"2021-06-01\");\n      expect(policyDefinition.versionConfig.supportLevel).toBe(\n        VersionSupportLevel.ACTIVE,\n      );\n    });\n  });\n\n  describe(\"Property Validation\", () => {\n    it(\"should validate properties when validation is enabled\", () => {\n      const props: PolicyDefinitionProps = {\n        name: \"test-policy\",\n        policyRule: {\n          if: {\n            field: \"type\",\n            equals: \"Microsoft.Compute/virtualMachines\",\n          },\n          then: {\n            effect: \"audit\",\n          },\n        },\n        enableValidation: true,\n      };\n\n      expect(() => {\n        new PolicyDefinition(stack, \"TestPolicyDefinition\", props);\n      }).not.toThrow();\n    });\n\n    it(\"should have validation results for valid properties\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"valid-policy\",\n          displayName: \"Valid Policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          enableValidation: true,\n        },\n      );\n\n      expect(policyDefinition.validationResult).toBeDefined();\n      expect(policyDefinition.validationResult!.valid).toBe(true);\n      expect(policyDefinition.validationResult!.errors).toHaveLength(0);\n    });\n\n    it(\"should skip validation when disabled\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          enableValidation: false,\n        },\n      );\n\n      expect(policyDefinition).toBeDefined();\n    });\n  });\n\n  describe(\"Migration Analysis\", () => {\n    it(\"should skip migration analysis for single version\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          apiVersion: \"2021-06-01\",\n        },\n      );\n\n      // Since there's only one version, migration analysis should be skipped\n      expect(policyDefinition).toBeDefined();\n    });\n\n    it(\"should skip migration analysis when disabled\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          enableMigrationAnalysis: false,\n        },\n      );\n\n      expect(policyDefinition.migrationAnalysis).toBeUndefined();\n    });\n  });\n\n  describe(\"Resource Creation and Body\", () => {\n    it(\"should create correct resource body with minimal properties\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          policyRule: {\n            if: {\n              field: \"tags['Environment']\",\n              exists: \"false\",\n            },\n            then: {\n              effect: \"deny\",\n            },\n          },\n        },\n      );\n\n      expect(policyDefinition).toBeDefined();\n      expect(policyDefinition.props.policyRule).toBeDefined();\n    });\n\n    it(\"should create correct resource body with all properties\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy\",\n          displayName: \"Test Policy\",\n          description: \"A test policy\",\n          policyType: \"Custom\",\n          mode: \"Indexed\",\n          policyRule: {\n            if: {\n              field: \"location\",\n              notIn: [\"eastus\", \"westus\"],\n            },\n            then: {\n              effect: \"deny\",\n            },\n          },\n          parameters: {\n            allowedLocations: {\n              type: \"Array\",\n            },\n          },\n          metadata: {\n            category: \"Compliance\",\n          },\n        },\n      );\n\n      expect(policyDefinition).toBeDefined();\n      expect(policyDefinition.props.displayName).toBe(\"Test Policy\");\n      expect(policyDefinition.props.policyType).toBe(\"Custom\");\n      expect(policyDefinition.props.mode).toBe(\"Indexed\");\n    });\n\n    it(\"should create Terraform outputs\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"TestPolicyDefinition\",\n        {\n          name: \"test-policy-outputs\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n        },\n      );\n\n      expect(policyDefinition.idOutput).toBeInstanceOf(cdktf.TerraformOutput);\n      expect(policyDefinition.nameOutput).toBeInstanceOf(cdktf.TerraformOutput);\n    });\n  });\n\n  describe(\"Public Methods and Properties\", () => {\n    let policyDefinition: PolicyDefinition;\n\n    beforeEach(() => {\n      policyDefinition = new PolicyDefinition(stack, \"TestPolicyDefinition\", {\n        name: \"test-policy\",\n        displayName: \"Test Policy\",\n        policyType: \"Custom\",\n        mode: \"All\",\n        policyRule: {\n          if: {\n            field: \"type\",\n            equals: \"Microsoft.Compute/virtualMachines\",\n          },\n          then: {\n            effect: \"audit\",\n          },\n        },\n      });\n    });\n\n    it(\"should have correct id format\", () => {\n      expect(policyDefinition.id).toMatch(/^\\$\\{.*\\.id\\}$/);\n    });\n\n    it(\"should have resourceId property matching id\", () => {\n      expect(policyDefinition.resourceId).toBe(policyDefinition.id);\n    });\n\n    it(\"should return correct policyType\", () => {\n      expect(policyDefinition.policyType).toBe(\"Custom\");\n    });\n\n    it(\"should return correct policyMode\", () => {\n      expect(policyDefinition.policyMode).toBe(\"All\");\n    });\n\n    it(\"should use default policyType when not provided\", () => {\n      const defaultPolicy = new PolicyDefinition(stack, \"DefaultTypePolicy\", {\n        name: \"default-policy\",\n        policyRule: { if: {}, then: { effect: \"deny\" } },\n      });\n\n      expect(defaultPolicy.policyType).toBe(\"Custom\");\n    });\n\n    it(\"should use default mode when not provided\", () => {\n      const defaultPolicy = new PolicyDefinition(stack, \"DefaultModePolicy\", {\n        name: \"default-policy\",\n        policyRule: { if: {}, then: { effect: \"deny\" } },\n      });\n\n      expect(defaultPolicy.policyMode).toBe(\"All\");\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"IgnoreChangesPolicy\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          ignoreChanges: [\"metadata\", \"description\"],\n        },\n      );\n\n      expect(policyDefinition).toBeInstanceOf(PolicyDefinition);\n    });\n\n    it(\"should handle empty ignore changes array\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"EmptyIgnorePolicy\",\n        {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          ignoreChanges: [],\n        },\n      );\n\n      expect(policyDefinition).toBeInstanceOf(PolicyDefinition);\n    });\n  });\n\n  describe(\"Policy Rule Validation\", () => {\n    it(\"should accept complex policy rules\", () => {\n      const complexRule = {\n        if: {\n          allOf: [\n            {\n              field: \"type\",\n              equals: \"Microsoft.Storage/storageAccounts\",\n            },\n            {\n              field: \"Microsoft.Storage/storageAccounts/enableHttpsTrafficOnly\",\n              notEquals: \"true\",\n            },\n          ],\n        },\n        then: {\n          effect: \"deny\",\n        },\n      };\n\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"ComplexRulePolicy\",\n        {\n          name: \"complex-policy\",\n          policyRule: complexRule,\n        },\n      );\n\n      expect(policyDefinition).toBeDefined();\n      expect(policyDefinition.props.policyRule).toEqual(complexRule);\n    });\n\n    it(\"should accept policy rules with parameters\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"ParameterizedPolicy\",\n        {\n          name: \"parameterized-policy\",\n          policyRule: {\n            if: {\n              field: \"[concat('tags[', parameters('tagName'), ']')]\",\n              exists: \"false\",\n            },\n            then: {\n              effect: \"[parameters('effect')]\",\n            },\n          },\n          parameters: {\n            tagName: {\n              type: \"String\",\n              metadata: {\n                displayName: \"Tag Name\",\n                description: \"Name of the tag to check\",\n              },\n            },\n            effect: {\n              type: \"String\",\n              allowedValues: [\"audit\", \"deny\"],\n              defaultValue: \"audit\",\n            },\n          },\n        },\n      );\n\n      expect(policyDefinition).toBeDefined();\n      expect(policyDefinition.props.parameters).toBeDefined();\n    });\n\n    it(\"should preserve complex allOf conditions with multiple field comparisons\", () => {\n      const complexRule = {\n        if: {\n          allOf: [\n            {\n              field: \"type\",\n              equals: \"Microsoft.Storage/storageAccounts\",\n            },\n            {\n              field:\n                \"Microsoft.Storage/storageAccounts/networkAcls.defaultAction\",\n              notEquals: \"Deny\",\n            },\n          ],\n        },\n        then: {\n          effect: \"audit\",\n        },\n      };\n\n      const policyDefinition = new PolicyDefinition(stack, \"ComplexAllOf\", {\n        name: \"complex-allof-policy\",\n        displayName: \"Complex AllOf Policy\",\n        policyRule: complexRule,\n      });\n\n      expect(policyDefinition).toBeDefined();\n      expect(policyDefinition.props.policyRule).toEqual(complexRule);\n\n      // Synthesize and verify the structure is preserved\n      const synthesized = Testing.synth(stack);\n      const stackConfig = JSON.parse(synthesized);\n      const azapiResource = Object.values(\n        stackConfig.resource.azapi_resource,\n      )[0] as any;\n\n      // The body is jsonencode() wrapped, so we need to parse the actual policy rule from props\n      expect(policyDefinition.props.policyRule.if.allOf).toHaveLength(2);\n      expect(policyDefinition.props.policyRule.if.allOf[0].field).toBe(\"type\");\n      expect(policyDefinition.props.policyRule.if.allOf[0].equals).toBe(\n        \"Microsoft.Storage/storageAccounts\",\n      );\n      expect(policyDefinition.props.policyRule.if.allOf[1].field).toBe(\n        \"Microsoft.Storage/storageAccounts/networkAcls.defaultAction\",\n      );\n      expect(policyDefinition.props.policyRule.if.allOf[1].notEquals).toBe(\n        \"Deny\",\n      );\n      expect(policyDefinition.props.policyRule.then.effect).toBe(\"audit\");\n\n      // Verify the synthesized config has the body property set\n      expect(azapiResource.body).toBeDefined();\n    });\n\n    it(\"should preserve Azure Policy expressions without converting them\", () => {\n      const rule = {\n        if: {\n          field: \"location\",\n          notIn: \"[parameters('allowedLocations')]\",\n        },\n        then: {\n          effect: \"[parameters('effect')]\",\n        },\n      };\n\n      new PolicyDefinition(stack, \"AzurePolicyExpressions\", {\n        name: \"azure-expressions-policy\",\n        policyRule: rule,\n        parameters: {\n          allowedLocations: { type: \"Array\" },\n          effect: { type: \"String\" },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      const stackConfig = JSON.parse(synthesized);\n      const azapiResource = Object.values(\n        stackConfig.resource.azapi_resource,\n      )[0] as any;\n\n      // Verify Azure Policy expressions are preserved in the construct's props\n      expect(rule.if.notIn).toBe(\"[parameters('allowedLocations')]\");\n      expect(rule.then.effect).toBe(\"[parameters('effect')]\");\n\n      // Verify the synthesized config has the body property set\n      expect(azapiResource.body).toBeDefined();\n    });\n\n    it(\"should preserve DeployIfNotExists policy with ARM template\", () => {\n      const complexRule = {\n        if: {\n          field: \"type\",\n          equals: \"Microsoft.Network/virtualNetworks\",\n        },\n        then: {\n          effect: \"DeployIfNotExists\",\n          details: {\n            type: \"Microsoft.Network/networkManagers/networkGroups/staticMembers\",\n            deploymentScope: \"subscription\",\n            existenceScope: \"subscription\",\n            roleDefinitionIds: [\n              \"/providers/Microsoft.Authorization/roleDefinitions/b24988ac-6180-42a0-ab88-20f7382dd24c\",\n            ],\n            deployment: {\n              location: \"[field('location')]\",\n              properties: {\n                mode: \"incremental\",\n                resourceGroup: \"[variables('avnmResourceGroup')]\",\n                subscriptionId: \"[parameters('avnmSubscriptionId')]\",\n                template: {\n                  $schema:\n                    \"https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#\",\n                  contentVersion: \"1.0.0.0\",\n                  parameters: {\n                    vnetId: {\n                      type: \"string\",\n                    },\n                  },\n                  variables: {\n                    staticMemberName: \"[guid(parameters('vnetId'))]\",\n                  },\n                  resources: [\n                    {\n                      type: \"Microsoft.Network/networkManagers/networkGroups/staticMembers\",\n                      apiVersion: \"2023-04-01\",\n                      name: \"[concat(parameters('avnmId'), '/', variables('staticMemberName'))]\",\n                      properties: {\n                        resourceId: \"[parameters('vnetId')]\",\n                      },\n                    },\n                  ],\n                  outputs: {\n                    memberId: {\n                      type: \"string\",\n                      value:\n                        \"[resourceId('Microsoft.Network/networkManagers/networkGroups/staticMembers', variables('staticMemberName'))]\",\n                    },\n                  },\n                },\n                parameters: {\n                  vnetId: {\n                    value: \"[field('id')]\",\n                  },\n                },\n              },\n            },\n          },\n        },\n      };\n\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"DeployIfNotExistsPolicy\",\n        {\n          name: \"deploy-if-not-exists-policy\",\n          displayName: \"Deploy If Not Exists with ARM Template\",\n          policyRule: complexRule,\n          parameters: {\n            avnmSubscriptionId: { type: \"String\" },\n          },\n        },\n      );\n\n      expect(policyDefinition).toBeDefined();\n\n      const synthesized = Testing.synth(stack);\n      const stackConfig = JSON.parse(synthesized);\n      const azapiResource = Object.values(\n        stackConfig.resource.azapi_resource,\n      )[0] as any;\n\n      const details = policyDefinition.props.policyRule.then.details;\n\n      // Verify deployment structure is preserved (not converted to null)\n      expect(details.deployment).toBeDefined();\n      expect(details.deployment.location).toBe(\"[field('location')]\");\n      expect(details.deployment.properties).toBeDefined();\n      expect(details.deployment.properties.mode).toBe(\"incremental\");\n      expect(details.deployment.properties.resourceGroup).toBe(\n        \"[variables('avnmResourceGroup')]\",\n      );\n      expect(details.deployment.properties.subscriptionId).toBe(\n        \"[parameters('avnmSubscriptionId')]\",\n      );\n\n      // Verify ARM template is fully preserved (not converted to null)\n      const template = details.deployment.properties.template;\n      expect(template).toBeDefined();\n      expect(template.$schema).toBe(\n        \"https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#\",\n      );\n      expect(template.contentVersion).toBe(\"1.0.0.0\");\n      expect(template.parameters).toBeDefined();\n      expect(template.parameters.vnetId).toBeDefined();\n      expect(template.variables).toBeDefined();\n      expect(template.variables.staticMemberName).toBe(\n        \"[guid(parameters('vnetId'))]\",\n      );\n      expect(template.resources).toHaveLength(1);\n      expect(template.resources[0].name).toBe(\n        \"[concat(parameters('avnmId'), '/', variables('staticMemberName'))]\",\n      );\n      expect(template.outputs).toBeDefined();\n      expect(template.outputs.memberId.value).toBe(\n        \"[resourceId('Microsoft.Network/networkManagers/networkGroups/staticMembers', variables('staticMemberName'))]\",\n      );\n\n      // Verify ARM template parameters are preserved\n      const deploymentParams = details.deployment.properties.parameters;\n      expect(deploymentParams).toBeDefined();\n      expect(deploymentParams.vnetId.value).toBe(\"[field('id')]\");\n\n      // Verify schema validation is disabled to allow complex nested structures\n      expect(azapiResource.schema_validation_enabled).toBe(false);\n      expect(azapiResource.ignore_missing_property).toBe(true);\n\n      // Verify the synthesized config has the body property set\n      expect(azapiResource.body).toBeDefined();\n    });\n\n    it(\"should preserve deeply nested logical operators\", () => {\n      const complexRule = {\n        if: {\n          allOf: [\n            {\n              field: \"type\",\n              equals: \"Microsoft.Network/virtualNetworks\",\n            },\n            {\n              anyOf: [\n                {\n                  field:\n                    \"Microsoft.Network/virtualNetworks/enableDdosProtection\",\n                  equals: \"false\",\n                },\n                {\n                  not: {\n                    field:\n                      \"Microsoft.Network/virtualNetworks/subnets[*].serviceEndpoints[*].service\",\n                    contains: \"Microsoft.Storage\",\n                  },\n                },\n              ],\n            },\n          ],\n        },\n        then: {\n          effect: \"audit\",\n        },\n      };\n\n      const policyDefinition = new PolicyDefinition(stack, \"DeeplyNested\", {\n        name: \"deeply-nested-policy\",\n        policyRule: complexRule,\n      });\n\n      expect(policyDefinition.props.policyRule).toEqual(complexRule);\n\n      const synthesized = Testing.synth(stack);\n      const stackConfig = JSON.parse(synthesized);\n      const azapiResource = Object.values(\n        stackConfig.resource.azapi_resource,\n      )[0] as any;\n\n      // Verify the deeply nested structure is preserved in the construct's props\n      expect(\n        policyDefinition.props.policyRule.if.allOf[1].anyOf[1].not,\n      ).toBeDefined();\n      expect(\n        policyDefinition.props.policyRule.if.allOf[1].anyOf[1].not.field,\n      ).toBe(\n        \"Microsoft.Network/virtualNetworks/subnets[*].serviceEndpoints[*].service\",\n      );\n\n      // Verify the synthesized config has the body property set\n      expect(azapiResource.body).toBeDefined();\n    });\n  });\n\n  describe(\"Error Handling\", () => {\n    it(\"should handle invalid API versions gracefully\", () => {\n      expect(() => {\n        new PolicyDefinition(stack, \"InvalidAPI\", {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n          apiVersion: \"invalid-version\",\n        });\n      }).toThrow(\"Unsupported API version 'invalid-version'\");\n    });\n\n    it(\"should handle validation errors when validation is enabled\", () => {\n      expect(() => {\n        new PolicyDefinition(stack, \"ValidationError\", {\n          name: \"test-policy\",\n          policyRule: undefined as any, // Missing required policyRule\n          enableValidation: true,\n        });\n      }).toThrow(\"Required property 'policyRule' is missing\");\n    });\n\n    it(\"should handle schema registration errors gracefully\", () => {\n      expect(() => {\n        new PolicyDefinition(stack, \"SchemaTest\", {\n          name: \"test-policy\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n        });\n      }).not.toThrow();\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have JSII-compliant constructor\", () => {\n      expect(() => {\n        new PolicyDefinition(stack, \"JsiiTest\", {\n          name: \"jsii-test\",\n          policyRule: { if: {}, then: { effect: \"deny\" } },\n        });\n      }).not.toThrow();\n    });\n\n    it(\"should have JSII-compliant properties\", () => {\n      const policyDefinition = new PolicyDefinition(stack, \"JsiiProps\", {\n        name: \"jsii-props\",\n        policyRule: { if: {}, then: { effect: \"deny\" } },\n      });\n\n      expect(typeof policyDefinition.id).toBe(\"string\");\n      expect(typeof policyDefinition.name).toBe(\"string\");\n      expect(typeof policyDefinition.resolvedApiVersion).toBe(\"string\");\n      expect(typeof policyDefinition.policyType).toBe(\"string\");\n      expect(typeof policyDefinition.policyMode).toBe(\"string\");\n    });\n\n    it(\"should have JSII-compliant methods\", () => {\n      const policyDefinition = new PolicyDefinition(stack, \"JsiiMethods\", {\n        name: \"jsii-methods\",\n        policyRule: { if: {}, then: { effect: \"deny\" } },\n      });\n\n      expect(typeof policyDefinition.latestVersion).toBe(\"function\");\n      expect(typeof policyDefinition.supportedVersions).toBe(\"function\");\n    });\n\n    it(\"should serialize complex objects correctly\", () => {\n      const policyDefinition = new PolicyDefinition(\n        stack,\n        \"JsiiSerialization\",\n        {\n          name: \"jsii-serialization\",\n          policyRule: {\n            if: { field: \"location\", equals: \"eastus\" },\n            then: { effect: \"deny\" },\n          },\n          parameters: {\n            testParam: {\n              type: \"String\",\n            },\n          },\n        },\n      );\n\n      expect(() =>\n        JSON.stringify(policyDefinition.validationResult),\n      ).not.toThrow();\n      expect(() => JSON.stringify(policyDefinition.schema)).not.toThrow();\n      expect(() =>\n        JSON.stringify(policyDefinition.versionConfig),\n      ).not.toThrow();\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new PolicyDefinition(stack, \"SynthTest\", {\n        name: \"synth-test\",\n        policyRule: {\n          if: {\n            field: \"type\",\n            equals: \"Microsoft.Compute/virtualMachines\",\n          },\n          then: {\n            effect: \"audit\",\n          },\n        },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n    });\n\n    it(\"should work in complex CDK constructs\", () => {\n      class ComplexConstruct extends cdktf.TerraformStack {\n        constructor(scope: cdktf.App, id: string) {\n          super(scope, id);\n\n          const policy1 = new PolicyDefinition(this, \"Policy1\", {\n            name: \"policy-1\",\n            displayName: \"First Policy\",\n            policyRule: { if: {}, then: { effect: \"audit\" } },\n          });\n\n          const policy2 = new PolicyDefinition(this, \"Policy2\", {\n            name: \"policy-2\",\n            displayName: \"Second Policy\",\n            policyRule: { if: {}, then: { effect: \"deny\" } },\n            apiVersion: \"2021-06-01\",\n          });\n\n          new cdktf.TerraformOutput(this, \"Policy1Id\", {\n            value: policy1.id,\n          });\n\n          new cdktf.TerraformOutput(this, \"Policy2Id\", {\n            value: policy2.id,\n          });\n        }\n      }\n\n      expect(() => {\n        new ComplexConstruct(app, \"ComplexStack\");\n      }).not.toThrow();\n    });\n\n    it(\"should handle multiple policy definitions in the same stack\", () => {\n      const policy1 = new PolicyDefinition(stack, \"PolicyDefinition1\", {\n        name: \"policy-1\",\n        policyRule: { if: {}, then: { effect: \"audit\" } },\n      });\n\n      const policy2 = new PolicyDefinition(stack, \"PolicyDefinition2\", {\n        name: \"policy-2\",\n        policyRule: { if: {}, then: { effect: \"deny\" } },\n        apiVersion: \"2021-06-01\",\n      });\n\n      expect(policy1.resolvedApiVersion).toBe(\"2021-06-01\");\n      expect(policy2.resolvedApiVersion).toBe(\"2021-06-01\");\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n\n  describe(\"Policy Definition Types\", () => {\n    it(\"should support BuiltIn policy type\", () => {\n      const policyDefinition = new PolicyDefinition(stack, \"BuiltInPolicy\", {\n        name: \"builtin-policy\",\n        policyType: \"BuiltIn\",\n        policyRule: { if: {}, then: { effect: \"audit\" } },\n      });\n\n      expect(policyDefinition.policyType).toBe(\"BuiltIn\");\n    });\n\n    it(\"should support Static policy type\", () => {\n      const policyDefinition = new PolicyDefinition(stack, \"StaticPolicy\", {\n        name: \"static-policy\",\n        policyType: \"Static\",\n        policyRule: { if: {}, then: { effect: \"audit\" } },\n      });\n\n      expect(policyDefinition.policyType).toBe(\"Static\");\n    });\n\n    it(\"should support different policy modes\", () => {\n      const indexedPolicy = new PolicyDefinition(stack, \"IndexedPolicy\", {\n        name: \"indexed-policy\",\n        mode: \"Indexed\",\n        policyRule: { if: {}, then: { effect: \"audit\" } },\n      });\n\n      expect(indexedPolicy.policyMode).toBe(\"Indexed\");\n\n      const resourceProviderPolicy = new PolicyDefinition(\n        stack,\n        \"ResourceProviderPolicy\",\n        {\n          name: \"resource-provider-policy\",\n          mode: \"Microsoft.KeyVault.Data\",\n          policyRule: { if: {}, then: { effect: \"audit\" } },\n        },\n      );\n\n      expect(resourceProviderPolicy.policyMode).toBe(\"Microsoft.KeyVault.Data\");\n    });\n  });\n});\n"]}