@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.1

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

@@ -0,0 +1,236 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyDefinition = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+/**
+ * Unified Azure Policy Definition implementation using VersionedAzapiResource framework
+ *
+ * This class provides a version-aware implementation for managing Azure Policy Definitions
+ * using the AZAPI provider. Policy definitions are deployed at subscription or management
+ * group scope and define the rules and parameters for policy enforcement.
+ *
+ * Supported API Versions:
+ * - 2021-06-01 (Active, Latest)
+ *
+ * Features:
+ * - Automatic latest version resolution when no version is specified
+ * - Explicit version pinning for stability requirements
+ * - Schema-driven validation and transformation
+ * - Support for custom policy rules and parameters
+ * - JSII compliance for multi-language support
+ */
+const cdktf = require("cdktf");
+const policy_definition_schemas_1 = require("./policy-definition-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+/**
+ * Unified Azure Policy Definition implementation
+ *
+ * This class provides a single, version-aware implementation for managing Azure
+ * Policy Definitions. It automatically handles version resolution, schema validation,
+ * and property transformation.
+ *
+ * Note: Policy definitions are deployed at subscription or management group scope.
+ * Unlike most Azure resources, they do not have a location property as they are
+ * not region-specific.
+ *
+ * @example
+ * // Basic custom policy definition:
+ * const policyDefinition = new PolicyDefinition(this, "policy", {
+ *   name: "require-tag-policy",
+ *   displayName: "Require tag on resources",
+ *   description: "Enforces a required tag on resources",
+ *   policyRule: {
+ *     if: {
+ *       field: "tags['Environment']",
+ *       exists: "false"
+ *     },
+ *     then: {
+ *       effect: "deny"
+ *     }
+ *   }
+ * });
+ *
+ * @example
+ * // Policy definition with parameters:
+ * const policyDefinition = new PolicyDefinition(this, "policy", {
+ *   name: "require-tag-policy",
+ *   displayName: "Require tag on resources",
+ *   policyRule: {
+ *     if: {
+ *       field: "[concat('tags[', parameters('tagName'), ']')]",
+ *       exists: "false"
+ *     },
+ *     then: {
+ *       effect: "deny"
+ *     }
+ *   },
+ *   parameters: {
+ *     tagName: {
+ *       type: "String",
+ *       metadata: {
+ *         displayName: "Tag Name"
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * @stability stable
+ */
+class PolicyDefinition extends azapi_resource_1.AzapiResource {
+    // Public properties
+    /**
+     * Creates a new Azure Policy Definition using the VersionedAzapiResource framework
+     *
+     * The constructor automatically handles version resolution, schema registration,
+     * validation, and resource creation.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The unique identifier for this instance
+     * @param props - Configuration properties for the Policy Definition
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        // Extract properties from the AZAPI resource outputs using Terraform interpolation
+        // Create Terraform outputs for easy access and referencing from other resources
+        this.idOutput = new cdktf.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Policy Definition",
+        });
+        this.nameOutput = new cdktf.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Policy Definition",
+        });
+        // Override logical IDs to match original naming convention
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+        // Apply ignore changes if specified
+        this._applyIgnoreChanges();
+    }
+    // =============================================================================
+    // REQUIRED ABSTRACT METHODS FROM AzapiResource
+    // =============================================================================
+    /**
+     * Gets the default API version to use when no explicit version is specified
+     * Returns the most recent stable version as the default
+     */
+    defaultVersion() {
+        return "2021-06-01";
+    }
+    /**
+     * Gets the Azure resource type for Policy Definitions
+     */
+    resourceType() {
+        return policy_definition_schemas_1.POLICY_DEFINITION_TYPE;
+    }
+    /**
+     * Gets the API schema for the resolved version
+     * Uses the framework's schema resolution to get the appropriate schema
+     */
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    /**
+     * Creates the resource body for the Azure API call
+     * Transforms the input properties into the JSON format expected by Azure REST API
+     *
+     * Note: Policy definitions do not have a location property as they are
+     * subscription or management group scoped resources.
+     */
+    createResourceBody(props) {
+        const typedProps = props;
+        return {
+            properties: {
+                displayName: typedProps.displayName,
+                description: typedProps.description,
+                policyType: typedProps.policyType || "Custom",
+                mode: typedProps.mode || "All",
+                // Deep clone policyRule to preserve all nested objects and Azure Policy expressions
+                // This ensures complex DeployIfNotExists policies with ARM templates are fully serialized
+                // Azure Policy expressions like [field()], [parameters()], [variables()] are preserved
+                policyRule: JSON.parse(JSON.stringify(typedProps.policyRule)),
+                parameters: typedProps.parameters,
+                metadata: typedProps.metadata,
+            },
+        };
+    }
+    /**
+     * Policy Definitions do not support tags at the resource level
+     * Tags are not a valid property for Microsoft.Authorization/policyDefinitions
+     * @returns false - Policy Definitions cannot have tags
+     * @override
+     */
+    supportsTags() {
+        return false;
+    }
+    /**
+     * Customizes the AZAPI ResourceConfig for policy-specific requirements
+     *
+     * Policy definitions require special handling because:
+     * 1. They contain complex nested objects (ARM templates in DeployIfNotExists policies)
+     * 2. They use Azure Policy expressions like [field()], [parameters()], [variables()]
+     *    which are NOT Terraform interpolations but Azure-native expressions
+     * 3. Schema validation may strip unknown properties from deeply nested structures
+     *
+     * @param config - The base ResourceConfig
+     * @returns Modified ResourceConfig with policy-specific settings
+     * @override
+     */
+    customizeResourceConfig(config) {
+        return {
+            ...config,
+            // Disable schema validation to preserve all nested properties
+            // Azure Policy definitions can contain deeply nested ARM templates and expressions
+            // that the AZAPI provider's schema validation may not recognize
+            schemaValidationEnabled: false,
+            // Allow properties not in the schema to prevent stripping of nested content
+            // This is essential for DeployIfNotExists policies with ARM template deployments
+            ignoreMissingProperty: true,
+        };
+    }
+    // =============================================================================
+    // PUBLIC METHODS FOR POLICY DEFINITION OPERATIONS
+    // =============================================================================
+    /**
+     * Get the full resource identifier for use in other Azure resources
+     * Alias for the id property
+     */
+    get resourceId() {
+        return this.id;
+    }
+    /**
+     * Get the policy type
+     */
+    get policyType() {
+        return this.props.policyType || "Custom";
+    }
+    /**
+     * Get the policy mode
+     */
+    get policyMode() {
+        return this.props.mode || "All";
+    }
+    // =============================================================================
+    // PRIVATE HELPER METHODS
+    // =============================================================================
+    /**
+     * Applies ignore changes lifecycle rules if specified in props
+     */
+    _applyIgnoreChanges() {
+        if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {
+            this.terraformResource.addOverride("lifecycle", [
+                {
+                    ignore_changes: this.props.ignoreChanges,
+                },
+            ]);
+        }
+    }
+}
+exports.PolicyDefinition = PolicyDefinition;
+_a = JSII_RTTI_SYMBOL_1;
+PolicyDefinition[_a] = { fqn: "@microsoft/terraform-cdk-constructs.PolicyDefinition", version: "1.3.1" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(policy_definition_schemas_1.POLICY_DEFINITION_TYPE, policy_definition_schemas_1.ALL_POLICY_DEFINITION_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-definition.js","sourceRoot":"","sources":["../../../src/azure-policydefinition/lib/policy-definition.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unified Azure Policy Definition implementation using VersionedAzapiResource framework\n *\n * This class provides a version-aware implementation for managing Azure Policy Definitions\n * using the AZAPI provider. Policy definitions are deployed at subscription or management\n * group scope and define the rules and parameters for policy enforcement.\n *\n * Supported API Versions:\n * - 2021-06-01 (Active, Latest)\n *\n * Features:\n * - Automatic latest version resolution when no version is specified\n * - Explicit version pinning for stability requirements\n * - Schema-driven validation and transformation\n * - Support for custom policy rules and parameters\n * - JSII compliance for multi-language support\n */\n\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  ALL_POLICY_DEFINITION_VERSIONS,\n  POLICY_DEFINITION_TYPE,\n} from \"./policy-definition-schemas\";\nimport {\n  AzapiResource,\n  AzapiResourceProps,\n} from \"../../core-azure/lib/azapi/azapi-resource\";\nimport { ApiSchema } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\n/**\n * Properties for the unified Azure Policy Definition\n *\n * Extends AzapiResourceProps with Policy Definition specific properties\n */\nexport interface PolicyDefinitionProps extends AzapiResourceProps {\n  /**\n   * The display name of the policy definition\n   * Provides a human-readable name for the policy\n   *\n   * @example \"Require tag and its value on resources\"\n   */\n  readonly displayName?: string;\n\n  /**\n   * The policy definition description\n   * Provides detailed information about what the policy enforces\n   *\n   * @example \"Enforces a required tag and its value on resources\"\n   */\n  readonly description?: string;\n\n  /**\n   * The type of policy definition\n   * @default \"Custom\"\n   * @example \"Custom\", \"BuiltIn\", \"Static\", \"NotSpecified\"\n   */\n  readonly policyType?: string;\n\n  /**\n   * The policy mode\n   * Determines which resource types will be evaluated\n   * @default \"All\"\n   * @example \"All\", \"Indexed\", \"Microsoft.KeyVault.Data\"\n   */\n  readonly mode?: string;\n\n  /**\n   * The policy rule as a JSON object\n   * Defines the if/then logic that determines policy enforcement\n   * This is required for all policy definitions\n   *\n   * @example\n   * {\n   *   if: {\n   *     field: \"tags['Environment']\",\n   *     exists: \"false\"\n   *   },\n   *   then: {\n   *     effect: \"deny\"\n   *   }\n   * }\n   */\n  readonly policyRule: any;\n\n  /**\n   * Parameters for the policy definition\n   * Allows policy assignments to provide values that are used in the policy rule\n   *\n   * @example\n   * {\n   *   tagName: {\n   *     type: \"String\",\n   *     metadata: {\n   *       displayName: \"Tag Name\",\n   *       description: \"Name of the tag to enforce\"\n   *     }\n   *   }\n   * }\n   */\n  readonly parameters?: any;\n\n  /**\n   * Metadata for the policy definition\n   * Used to store additional information like category, version, etc.\n   *\n   * @example\n   * {\n   *   category: \"Tags\",\n   *   version: \"1.0.0\"\n   * }\n   */\n  readonly metadata?: any;\n\n  /**\n   * The lifecycle rules to ignore changes\n   * @example [\"metadata\"]\n   */\n  readonly ignoreChanges?: string[];\n}\n\n/**\n * Properties interface for Azure Policy Definition\n * This is required for JSII compliance to support multi-language code generation\n */\nexport interface PolicyDefinitionProperties {\n  /**\n   * The display name of the policy definition\n   */\n  readonly displayName?: string;\n\n  /**\n   * The policy definition description\n   */\n  readonly description?: string;\n\n  /**\n   * The type of policy definition\n   */\n  readonly policyType?: string;\n\n  /**\n   * The policy mode\n   */\n  readonly mode?: string;\n\n  /**\n   * The policy rule object\n   */\n  readonly policyRule: any;\n\n  /**\n   * Parameters for the policy definition\n   */\n  readonly parameters?: any;\n\n  /**\n   * Metadata for the policy definition\n   */\n  readonly metadata?: any;\n}\n\n/**\n * The resource body interface for Azure Policy Definition API calls\n * This matches the Azure REST API schema for policy definitions\n */\nexport interface PolicyDefinitionBody {\n  /**\n   * The properties of the policy definition\n   */\n  readonly properties: PolicyDefinitionProperties;\n}\n\n/**\n * Unified Azure Policy Definition implementation\n *\n * This class provides a single, version-aware implementation for managing Azure\n * Policy Definitions. It automatically handles version resolution, schema validation,\n * and property transformation.\n *\n * Note: Policy definitions are deployed at subscription or management group scope.\n * Unlike most Azure resources, they do not have a location property as they are\n * not region-specific.\n *\n * @example\n * // Basic custom policy definition:\n * const policyDefinition = new PolicyDefinition(this, \"policy\", {\n *   name: \"require-tag-policy\",\n *   displayName: \"Require tag on resources\",\n *   description: \"Enforces a required tag on resources\",\n *   policyRule: {\n *     if: {\n *       field: \"tags['Environment']\",\n *       exists: \"false\"\n *     },\n *     then: {\n *       effect: \"deny\"\n *     }\n *   }\n * });\n *\n * @example\n * // Policy definition with parameters:\n * const policyDefinition = new PolicyDefinition(this, \"policy\", {\n *   name: \"require-tag-policy\",\n *   displayName: \"Require tag on resources\",\n *   policyRule: {\n *     if: {\n *       field: \"[concat('tags[', parameters('tagName'), ']')]\",\n *       exists: \"false\"\n *     },\n *     then: {\n *       effect: \"deny\"\n *     }\n *   },\n *   parameters: {\n *     tagName: {\n *       type: \"String\",\n *       metadata: {\n *         displayName: \"Tag Name\"\n *       }\n *     }\n *   }\n * });\n *\n * @stability stable\n */\nexport class PolicyDefinition extends AzapiResource {\n  static {\n    AzapiResource.registerSchemas(\n      POLICY_DEFINITION_TYPE,\n      ALL_POLICY_DEFINITION_VERSIONS,\n    );\n  }\n\n  /**\n   * The input properties for this Policy Definition instance\n   */\n  public readonly props: PolicyDefinitionProps;\n\n  // Output properties for easy access and referencing\n  public readonly idOutput: cdktf.TerraformOutput;\n  public readonly nameOutput: cdktf.TerraformOutput;\n\n  // Public properties\n\n  /**\n   * Creates a new Azure Policy Definition using the VersionedAzapiResource framework\n   *\n   * The constructor automatically handles version resolution, schema registration,\n   * validation, and resource creation.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The unique identifier for this instance\n   * @param props - Configuration properties for the Policy Definition\n   */\n  constructor(scope: Construct, id: string, props: PolicyDefinitionProps) {\n    super(scope, id, props);\n\n    this.props = props;\n\n    // Extract properties from the AZAPI resource outputs using Terraform interpolation\n\n    // Create Terraform outputs for easy access and referencing from other resources\n    this.idOutput = new cdktf.TerraformOutput(this, \"id\", {\n      value: this.id,\n      description: \"The ID of the Policy Definition\",\n    });\n\n    this.nameOutput = new cdktf.TerraformOutput(this, \"name\", {\n      value: `\\${${this.terraformResource.fqn}.name}`,\n      description: \"The name of the Policy Definition\",\n    });\n\n    // Override logical IDs to match original naming convention\n    this.idOutput.overrideLogicalId(\"id\");\n    this.nameOutput.overrideLogicalId(\"name\");\n\n    // Apply ignore changes if specified\n    this._applyIgnoreChanges();\n  }\n\n  // =============================================================================\n  // REQUIRED ABSTRACT METHODS FROM AzapiResource\n  // =============================================================================\n\n  /**\n   * Gets the default API version to use when no explicit version is specified\n   * Returns the most recent stable version as the default\n   */\n  protected defaultVersion(): string {\n    return \"2021-06-01\";\n  }\n\n  /**\n   * Gets the Azure resource type for Policy Definitions\n   */\n  protected resourceType(): string {\n    return POLICY_DEFINITION_TYPE;\n  }\n\n  /**\n   * Gets the API schema for the resolved version\n   * Uses the framework's schema resolution to get the appropriate schema\n   */\n  protected apiSchema(): ApiSchema {\n    return this.resolveSchema();\n  }\n\n  /**\n   * Creates the resource body for the Azure API call\n   * Transforms the input properties into the JSON format expected by Azure REST API\n   *\n   * Note: Policy definitions do not have a location property as they are\n   * subscription or management group scoped resources.\n   */\n  protected createResourceBody(props: any): any {\n    const typedProps = props as PolicyDefinitionProps;\n    return {\n      properties: {\n        displayName: typedProps.displayName,\n        description: typedProps.description,\n        policyType: typedProps.policyType || \"Custom\",\n        mode: typedProps.mode || \"All\",\n        // Deep clone policyRule to preserve all nested objects and Azure Policy expressions\n        // This ensures complex DeployIfNotExists policies with ARM templates are fully serialized\n        // Azure Policy expressions like [field()], [parameters()], [variables()] are preserved\n        policyRule: JSON.parse(JSON.stringify(typedProps.policyRule)),\n        parameters: typedProps.parameters,\n        metadata: typedProps.metadata,\n      },\n    };\n  }\n\n  /**\n   * Policy Definitions do not support tags at the resource level\n   * Tags are not a valid property for Microsoft.Authorization/policyDefinitions\n   * @returns false - Policy Definitions cannot have tags\n   * @override\n   */\n  protected supportsTags(): boolean {\n    return false;\n  }\n\n  /**\n   * Customizes the AZAPI ResourceConfig for policy-specific requirements\n   *\n   * Policy definitions require special handling because:\n   * 1. They contain complex nested objects (ARM templates in DeployIfNotExists policies)\n   * 2. They use Azure Policy expressions like [field()], [parameters()], [variables()]\n   *    which are NOT Terraform interpolations but Azure-native expressions\n   * 3. Schema validation may strip unknown properties from deeply nested structures\n   *\n   * @param config - The base ResourceConfig\n   * @returns Modified ResourceConfig with policy-specific settings\n   * @override\n   */\n  protected customizeResourceConfig(config: any): any {\n    return {\n      ...config,\n      // Disable schema validation to preserve all nested properties\n      // Azure Policy definitions can contain deeply nested ARM templates and expressions\n      // that the AZAPI provider's schema validation may not recognize\n      schemaValidationEnabled: false,\n      // Allow properties not in the schema to prevent stripping of nested content\n      // This is essential for DeployIfNotExists policies with ARM template deployments\n      ignoreMissingProperty: true,\n    };\n  }\n\n  // =============================================================================\n  // PUBLIC METHODS FOR POLICY DEFINITION OPERATIONS\n  // =============================================================================\n\n  /**\n   * Get the full resource identifier for use in other Azure resources\n   * Alias for the id property\n   */\n  public get resourceId(): string {\n    return this.id;\n  }\n\n  /**\n   * Get the policy type\n   */\n  public get policyType(): string {\n    return this.props.policyType || \"Custom\";\n  }\n\n  /**\n   * Get the policy mode\n   */\n  public get policyMode(): string {\n    return this.props.mode || \"All\";\n  }\n\n  // =============================================================================\n  // PRIVATE HELPER METHODS\n  // =============================================================================\n\n  /**\n   * Applies ignore changes lifecycle rules if specified in props\n   */\n  private _applyIgnoreChanges(): void {\n    if (this.props.ignoreChanges && this.props.ignoreChanges.length > 0) {\n      this.terraformResource.addOverride(\"lifecycle\", [\n        {\n          ignore_changes: this.props.ignoreChanges,\n        },\n      ]);\n    }\n  }\n}\n"]}

package/lib/azure-policydefinition/test/policy-definition.integ.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Integration test for Azure Policy Definition
+ *
+ * This test demonstrates basic usage of the PolicyDefinition construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+import "cdktf/lib/testing/adapters/jest";

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

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * Integration test for Azure Policy Definition
+ *
+ * This test demonstrates basic usage of the PolicyDefinition construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const metadata_1 = require("../../testing/lib/metadata");
+const policy_definition_1 = require("../lib/policy-definition");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("policy-definition-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating Policy Definition usage
+ */
+class PolicyDefinitionExampleStack extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id, {
+            testRunOptions: {
+                maxAgeHours: testMetadata.maxAgeHours,
+                autoCleanup: testMetadata.autoCleanup,
+                cleanupPolicy: testMetadata.cleanupPolicy,
+            },
+        });
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Generate unique names for policy definitions
+        const basicPolicyName = this.generateResourceName("Microsoft.Authorization/policyDefinitions", "basic");
+        const parameterizedPolicyName = this.generateResourceName("Microsoft.Authorization/policyDefinitions", "param");
+        // Example 1: Basic policy definition that denies resources without required tags
+        new policy_definition_1.PolicyDefinition(this, "basic-policy", {
+            name: basicPolicyName,
+            displayName: "Require Environment Tag",
+            description: "This policy ensures that resources have an Environment tag",
+            policyType: "Custom",
+            mode: "Indexed",
+            policyRule: {
+                if: {
+                    field: "tags['Environment']",
+                    exists: "false",
+                },
+                then: {
+                    effect: "deny",
+                },
+            },
+            metadata: {
+                category: "Tags",
+                version: "1.0.0",
+            },
+            tags: {
+                ...this.systemTags(),
+                example: "basic",
+            },
+        });
+        // Example 2: Policy definition with parameters for flexible enforcement
+        new policy_definition_1.PolicyDefinition(this, "parameterized-policy", {
+            name: parameterizedPolicyName,
+            displayName: "Require Specific Tag with Allowed Values",
+            description: "This policy ensures that resources have a specific tag with a value from an allowed list",
+            policyType: "Custom",
+            mode: "All",
+            policyRule: {
+                if: {
+                    allOf: [
+                        {
+                            field: "[concat('tags[', parameters('tagName'), ']')]",
+                            exists: "true",
+                        },
+                        {
+                            field: "[concat('tags[', parameters('tagName'), ']')]",
+                            notIn: "[parameters('allowedValues')]",
+                        },
+                    ],
+                },
+                then: {
+                    effect: "[parameters('effect')]",
+                },
+            },
+            parameters: {
+                tagName: {
+                    type: "String",
+                    metadata: {
+                        displayName: "Tag Name",
+                        description: "Name of the tag to check",
+                    },
+                    defaultValue: "CostCenter",
+                },
+                allowedValues: {
+                    type: "Array",
+                    metadata: {
+                        displayName: "Allowed Tag Values",
+                        description: "List of allowed values for the tag",
+                    },
+                    defaultValue: ["Engineering", "Marketing", "Operations"],
+                },
+                effect: {
+                    type: "String",
+                    metadata: {
+                        displayName: "Effect",
+                        description: "The effect of the policy (audit or deny)",
+                    },
+                    allowedValues: ["audit", "deny"],
+                    defaultValue: "audit",
+                },
+            },
+            metadata: {
+                category: "Tags",
+                version: "1.0.0",
+            },
+            tags: {
+                ...this.systemTags(),
+                example: "parameterized",
+            },
+        });
+    }
+}
+describe("Policy Definition Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup policy definition resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new PolicyDefinitionExampleStack(app, "test-policy-definition");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
+    }, 600000); // 10 minute timeout for deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-definition.integ.js","sourceRoot":"","sources":["../../../src/azure-policydefinition/test/policy-definition.integ.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Integration test for Azure Policy Definition\n *\n * This test demonstrates basic usage of the PolicyDefinition construct\n * and validates deployment, idempotency, and cleanup.\n *\n * Run with: npm run integration:nostream\n */\n\nimport { Testing } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport \"cdktf/lib/testing/adapters/jest\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { PolicyDefinition } from \"../lib/policy-definition\";\n\n// Generate unique test run metadata for this test suite\nconst testMetadata = new TestRunMetadata(\"policy-definition-integration\", {\n  maxAgeHours: 4,\n});\n\n/**\n * Example stack demonstrating Policy Definition usage\n */\nclass PolicyDefinitionExampleStack extends BaseTestStack {\n  constructor(scope: Construct, id: string) {\n    super(scope, id, {\n      testRunOptions: {\n        maxAgeHours: testMetadata.maxAgeHours,\n        autoCleanup: testMetadata.autoCleanup,\n        cleanupPolicy: testMetadata.cleanupPolicy,\n      },\n    });\n\n    // Configure AZAPI provider\n    new AzapiProvider(this, \"azapi\", {});\n\n    // Generate unique names for policy definitions\n    const basicPolicyName = this.generateResourceName(\n      \"Microsoft.Authorization/policyDefinitions\",\n      \"basic\",\n    );\n    const parameterizedPolicyName = this.generateResourceName(\n      \"Microsoft.Authorization/policyDefinitions\",\n      \"param\",\n    );\n\n    // Example 1: Basic policy definition that denies resources without required tags\n    new PolicyDefinition(this, \"basic-policy\", {\n      name: basicPolicyName,\n      displayName: \"Require Environment Tag\",\n      description: \"This policy ensures that resources have an Environment tag\",\n      policyType: \"Custom\",\n      mode: \"Indexed\",\n      policyRule: {\n        if: {\n          field: \"tags['Environment']\",\n          exists: \"false\",\n        },\n        then: {\n          effect: \"deny\",\n        },\n      },\n      metadata: {\n        category: \"Tags\",\n        version: \"1.0.0\",\n      },\n      tags: {\n        ...this.systemTags(),\n        example: \"basic\",\n      },\n    });\n\n    // Example 2: Policy definition with parameters for flexible enforcement\n    new PolicyDefinition(this, \"parameterized-policy\", {\n      name: parameterizedPolicyName,\n      displayName: \"Require Specific Tag with Allowed Values\",\n      description:\n        \"This policy ensures that resources have a specific tag with a value from an allowed list\",\n      policyType: \"Custom\",\n      mode: \"All\",\n      policyRule: {\n        if: {\n          allOf: [\n            {\n              field: \"[concat('tags[', parameters('tagName'), ']')]\",\n              exists: \"true\",\n            },\n            {\n              field: \"[concat('tags[', parameters('tagName'), ']')]\",\n              notIn: \"[parameters('allowedValues')]\",\n            },\n          ],\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          defaultValue: \"CostCenter\",\n        },\n        allowedValues: {\n          type: \"Array\",\n          metadata: {\n            displayName: \"Allowed Tag Values\",\n            description: \"List of allowed values for the tag\",\n          },\n          defaultValue: [\"Engineering\", \"Marketing\", \"Operations\"],\n        },\n        effect: {\n          type: \"String\",\n          metadata: {\n            displayName: \"Effect\",\n            description: \"The effect of the policy (audit or deny)\",\n          },\n          allowedValues: [\"audit\", \"deny\"],\n          defaultValue: \"audit\",\n        },\n      },\n      metadata: {\n        category: \"Tags\",\n        version: \"1.0.0\",\n      },\n      tags: {\n        ...this.systemTags(),\n        example: \"parameterized\",\n      },\n    });\n  }\n}\n\ndescribe(\"Policy Definition Integration Test\", () => {\n  it(\"should deploy, validate idempotency, and cleanup policy definition resources\", () => {\n    const app = Testing.app();\n    const stack = new PolicyDefinitionExampleStack(\n      app,\n      \"test-policy-definition\",\n    );\n    const synthesized = Testing.fullSynth(stack);\n\n    // This will:\n    // 1. Run terraform apply to deploy resources\n    // 2. Run terraform plan to check idempotency (no changes expected)\n    // 3. Run terraform destroy to cleanup resources\n    TerraformApplyCheckAndDestroy(synthesized, { verifyCleanup: true });\n  }, 600000); // 10 minute timeout for deployment and cleanup\n});\n"]}

package/lib/azure-policydefinition/test/policy-definition.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+export {};