@microsoft/terraform-cdk-constructs 1.2.0 → 1.3.0

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

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Tests for the AzapiResource tag management functionality
+ *
+ * These tests verify that the immutability pattern for tags works correctly:
+ * - Tags from props are stored separately from the readonly props
+ * - Tags added via addTag() are combined with props tags
+ * - The tags getter returns all tags (props + added)
+ * - The allTags() method used in createResourceBody includes all tags
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+const cdktf = require("cdktf");
+const resource_group_1 = require("../../../azure-resourcegroup/lib/resource-group");
+describe("AzapiResource - Tag Management", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktf_1.Testing.app();
+        stack = new cdktf.TerraformStack(app, "TestStack");
+    });
+    describe("Tag Immutability", () => {
+        it("should store tags separately from readonly props", () => {
+            const props = {
+                name: "test-rg",
+                location: "eastus",
+                tags: { initial: "value" },
+            };
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", props);
+            // Original props should remain unchanged
+            expect(props.tags).toEqual({ initial: "value" });
+            // Tags should be accessible via getter
+            expect(rg.tags).toEqual({ initial: "value" });
+        });
+        it("should not mutate props when adding tags", () => {
+            const props = {
+                name: "test-rg",
+                location: "eastus",
+                tags: { initial: "value" },
+            };
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", props);
+            // Add a tag
+            rg.addTag("added", "dynamically");
+            // Original props should remain unchanged
+            expect(props.tags).toEqual({ initial: "value" });
+            expect(props.tags.added).toBeUndefined();
+            // Tags getter should include both
+            expect(rg.tags).toEqual({
+                initial: "value",
+                added: "dynamically",
+            });
+        });
+        it("should handle tags when no initial tags are provided", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            // Should start with empty tags
+            expect(rg.tags).toEqual({});
+            // Add tags
+            rg.addTag("tag1", "value1");
+            rg.addTag("tag2", "value2");
+            // Should have the added tags
+            expect(rg.tags).toEqual({
+                tag1: "value1",
+                tag2: "value2",
+            });
+        });
+    });
+    describe("Tag Combination", () => {
+        it("should combine props tags with dynamically added tags", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+                tags: {
+                    environment: "test",
+                    project: "cdktf",
+                },
+            });
+            // Add more tags
+            rg.addTag("owner", "team@example.com");
+            rg.addTag("cost-center", "engineering");
+            // All tags should be accessible
+            expect(rg.tags).toEqual({
+                environment: "test",
+                project: "cdktf",
+                owner: "team@example.com",
+                "cost-center": "engineering",
+            });
+        });
+        it("should allow overwriting tags via addTag", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+                tags: { environment: "dev" },
+            });
+            // Overwrite existing tag
+            rg.addTag("environment", "production");
+            // Should have the new value
+            expect(rg.tags.environment).toBe("production");
+        });
+        it("should return a copy from tags getter to maintain immutability", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+                tags: { initial: "value" },
+            });
+            // Get tags reference
+            const tags1 = rg.tags;
+            const tags2 = rg.tags;
+            // Should be different objects (copies)
+            expect(tags1).not.toBe(tags2);
+            // But with same content
+            expect(tags1).toEqual(tags2);
+            // Modifying the returned object should not affect the resource
+            tags1.modified = "externally";
+            expect(rg.tags.modified).toBeUndefined();
+        });
+    });
+    describe("Multiple Tag Operations", () => {
+        it("should handle multiple addTag calls", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            // Add multiple tags
+            for (let i = 0; i < 10; i++) {
+                rg.addTag(`tag${i}`, `value${i}`);
+            }
+            // All tags should be present
+            const tags = rg.tags;
+            expect(Object.keys(tags)).toHaveLength(10);
+            for (let i = 0; i < 10; i++) {
+                expect(tags[`tag${i}`]).toBe(`value${i}`);
+            }
+        });
+        it("should handle special characters in tag keys and values", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            rg.addTag("tag-with-dash", "value-with-dash");
+            rg.addTag("tag:with:colon", "value:with:colon");
+            rg.addTag("tag.with.dot", "value.with.dot");
+            const tags = rg.tags;
+            expect(tags["tag-with-dash"]).toBe("value-with-dash");
+            expect(tags["tag:with:colon"]).toBe("value:with:colon");
+            expect(tags["tag.with.dot"]).toBe("value.with.dot");
+        });
+    });
+    describe("Resource Body Integration", () => {
+        it("should include all tags in synthesized Terraform configuration when added before synthesis", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+                tags: { initial: "tag" },
+            });
+            // Tags are set during construction via props
+            // Verify they're accessible
+            expect(rg.tags).toEqual({ initial: "tag" });
+            // Synthesize the stack
+            const synthesized = cdktf_1.Testing.synth(stack);
+            const stackConfig = JSON.parse(synthesized);
+            // The azapi_resource should exist
+            expect(stackConfig.resource).toBeDefined();
+            expect(stackConfig.resource.azapi_resource).toBeDefined();
+            // Find the resource (name may vary based on construct ID generation)
+            const resources = Object.values(stackConfig.resource.azapi_resource);
+            expect(resources.length).toBeGreaterThan(0);
+            const resource = resources[0];
+            // Tags should be at the resource level, not in the body
+            // The createAzapiResource method extracts tags from body and places them at top level
+            expect(resource.tags).toEqual({
+                initial: "tag",
+            });
+        });
+        it("should make tags added via addTag accessible via tags getter", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+                tags: { initial: "tag" },
+            });
+            // Add tag after construction
+            rg.addTag("added", "later");
+            // Verify tags are accessible via getter
+            expect(rg.tags).toEqual({
+                initial: "tag",
+                added: "later",
+            });
+        });
+    });
+    describe("JSII Compliance", () => {
+        it("should have JSII-compliant addTag method", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+            });
+            // Should be a function
+            expect(typeof rg.addTag).toBe("function");
+            // Should work with standard parameters
+            expect(() => {
+                rg.addTag("key", "value");
+            }).not.toThrow();
+        });
+        it("should have JSII-compliant tags getter", () => {
+            const rg = new resource_group_1.ResourceGroup(stack, "TestRG", {
+                name: "test-rg",
+                location: "eastus",
+                tags: { test: "tag" },
+            });
+            // Should return an object
+            expect(typeof rg.tags).toBe("object");
+            // Should be serializable
+            expect(() => JSON.stringify(rg.tags)).not.toThrow();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"azapi-resource-tags.spec.js","sourceRoot":"","sources":["../../../../src/core-azure/lib/azapi/azapi-resource-tags.spec.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAEH,iCAAgC;AAChC,+BAA+B;AAC/B,oFAAgF;AAEhF,QAAQ,CAAC,gCAAgC,EAAE,GAAG,EAAE;IAC9C,IAAI,GAAc,CAAC;IACnB,IAAI,KAA2B,CAAC;IAEhC,UAAU,CAAC,GAAG,EAAE;QACd,GAAG,GAAG,eAAO,CAAC,GAAG,EAAE,CAAC;QACpB,KAAK,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACrD,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;QAChC,EAAE,CAAC,kDAAkD,EAAE,GAAG,EAAE;YAC1D,MAAM,KAAK,GAAG;gBACZ,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;aAC3B,CAAC;YAEF,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YAErD,yCAAyC;YACzC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;YAEjD,uCAAuC;YACvC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;QAChD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,KAAK,GAAG;gBACZ,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;aAC3B,CAAC;YAEF,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;YAErD,YAAY;YACZ,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;YAElC,yCAAyC;YACzC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;YACjD,MAAM,CAAE,KAAK,CAAC,IAAY,CAAC,KAAK,CAAC,CAAC,aAAa,EAAE,CAAC;YAElD,kCAAkC;YAClC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;gBACtB,OAAO,EAAE,OAAO;gBAChB,KAAK,EAAE,aAAa;aACrB,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,sDAAsD,EAAE,GAAG,EAAE;YAC9D,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;aACnB,CAAC,CAAC;YAEH,+BAA+B;YAC/B,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YAE5B,WAAW;YACX,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAC5B,EAAE,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YAE5B,6BAA6B;YAC7B,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;gBACtB,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,QAAQ;aACf,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;QAC/B,EAAE,CAAC,uDAAuD,EAAE,GAAG,EAAE;YAC/D,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE;oBACJ,WAAW,EAAE,MAAM;oBACnB,OAAO,EAAE,OAAO;iBACjB;aACF,CAAC,CAAC;YAEH,gBAAgB;YAChB,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC;YACvC,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;YAExC,gCAAgC;YAChC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;gBACtB,WAAW,EAAE,MAAM;gBACnB,OAAO,EAAE,OAAO;gBAChB,KAAK,EAAE,kBAAkB;gBACzB,aAAa,EAAE,aAAa;aAC7B,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE;aAC7B,CAAC,CAAC;YAEH,yBAAyB;YACzB,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;YAEvC,4BAA4B;YAC5B,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QACjD,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,gEAAgE,EAAE,GAAG,EAAE;YACxE,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE;aAC3B,CAAC,CAAC;YAEH,qBAAqB;YACrB,MAAM,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC;YACtB,MAAM,KAAK,GAAG,EAAE,CAAC,IAAI,CAAC;YAEtB,uCAAuC;YACvC,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAE9B,wBAAwB;YACxB,MAAM,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAE7B,+DAA+D;YAC/D,KAAK,CAAC,QAAQ,GAAG,YAAY,CAAC;YAC9B,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,aAAa,EAAE,CAAC;QAC3C,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACvC,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;YAC7C,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;aACnB,CAAC,CAAC;YAEH,oBAAoB;YACpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5B,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;YACpC,CAAC;YAED,6BAA6B;YAC7B,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;YACrB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;YAC3C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC5B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,yDAAyD,EAAE,GAAG,EAAE;YACjE,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;aACnB,CAAC,CAAC;YAEH,EAAE,CAAC,MAAM,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAC;YAC9C,EAAE,CAAC,MAAM,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;YAChD,EAAE,CAAC,MAAM,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;YAE5C,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;YACtD,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;YACxD,MAAM,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;QACzC,EAAE,CAAC,4FAA4F,EAAE,GAAG,EAAE;YACpG,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;aACzB,CAAC,CAAC;YAEH,6CAA6C;YAC7C,4BAA4B;YAC5B,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC;YAE5C,uBAAuB;YACvB,MAAM,WAAW,GAAG,eAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YACzC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAE5C,kCAAkC;YAClC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;YAC3C,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC,WAAW,EAAE,CAAC;YAE1D,qEAAqE;YACrE,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YACrE,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;YAE5C,MAAM,QAAQ,GAAQ,SAAS,CAAC,CAAC,CAAC,CAAC;YAEnC,wDAAwD;YACxD,sFAAsF;YACtF,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;gBAC5B,OAAO,EAAE,KAAK;aACf,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,8DAA8D,EAAE,GAAG,EAAE;YACtE,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;aACzB,CAAC,CAAC;YAEH,6BAA6B;YAC7B,EAAE,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAE5B,wCAAwC;YACxC,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC;gBACtB,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,OAAO;aACf,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,iBAAiB,EAAE,GAAG,EAAE;QAC/B,EAAE,CAAC,0CAA0C,EAAE,GAAG,EAAE;YAClD,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;aACnB,CAAC,CAAC;YAEH,uBAAuB;YACvB,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAE1C,uCAAuC;YACvC,MAAM,CAAC,GAAG,EAAE;gBACV,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YAC5B,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;YAChD,MAAM,EAAE,GAAG,IAAI,8BAAa,CAAC,KAAK,EAAE,QAAQ,EAAE;gBAC5C,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;gBAClB,IAAI,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE;aACtB,CAAC,CAAC;YAEH,0BAA0B;YAC1B,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAEtC,yBAAyB;YACzB,MAAM,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;QACtD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["/**\n * Tests for the AzapiResource tag management functionality\n *\n * These tests verify that the immutability pattern for tags works correctly:\n * - Tags from props are stored separately from the readonly props\n * - Tags added via addTag() are combined with props tags\n * - The tags getter returns all tags (props + added)\n * - The allTags() method used in createResourceBody includes all tags\n */\n\nimport { Testing } from \"cdktf\";\nimport * as cdktf from \"cdktf\";\nimport { ResourceGroup } from \"../../../azure-resourcegroup/lib/resource-group\";\n\ndescribe(\"AzapiResource - Tag Management\", () => {\n  let app: cdktf.App;\n  let stack: cdktf.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktf.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Tag Immutability\", () => {\n    it(\"should store tags separately from readonly props\", () => {\n      const props = {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { initial: \"value\" },\n      };\n\n      const rg = new ResourceGroup(stack, \"TestRG\", props);\n\n      // Original props should remain unchanged\n      expect(props.tags).toEqual({ initial: \"value\" });\n\n      // Tags should be accessible via getter\n      expect(rg.tags).toEqual({ initial: \"value\" });\n    });\n\n    it(\"should not mutate props when adding tags\", () => {\n      const props = {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { initial: \"value\" },\n      };\n\n      const rg = new ResourceGroup(stack, \"TestRG\", props);\n\n      // Add a tag\n      rg.addTag(\"added\", \"dynamically\");\n\n      // Original props should remain unchanged\n      expect(props.tags).toEqual({ initial: \"value\" });\n      expect((props.tags as any).added).toBeUndefined();\n\n      // Tags getter should include both\n      expect(rg.tags).toEqual({\n        initial: \"value\",\n        added: \"dynamically\",\n      });\n    });\n\n    it(\"should handle tags when no initial tags are provided\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      // Should start with empty tags\n      expect(rg.tags).toEqual({});\n\n      // Add tags\n      rg.addTag(\"tag1\", \"value1\");\n      rg.addTag(\"tag2\", \"value2\");\n\n      // Should have the added tags\n      expect(rg.tags).toEqual({\n        tag1: \"value1\",\n        tag2: \"value2\",\n      });\n    });\n  });\n\n  describe(\"Tag Combination\", () => {\n    it(\"should combine props tags with dynamically added tags\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: {\n          environment: \"test\",\n          project: \"cdktf\",\n        },\n      });\n\n      // Add more tags\n      rg.addTag(\"owner\", \"team@example.com\");\n      rg.addTag(\"cost-center\", \"engineering\");\n\n      // All tags should be accessible\n      expect(rg.tags).toEqual({\n        environment: \"test\",\n        project: \"cdktf\",\n        owner: \"team@example.com\",\n        \"cost-center\": \"engineering\",\n      });\n    });\n\n    it(\"should allow overwriting tags via addTag\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { environment: \"dev\" },\n      });\n\n      // Overwrite existing tag\n      rg.addTag(\"environment\", \"production\");\n\n      // Should have the new value\n      expect(rg.tags.environment).toBe(\"production\");\n    });\n\n    it(\"should return a copy from tags getter to maintain immutability\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { initial: \"value\" },\n      });\n\n      // Get tags reference\n      const tags1 = rg.tags;\n      const tags2 = rg.tags;\n\n      // Should be different objects (copies)\n      expect(tags1).not.toBe(tags2);\n\n      // But with same content\n      expect(tags1).toEqual(tags2);\n\n      // Modifying the returned object should not affect the resource\n      tags1.modified = \"externally\";\n      expect(rg.tags.modified).toBeUndefined();\n    });\n  });\n\n  describe(\"Multiple Tag Operations\", () => {\n    it(\"should handle multiple addTag calls\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      // Add multiple tags\n      for (let i = 0; i < 10; i++) {\n        rg.addTag(`tag${i}`, `value${i}`);\n      }\n\n      // All tags should be present\n      const tags = rg.tags;\n      expect(Object.keys(tags)).toHaveLength(10);\n      for (let i = 0; i < 10; i++) {\n        expect(tags[`tag${i}`]).toBe(`value${i}`);\n      }\n    });\n\n    it(\"should handle special characters in tag keys and values\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      rg.addTag(\"tag-with-dash\", \"value-with-dash\");\n      rg.addTag(\"tag:with:colon\", \"value:with:colon\");\n      rg.addTag(\"tag.with.dot\", \"value.with.dot\");\n\n      const tags = rg.tags;\n      expect(tags[\"tag-with-dash\"]).toBe(\"value-with-dash\");\n      expect(tags[\"tag:with:colon\"]).toBe(\"value:with:colon\");\n      expect(tags[\"tag.with.dot\"]).toBe(\"value.with.dot\");\n    });\n  });\n\n  describe(\"Resource Body Integration\", () => {\n    it(\"should include all tags in synthesized Terraform configuration when added before synthesis\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { initial: \"tag\" },\n      });\n\n      // Tags are set during construction via props\n      // Verify they're accessible\n      expect(rg.tags).toEqual({ initial: \"tag\" });\n\n      // Synthesize the stack\n      const synthesized = Testing.synth(stack);\n      const stackConfig = JSON.parse(synthesized);\n\n      // The azapi_resource should exist\n      expect(stackConfig.resource).toBeDefined();\n      expect(stackConfig.resource.azapi_resource).toBeDefined();\n\n      // Find the resource (name may vary based on construct ID generation)\n      const resources = Object.values(stackConfig.resource.azapi_resource);\n      expect(resources.length).toBeGreaterThan(0);\n\n      const resource: any = resources[0];\n\n      // Tags should be at the resource level, not in the body\n      // The createAzapiResource method extracts tags from body and places them at top level\n      expect(resource.tags).toEqual({\n        initial: \"tag\",\n      });\n    });\n\n    it(\"should make tags added via addTag accessible via tags getter\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { initial: \"tag\" },\n      });\n\n      // Add tag after construction\n      rg.addTag(\"added\", \"later\");\n\n      // Verify tags are accessible via getter\n      expect(rg.tags).toEqual({\n        initial: \"tag\",\n        added: \"later\",\n      });\n    });\n  });\n\n  describe(\"JSII Compliance\", () => {\n    it(\"should have JSII-compliant addTag method\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n      });\n\n      // Should be a function\n      expect(typeof rg.addTag).toBe(\"function\");\n\n      // Should work with standard parameters\n      expect(() => {\n        rg.addTag(\"key\", \"value\");\n      }).not.toThrow();\n    });\n\n    it(\"should have JSII-compliant tags getter\", () => {\n      const rg = new ResourceGroup(stack, \"TestRG\", {\n        name: \"test-rg\",\n        location: \"eastus\",\n        tags: { test: \"tag\" },\n      });\n\n      // Should return an object\n      expect(typeof rg.tags).toBe(\"object\");\n\n      // Should be serializable\n      expect(() => JSON.stringify(rg.tags)).not.toThrow();\n    });\n  });\n});\n"]}

package/lib/core-azure/lib/azapi/azapi-resource.d.ts

@@ -92,13 +92,36 @@ export interface MonitoringConfig {
  * Combines base resource properties with version management capabilities
  * and advanced configuration options for the unified framework.
  */
-export interface AzapiResourceProps {
+export interface AzapiResourceProps extends cdktf.TerraformMetaArguments {
     /**
      * The name of the resource
      */
     readonly name?: string;
     /**
      * The location where the resource should be created
+     *
+     * @remarks
+     * Location handling varies by resource type:
+     * - **Top-level resources**: Most require an explicit location (e.g., "eastus", "westus")
+     * - **Global resources**: Some use "global" as location (e.g., Private DNS Zones)
+     * - **Child resources**: Inherit location from parent and should NOT set this property
+     *
+     * Each resource type may provide its own default through the `resolveLocation()` method.
+     * If no location is specified and no default exists, resource creation may fail.
+     *
+     * @example
+     * // Explicit location for most resources
+     * location: "eastus"
+     *
+     * @example
+     * // Global resource (Private DNS Zone)
+     * location: "global"
+     *
+     * @example
+     * // Child resource (Subnet) - do not set location
+     * // location: undefined (inherited from parent Virtual Network)
+     *
+     * @defaultValue Varies by resource type - see specific resource documentation
      */
     readonly location?: string;
     /**
@@ -214,15 +237,35 @@ export interface AzapiResourceProps {
  * @stability stable
  */
 export declare abstract class AzapiResource extends Construct {
+    /**
+     * Static helper for child classes to register their schemas in static initializers
+     *
+     * This method should be called in a static initializer block of each child class
+     * to register all supported API versions and their schemas with the ApiVersionManager.
+     * The static block runs once when the class is first loaded, ensuring schemas are
+     * registered before any instances are created.
+     *
+     * @param resourceType - The Azure resource type (e.g., "Microsoft.Network/virtualNetworks")
+     * @param versions - Array of version configurations containing schemas
+     *
+     * @example
+     * static {
+     *   AzapiResource.registerSchemas(
+     *     "Microsoft.Network/virtualNetworks",
+     *     ALL_VIRTUAL_NETWORK_VERSIONS
+     *   );
+     * }
+     */
+    protected static registerSchemas(resourceType: string, versions: VersionConfig[]): void;
     /**
      * The Azure resource type (e.g., "Microsoft.Resources/resourceGroups")
      * @internal
      */
-    protected readonly _resourceType: string;
+    protected _resourceType: string;
     /**
      * The API version to use for this resource
      */
-    protected readonly apiVersion: string;
+    protected apiVersion: string;
     /**
      * The underlying AZAPI Terraform resource
      */
@@ -232,13 +275,17 @@ export declare abstract class AzapiResource extends Construct {
      */
     readonly name: string;
     /**
-     * The location of the resource
+     * The location of the resource (optional - not all resources have a location)
+     * Child resources typically inherit location from their parent
      */
-    readonly location: string;
+    readonly location?: string;
     /**
-     * The resource ID (abstract - must be implemented by subclasses)
+     * The Azure resource ID
+     *
+     * This property is automatically derived from the underlying Terraform resource.
+     * Child classes no longer need to implement this property.
      */
-    abstract readonly id: string;
+    get id(): string;
     /**
      * The resolved API version being used for this resource instance
      *
@@ -246,37 +293,43 @@ export declare abstract class AzapiResource extends Construct {
      * either explicitly specified in props or automatically resolved to
      * the latest active version.
      */
-    readonly resolvedApiVersion: string;
+    resolvedApiVersion: string;
     /**
      * The API schema for the resolved version
      *
      * Contains the complete schema definition including properties, validation
      * rules, and transformation mappings for the resolved API version.
      */
-    readonly schema: ApiSchema;
+    schema: ApiSchema;
     /**
      * The version configuration for the resolved version
      *
      * Contains lifecycle information, breaking changes, and migration metadata
      * for the resolved API version.
      */
-    readonly versionConfig: VersionConfig;
+    versionConfig: VersionConfig;
     /**
      * Validation results for the resource properties
      *
      * Available after construction if validation is enabled. Contains detailed
      * information about any validation errors or warnings.
      */
-    readonly validationResult?: ValidationResult;
+    validationResult?: ValidationResult;
     /**
      * Migration analysis results
      *
      * Available after construction if migration analysis is enabled and a
      * previous version can be determined for comparison.
      */
-    readonly migrationAnalysis?: MigrationAnalysis;
+    migrationAnalysis?: MigrationAnalysis;
     private readonly _apiVersionManager;
-    private readonly _schemaMapper;
+    private _versionManager;
+    private _schemaValidator;
+    /**
+     * Internal mutable tags storage separate from input props
+     * Combines props.tags with dynamically added tags via addTag()
+     */
+    private _tags;
     protected readonly monitoringActionGroups: Construct[];
     protected readonly monitoringMetricAlerts: Construct[];
     protected readonly monitoringActivityLogAlerts: Construct[];
@@ -292,6 +345,16 @@ export declare abstract class AzapiResource extends Construct {
      * @param props - Configuration properties for the resource
      */
     constructor(scope: Construct, id: string, props?: AzapiResourceProps);
+    /**
+     * Protected initialization method called after the constructor completes
+     *
+     * This method is called at the end of the constructor to perform initialization
+     * that requires calling abstract methods. Child classes can override this method
+     * if they need to extend initialization logic, but they MUST call super.initialize(props).
+     *
+     * @param props - Configuration properties for the resource
+     */
+    protected initialize(props: AzapiResourceProps): void;
     /**
      * Gets the default API version to use when no explicit version is specified
      *
@@ -332,6 +395,36 @@ export declare abstract class AzapiResource extends Construct {
      * @returns The resource body object to send to Azure API
      */
     protected abstract createResourceBody(props: any): any;
+    /**
+     * Override in child classes to provide default location
+     * @returns Default location or undefined
+     */
+    protected defaultLocation(): string | undefined;
+    /**
+     * Override in child classes to indicate if location is required
+     * @returns true if location is mandatory for this resource type
+     */
+    protected requiresLocation(): boolean;
+    /**
+     * Override in child classes to specify parent resource for location inheritance
+     * @returns Parent resource or undefined
+     */
+    protected parentResourceForLocation(): AzapiResource | undefined;
+    /**
+     * Resolves location using template method pattern
+     * Priority: props.location > parent location > default location > validation
+     */
+    protected resolveLocation(props: AzapiResourceProps): string | undefined;
+    /**
+     * Resolves the name for this resource
+     *
+     * This method centralizes name resolution logic. By default, it uses the
+     * provided name or falls back to the construct ID.
+     *
+     * @param props - The resource properties
+     * @returns The resolved resource name
+     */
+    protected resolveName(props: AzapiResourceProps): string;
     /**
      * Helper method for standard schema resolution
      *
@@ -371,18 +464,10 @@ export declare abstract class AzapiResource extends Construct {
      * @returns Detailed migration analysis results
      */
     analyzeMigrationTo(targetVersion: string): MigrationAnalysis;
-    /**
-     * Resolves the API version to use for this resource instance
-     */
-    private _resolveApiVersion;
     /**
      * Processes properties through the framework pipeline
      */
     private _processProperties;
-    /**
-     * Validates properties against the schema
-     */
-    private _validateProperties;
     /**
      * Performs migration analysis for the current version
      */
@@ -391,6 +476,23 @@ export declare abstract class AzapiResource extends Construct {
      * Creates the underlying Azure resource
      */
     private _createAzureResource;
+    /**
+     * Finds the parent AzapiResource construct if the parentId references a resource
+     * Returns undefined if parentId is a static string or parent not found
+     * @private
+     */
+    private _findParentAzapiResource;
+    /**
+     * Finds the root of the construct tree
+     * @private
+     */
+    private _findRoot;
+    /**
+     * Recursively searches for a parent resource by matching parentId patterns
+     * Enhanced to better handle Terraform interpolation syntax
+     * @private
+     */
+    private _findParentResource;
     /**
      * Resolves the parent resource ID for this resource.
      *
@@ -405,8 +507,12 @@ export declare abstract class AzapiResource extends Construct {
     /**
      * Determines the parent ID for the resource (internal implementation)
      *
-     * This method provides the default parent ID resolution logic for most resources.
-     * Child resources should override resolveParentId() instead of this method.
+     * This method provides the default parent ID resolution logic.
+     * Resource-specific logic should be implemented in the overrideable resolveParentId() method.
+     *
+     * Default behavior:
+     * - If resourceGroupId is provided in props, use it
+     * - Otherwise, default to subscription scope
      */
     private _determineParentId;
     /**
@@ -427,13 +533,16 @@ export declare abstract class AzapiResource extends Construct {
     /**
      * Creates the underlying AZAPI Terraform resource using the generated provider classes
      *
-     * @param properties - The properties object to send to the Azure API
+     * @param properties - The properties object to send to the Azure API (should include location if needed)
      * @param parentId - The parent resource ID (e.g., subscription or resource group)
      * @param name - The name of the resource
-     * @param location - The location of the resource (optional, can be in properties)
+     * @param location - The location of the resource (optional, only for top-level resources without location in body)
+     * @param parentResource - The parent resource for dependency tracking
+     * @param dependsOn - Explicit dependencies for this resource
+     * @param tags - Tags to apply to the resource (passed separately from body for proper idempotency)
      * @returns The created AZAPI resource
      */
-    protected createAzapiResource(properties: Record<string, any>, parentId: string, name: string, location?: string): cdktf.TerraformResource;
+    protected createAzapiResource(properties: Record<string, any>, parentId: string, name: string, location?: string, parentResource?: AzapiResource, dependsOn?: cdktf.ITerraformDependable[], tags?: Record<string, string>): cdktf.TerraformResource;
     /**
      * Creates an AZAPI data source for reading existing resources
      *
@@ -451,6 +560,11 @@ export declare abstract class AzapiResource extends Construct {
      * Gets the full resource ID
      */
     get resourceId(): string;
+    /**
+     * Gets the underlying Terraform resource for use in dependency declarations
+     * This allows explicit dependency management between resources
+     */
+    get resource(): cdktf.TerraformResource;
     /**
      * Gets the resource as a Terraform output value
      */
@@ -464,6 +578,44 @@ export declare abstract class AzapiResource extends Construct {
      * @param roleDefinitionName - The name of the Azure RBAC role to be assigned
      */
     addAccess(objectId: string, roleDefinitionName: string): void;
+    /**
+     * Adds a tag to this resource. The tag will be included in the Azure resource.
+     *
+     * This method provides proper immutability by storing tags separately from props.
+     * Tags added via this method are combined with tags from props and included in
+     * the deployed Azure resource.
+     *
+     * **Important:** In CDK for Terraform, tags should ideally be set during resource
+     * construction via props. While this method allows adding tags after construction,
+     * those tags are only included if added before the Terraform configuration is
+     * synthesized. For best results, add all tags via props or call addTag() in the
+     * same scope where the resource is created.
+     *
+     * @param key - The tag key
+     * @param value - The tag value
+     */
+    addTag(key: string, value: string): void;
+    /**
+     * All tags on this resource (readonly view)
+     *
+     * This getter provides convenient access to all tags including those from props
+     * and those added dynamically via addTag(). Returns a copy to maintain immutability.
+     */
+    get tags(): {
+        [key: string]: string;
+    };
+    /**
+     * Protected method to retrieve all tags for use in createResourceBody implementations
+     *
+     * Subclasses should use this method when creating resource bodies to ensure
+     * all tags (from props and addTag()) are included in the Azure resource.
+     * Uses a non-getter name to avoid JSII conflicts with the tags property.
+     *
+     * @returns Object containing all tags
+     */
+    protected allTags(): {
+        [key: string]: string;
+    };
 }
 /**
  * Properties for AZAPI role assignment