@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.0

package/lib/azure-policyassignment/test/policy-assignment.integ.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * Integration test for Azure Policy Assignment
+ *
+ * This test demonstrates basic usage of the PolicyAssignment construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Note: This test requires a policy definition to exist before assigning it.
+ * It creates a simple policy definition first, then creates assignments
+ * that reference it.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const azure_policydefinition_1 = require("../../azure-policydefinition");
+const data_azapi_client_config_1 = require("../../core-azure/lib/azapi/providers-azapi/data-azapi-client-config");
+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_assignment_1 = require("../lib/policy-assignment");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("policy-assignment-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating Policy Assignment usage
+ */
+class PolicyAssignmentExampleStack 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", {});
+        // Get the current subscription ID from Azure
+        const clientConfig = new data_azapi_client_config_1.DataAzapiClientConfig(this, "client_config_default");
+        // Generate unique names
+        const policyDefinitionName = this.generateResourceName("Microsoft.Authorization/policyDefinitions", "testpolicy");
+        const basicAssignmentName = this.generateResourceName("Microsoft.Authorization/policyAssignments", "basic");
+        const advancedAssignmentName = this.generateResourceName("Microsoft.Authorization/policyAssignments", "advanced");
+        // First, create a policy definition to assign
+        const policyDefinition = new azure_policydefinition_1.PolicyDefinition(this, "test-policy", {
+            name: policyDefinitionName,
+            displayName: "Test Policy for Assignment",
+            description: "A simple test policy used to validate policy assignments",
+            policyType: "Custom",
+            mode: "Indexed",
+            policyRule: {
+                if: {
+                    field: "[concat('tags[''', parameters('tagName'), ''']')]",
+                    exists: "false",
+                },
+                then: {
+                    effect: "audit",
+                },
+            },
+            parameters: {
+                tagName: {
+                    type: "String",
+                    metadata: {
+                        displayName: "Tag Name",
+                        description: "Name of the tag to check",
+                    },
+                    defaultValue: "TestTag",
+                },
+            },
+            metadata: {
+                category: "Testing",
+                version: "1.0.0",
+            },
+            tags: {
+                ...this.systemTags(),
+                purpose: "integration-test",
+            },
+        });
+        // Use the actual subscription ID from the client config data source
+        const subscriptionScope = `/subscriptions/${clientConfig.subscriptionId}`;
+        // Example 1: Basic policy assignment at subscription scope
+        // Add explicit dependsOn for proper destroy ordering
+        new policy_assignment_1.PolicyAssignment(this, "basic-assignment", {
+            name: basicAssignmentName,
+            displayName: "Basic Policy Assignment",
+            description: "A basic policy assignment for testing",
+            policyDefinitionId: policyDefinition.id,
+            scope: subscriptionScope,
+            enforcementMode: "Default",
+            tags: {
+                ...this.systemTags(),
+                example: "basic",
+            },
+            // IMPORTANT: Add explicit dependency on policy definition to ensure:
+            // 1. Policy definition is created before assignment (apply)
+            // 2. Policy assignment is destroyed before definition (destroy)
+            // Azure RBAC/Policy has eventual consistency - explicit deps help ordering
+            dependsOn: [policyDefinition.resource],
+        });
+        // Example 2: Advanced policy assignment with parameters, identity, and non-compliance messages
+        // Add explicit dependsOn for proper destroy ordering
+        new policy_assignment_1.PolicyAssignment(this, "advanced-assignment", {
+            name: advancedAssignmentName,
+            location: "eastus", // Required when identity is specified
+            displayName: "Advanced Policy Assignment",
+            description: "An advanced policy assignment with parameters and identity",
+            policyDefinitionId: policyDefinition.id,
+            scope: subscriptionScope,
+            enforcementMode: "DoNotEnforce", // Audit mode
+            parameters: {
+                tagName: {
+                    value: "Environment",
+                },
+            },
+            metadata: {
+                assignedBy: "integration-test",
+                assignmentDate: new Date().toISOString(),
+            },
+            identity: {
+                type: "SystemAssigned",
+            },
+            nonComplianceMessages: [
+                {
+                    message: "Resources must have the required tag. This is a test policy assignment.",
+                },
+            ],
+            tags: {
+                ...this.systemTags(),
+                example: "advanced",
+            },
+            // IMPORTANT: Add explicit dependency on policy definition to ensure:
+            // 1. Policy definition is created before assignment (apply)
+            // 2. Policy assignment is destroyed before definition (destroy)
+            dependsOn: [policyDefinition.resource],
+        });
+    }
+}
+describe("Policy Assignment Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup policy assignment resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new PolicyAssignmentExampleStack(app, "test-policy-assignment");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources (policy definition and assignments)
+        // 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-assignment.integ.js","sourceRoot":"","sources":["../../../src/azure-policyassignment/test/policy-assignment.integ.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Integration test for Azure Policy Assignment\n *\n * This test demonstrates basic usage of the PolicyAssignment construct\n * and validates deployment, idempotency, and cleanup.\n *\n * Note: This test requires a policy definition to exist before assigning it.\n * It creates a simple policy definition first, then creates assignments\n * that reference it.\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 { PolicyDefinition } from \"../../azure-policydefinition\";\nimport { DataAzapiClientConfig } from \"../../core-azure/lib/azapi/providers-azapi/data-azapi-client-config\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { PolicyAssignment } from \"../lib/policy-assignment\";\n\n// Generate unique test run metadata for this test suite\nconst testMetadata = new TestRunMetadata(\"policy-assignment-integration\", {\n  maxAgeHours: 4,\n});\n\n/**\n * Example stack demonstrating Policy Assignment usage\n */\nclass PolicyAssignmentExampleStack 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    // Get the current subscription ID from Azure\n    const clientConfig = new DataAzapiClientConfig(\n      this,\n      \"client_config_default\",\n    );\n\n    // Generate unique names\n    const policyDefinitionName = this.generateResourceName(\n      \"Microsoft.Authorization/policyDefinitions\",\n      \"testpolicy\",\n    );\n    const basicAssignmentName = this.generateResourceName(\n      \"Microsoft.Authorization/policyAssignments\",\n      \"basic\",\n    );\n    const advancedAssignmentName = this.generateResourceName(\n      \"Microsoft.Authorization/policyAssignments\",\n      \"advanced\",\n    );\n\n    // First, create a policy definition to assign\n    const policyDefinition = new PolicyDefinition(this, \"test-policy\", {\n      name: policyDefinitionName,\n      displayName: \"Test Policy for Assignment\",\n      description: \"A simple test policy used to validate policy assignments\",\n      policyType: \"Custom\",\n      mode: \"Indexed\",\n      policyRule: {\n        if: {\n          field: \"[concat('tags[''', parameters('tagName'), ''']')]\",\n          exists: \"false\",\n        },\n        then: {\n          effect: \"audit\",\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: \"TestTag\",\n        },\n      },\n      metadata: {\n        category: \"Testing\",\n        version: \"1.0.0\",\n      },\n      tags: {\n        ...this.systemTags(),\n        purpose: \"integration-test\",\n      },\n    });\n\n    // Use the actual subscription ID from the client config data source\n    const subscriptionScope = `/subscriptions/${clientConfig.subscriptionId}`;\n\n    // Example 1: Basic policy assignment at subscription scope\n    // Add explicit dependsOn for proper destroy ordering\n    new PolicyAssignment(this, \"basic-assignment\", {\n      name: basicAssignmentName,\n      displayName: \"Basic Policy Assignment\",\n      description: \"A basic policy assignment for testing\",\n      policyDefinitionId: policyDefinition.id,\n      scope: subscriptionScope,\n      enforcementMode: \"Default\",\n      tags: {\n        ...this.systemTags(),\n        example: \"basic\",\n      },\n      // IMPORTANT: Add explicit dependency on policy definition to ensure:\n      // 1. Policy definition is created before assignment (apply)\n      // 2. Policy assignment is destroyed before definition (destroy)\n      // Azure RBAC/Policy has eventual consistency - explicit deps help ordering\n      dependsOn: [policyDefinition.resource],\n    });\n\n    // Example 2: Advanced policy assignment with parameters, identity, and non-compliance messages\n    // Add explicit dependsOn for proper destroy ordering\n    new PolicyAssignment(this, \"advanced-assignment\", {\n      name: advancedAssignmentName,\n      location: \"eastus\", // Required when identity is specified\n      displayName: \"Advanced Policy Assignment\",\n      description: \"An advanced policy assignment with parameters and identity\",\n      policyDefinitionId: policyDefinition.id,\n      scope: subscriptionScope,\n      enforcementMode: \"DoNotEnforce\", // Audit mode\n      parameters: {\n        tagName: {\n          value: \"Environment\",\n        },\n      },\n      metadata: {\n        assignedBy: \"integration-test\",\n        assignmentDate: new Date().toISOString(),\n      },\n      identity: {\n        type: \"SystemAssigned\",\n      },\n      nonComplianceMessages: [\n        {\n          message:\n            \"Resources must have the required tag. This is a test policy assignment.\",\n        },\n      ],\n      tags: {\n        ...this.systemTags(),\n        example: \"advanced\",\n      },\n      // IMPORTANT: Add explicit dependency on policy definition to ensure:\n      // 1. Policy definition is created before assignment (apply)\n      // 2. Policy assignment is destroyed before definition (destroy)\n      dependsOn: [policyDefinition.resource],\n    });\n  }\n}\n\ndescribe(\"Policy Assignment Integration Test\", () => {\n  it(\"should deploy, validate idempotency, and cleanup policy assignment resources\", () => {\n    const app = Testing.app();\n    const stack = new PolicyAssignmentExampleStack(\n      app,\n      \"test-policy-assignment\",\n    );\n    const synthesized = Testing.fullSynth(stack);\n\n    // This will:\n    // 1. Run terraform apply to deploy resources (policy definition and assignments)\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-policyassignment/test/policy-assignment.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Comprehensive tests for the unified PolicyAssignment implementation
+ *
+ * This test suite validates the unified PolicyAssignment class that uses
+ * the VersionedAzapiResource framework. Tests cover automatic version resolution,
+ * explicit version pinning, schema validation, property transformation, and
+ * policy assignment-specific functionality.
+ */
+export {};