@microsoft/terraform-cdk-constructs 1.0.0 → 1.3.0

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

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

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":"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","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"]}