@microsoft/terraform-cdk-constructs 2.2.0 → 2.5.1

package/lib/azure-containerapps/test/container-apps-job.spec.js

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktn_1 = require("cdktn");
+const cdktn = require("cdktn");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const container_apps_job_1 = require("../lib/container-apps-job");
+const container_apps_job_schemas_1 = require("../lib/container-apps-job-schemas");
+describe("ContainerAppsJob - Unified Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    const environmentId = "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.App/managedEnvironments/test-env";
+    const resourceGroupId = "/subscriptions/test-sub/resourceGroups/test-rg";
+    const configuration = { triggerType: "Manual", replicaTimeout: 300 };
+    const template = {
+        containers: [
+            {
+                name: "test-container",
+                image: "mcr.microsoft.com/azuredocs/containerapps-helloworld:latest",
+            },
+        ],
+    };
+    beforeEach(() => {
+        app = cdktn_1.Testing.app();
+        stack = new cdktn.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        try {
+            manager.registerResourceType(container_apps_job_schemas_1.CONTAINER_APPS_JOB_TYPE, container_apps_job_schemas_1.ALL_CONTAINER_APPS_JOB_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create job with required properties", () => {
+            const props = {
+                name: "test-job",
+                location: "eastus",
+                environmentId,
+                configuration,
+                template,
+            };
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", props);
+            expect(job).toBeInstanceOf(container_apps_job_1.ContainerAppsJob);
+            expect(job.props).toBe(props);
+            expect(job.props.environmentId).toBe(environmentId);
+            expect(job.props.configuration).toEqual(configuration);
+            expect(job.props.template).toEqual(template);
+        });
+        it("should create job with automatic latest version resolution", () => {
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", {
+                name: "test-job",
+                location: "eastus",
+                environmentId,
+                configuration,
+                template,
+            });
+            expect(job.resolvedApiVersion).toBe("2024-03-01");
+            expect(job.latestVersion()).toBe("2024-03-01");
+        });
+        it("should create job with explicit version pinning", () => {
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", {
+                name: "test-job",
+                location: "eastus",
+                apiVersion: "2024-03-01",
+                environmentId,
+                configuration,
+                template,
+            });
+            expect(job.resolvedApiVersion).toBe("2024-03-01");
+        });
+        it("should create job with all optional properties", () => {
+            const props = {
+                name: "test-job-full",
+                location: "eastus",
+                apiVersion: "2024-03-01",
+                environmentId,
+                resourceGroupId,
+                configuration: {
+                    triggerType: "Manual",
+                    replicaTimeout: 300,
+                    replicaRetryLimit: 2,
+                    manualTriggerConfig: {
+                        parallelism: 1,
+                        replicaCompletionCount: 1,
+                    },
+                    secrets: [{ name: "registry-password", value: "super-secret" }],
+                    registries: [
+                        {
+                            server: "example.azurecr.io",
+                            username: "test-user",
+                            passwordSecretRef: "registry-password",
+                        },
+                    ],
+                },
+                template: {
+                    containers: [
+                        {
+                            name: "test-container",
+                            image: "mcr.microsoft.com/azuredocs/containerapps-helloworld:latest",
+                            resources: {
+                                cpu: 0.25,
+                                memory: "0.5Gi",
+                            },
+                            command: ["/bin/sh"],
+                            args: ["-c", "echo hello"],
+                            env: [
+                                { name: "ENVIRONMENT", value: "test" },
+                                { name: "PASSWORD", secretRef: "registry-password" },
+                            ],
+                        },
+                    ],
+                    initContainers: [
+                        {
+                            name: "init-container",
+                            image: "busybox:latest",
+                            args: ["echo", "setup"],
+                        },
+                    ],
+                    volumes: [{ name: "work", storageType: "EmptyDir" }],
+                },
+                identity: {
+                    type: "SystemAssigned",
+                },
+                tags: {
+                    environment: "test",
+                    workload: "job",
+                },
+            };
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", props);
+            expect(job.props.resourceGroupId).toBe(resourceGroupId);
+            expect(job.props.identity).toEqual({ type: "SystemAssigned" });
+            expect(job.props.tags).toEqual(props.tags);
+        });
+        it("should require location to be provided", () => {
+            const props = {
+                name: "test-job",
+                environmentId,
+                configuration,
+                template,
+            };
+            expect(() => {
+                new container_apps_job_1.ContainerAppsJob(stack, "TestJob", props);
+            }).toThrow("Location is required for Microsoft.App/jobs");
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should provide supported versions list", () => {
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", {
+                name: "test-job",
+                location: "eastus",
+                environmentId,
+                configuration,
+                template,
+            });
+            expect(job.supportedVersions()).toEqual(["2024-03-01"]);
+        });
+        it("should validate version support", () => {
+            expect(() => {
+                new container_apps_job_1.ContainerAppsJob(stack, "ValidVersion", {
+                    name: "test-job",
+                    location: "eastus",
+                    apiVersion: "2024-03-01",
+                    environmentId,
+                    configuration,
+                    template,
+                });
+            }).not.toThrow();
+            expect(() => {
+                new container_apps_job_1.ContainerAppsJob(stack, "InvalidVersion", {
+                    name: "test-job",
+                    location: "eastus",
+                    apiVersion: "2025-01-01",
+                    environmentId,
+                    configuration,
+                    template,
+                });
+            }).toThrow("Unsupported API version '2025-01-01'");
+        });
+        it("should load correct schema for resolved version", () => {
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", {
+                name: "test-job",
+                location: "eastus",
+                apiVersion: "2024-03-01",
+                environmentId,
+                configuration,
+                template,
+            });
+            expect(job.schema).toBeDefined();
+            expect(job.schema.resourceType).toBe(container_apps_job_schemas_1.CONTAINER_APPS_JOB_TYPE);
+            expect(job.schema.version).toBe("2024-03-01");
+            expect(job.schema.properties).toBeDefined();
+        });
+        it("should load version configuration correctly", () => {
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", {
+                name: "test-job",
+                location: "eastus",
+                environmentId,
+                configuration,
+                template,
+            });
+            expect(job.versionConfig).toBeDefined();
+            expect(job.versionConfig.version).toBe("2024-03-01");
+            expect(job.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+    });
+    describe("Outputs", () => {
+        it("should create Terraform outputs", () => {
+            const job = new container_apps_job_1.ContainerAppsJob(stack, "TestJob", {
+                name: "test-job",
+                location: "eastus",
+                environmentId,
+                configuration,
+                template,
+            });
+            expect(job.idOutput).toBeDefined();
+            expect(job.locationOutput).toBeDefined();
+            expect(job.nameOutput).toBeDefined();
+            expect(job.tagsOutput).toBeDefined();
+            expect(job.resourceId).toBe(job.id);
+        });
+        it("should synthesize output logical IDs", () => {
+            new container_apps_job_1.ContainerAppsJob(stack, "TestJob", {
+                name: "test-job",
+                location: "eastus",
+                environmentId,
+                configuration,
+                template,
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain('"id"');
+            expect(synthesized).toContain('"location"');
+            expect(synthesized).toContain('"name"');
+            expect(synthesized).toContain('"tags"');
+        });
+    });
+    describe("Multiple Resources", () => {
+        it("should handle multiple jobs in the same stack", () => {
+            const job1 = new container_apps_job_1.ContainerAppsJob(stack, "TestJob1", {
+                name: "test-job-1",
+                location: "eastus",
+                environmentId,
+                configuration,
+                template,
+            });
+            const job2 = new container_apps_job_1.ContainerAppsJob(stack, "TestJob2", {
+                name: "test-job-2",
+                location: "westus",
+                apiVersion: "2024-03-01",
+                environmentId,
+                configuration,
+                template,
+            });
+            expect(job1.resolvedApiVersion).toBe("2024-03-01");
+            expect(job2.resolvedApiVersion).toBe("2024-03-01");
+            expect(cdktn_1.Testing.synth(stack)).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container-apps-job.spec.js","sourceRoot":"","sources":["../../../src/azure-containerapps/test/container-apps-job.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { Testing } from \"cdktn\";\nimport * as cdktn from \"cdktn\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport {\n  ContainerAppsJob,\n  ContainerAppsJobProps,\n} from \"../lib/container-apps-job\";\nimport {\n  ALL_CONTAINER_APPS_JOB_VERSIONS,\n  CONTAINER_APPS_JOB_TYPE,\n} from \"../lib/container-apps-job-schemas\";\n\ndescribe(\"ContainerAppsJob - Unified Implementation\", () => {\n  let app: cdktn.App;\n  let stack: cdktn.TerraformStack;\n  let manager: ApiVersionManager;\n\n  const environmentId =\n    \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.App/managedEnvironments/test-env\";\n  const resourceGroupId = \"/subscriptions/test-sub/resourceGroups/test-rg\";\n  const configuration = { triggerType: \"Manual\", replicaTimeout: 300 };\n  const template = {\n    containers: [\n      {\n        name: \"test-container\",\n        image: \"mcr.microsoft.com/azuredocs/containerapps-helloworld:latest\",\n      },\n    ],\n  };\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktn.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    try {\n      manager.registerResourceType(\n        CONTAINER_APPS_JOB_TYPE,\n        ALL_CONTAINER_APPS_JOB_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create job with required properties\", () => {\n      const props: ContainerAppsJobProps = {\n        name: \"test-job\",\n        location: \"eastus\",\n        environmentId,\n        configuration,\n        template,\n      };\n\n      const job = new ContainerAppsJob(stack, \"TestJob\", props);\n\n      expect(job).toBeInstanceOf(ContainerAppsJob);\n      expect(job.props).toBe(props);\n      expect(job.props.environmentId).toBe(environmentId);\n      expect(job.props.configuration).toEqual(configuration);\n      expect(job.props.template).toEqual(template);\n    });\n\n    it(\"should create job with automatic latest version resolution\", () => {\n      const job = new ContainerAppsJob(stack, \"TestJob\", {\n        name: \"test-job\",\n        location: \"eastus\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      expect(job.resolvedApiVersion).toBe(\"2024-03-01\");\n      expect(job.latestVersion()).toBe(\"2024-03-01\");\n    });\n\n    it(\"should create job with explicit version pinning\", () => {\n      const job = new ContainerAppsJob(stack, \"TestJob\", {\n        name: \"test-job\",\n        location: \"eastus\",\n        apiVersion: \"2024-03-01\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      expect(job.resolvedApiVersion).toBe(\"2024-03-01\");\n    });\n\n    it(\"should create job with all optional properties\", () => {\n      const props: ContainerAppsJobProps = {\n        name: \"test-job-full\",\n        location: \"eastus\",\n        apiVersion: \"2024-03-01\",\n        environmentId,\n        resourceGroupId,\n        configuration: {\n          triggerType: \"Manual\",\n          replicaTimeout: 300,\n          replicaRetryLimit: 2,\n          manualTriggerConfig: {\n            parallelism: 1,\n            replicaCompletionCount: 1,\n          },\n          secrets: [{ name: \"registry-password\", value: \"super-secret\" }],\n          registries: [\n            {\n              server: \"example.azurecr.io\",\n              username: \"test-user\",\n              passwordSecretRef: \"registry-password\",\n            },\n          ],\n        },\n        template: {\n          containers: [\n            {\n              name: \"test-container\",\n              image:\n                \"mcr.microsoft.com/azuredocs/containerapps-helloworld:latest\",\n              resources: {\n                cpu: 0.25,\n                memory: \"0.5Gi\",\n              },\n              command: [\"/bin/sh\"],\n              args: [\"-c\", \"echo hello\"],\n              env: [\n                { name: \"ENVIRONMENT\", value: \"test\" },\n                { name: \"PASSWORD\", secretRef: \"registry-password\" },\n              ],\n            },\n          ],\n          initContainers: [\n            {\n              name: \"init-container\",\n              image: \"busybox:latest\",\n              args: [\"echo\", \"setup\"],\n            },\n          ],\n          volumes: [{ name: \"work\", storageType: \"EmptyDir\" }],\n        },\n        identity: {\n          type: \"SystemAssigned\",\n        },\n        tags: {\n          environment: \"test\",\n          workload: \"job\",\n        },\n      };\n\n      const job = new ContainerAppsJob(stack, \"TestJob\", props);\n\n      expect(job.props.resourceGroupId).toBe(resourceGroupId);\n      expect(job.props.identity).toEqual({ type: \"SystemAssigned\" });\n      expect(job.props.tags).toEqual(props.tags);\n    });\n\n    it(\"should require location to be provided\", () => {\n      const props = {\n        name: \"test-job\",\n        environmentId,\n        configuration,\n        template,\n      } as ContainerAppsJobProps;\n\n      expect(() => {\n        new ContainerAppsJob(stack, \"TestJob\", props);\n      }).toThrow(\"Location is required for Microsoft.App/jobs\");\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should provide supported versions list\", () => {\n      const job = new ContainerAppsJob(stack, \"TestJob\", {\n        name: \"test-job\",\n        location: \"eastus\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      expect(job.supportedVersions()).toEqual([\"2024-03-01\"]);\n    });\n\n    it(\"should validate version support\", () => {\n      expect(() => {\n        new ContainerAppsJob(stack, \"ValidVersion\", {\n          name: \"test-job\",\n          location: \"eastus\",\n          apiVersion: \"2024-03-01\",\n          environmentId,\n          configuration,\n          template,\n        });\n      }).not.toThrow();\n\n      expect(() => {\n        new ContainerAppsJob(stack, \"InvalidVersion\", {\n          name: \"test-job\",\n          location: \"eastus\",\n          apiVersion: \"2025-01-01\",\n          environmentId,\n          configuration,\n          template,\n        });\n      }).toThrow(\"Unsupported API version '2025-01-01'\");\n    });\n\n    it(\"should load correct schema for resolved version\", () => {\n      const job = new ContainerAppsJob(stack, \"TestJob\", {\n        name: \"test-job\",\n        location: \"eastus\",\n        apiVersion: \"2024-03-01\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      expect(job.schema).toBeDefined();\n      expect(job.schema.resourceType).toBe(CONTAINER_APPS_JOB_TYPE);\n      expect(job.schema.version).toBe(\"2024-03-01\");\n      expect(job.schema.properties).toBeDefined();\n    });\n\n    it(\"should load version configuration correctly\", () => {\n      const job = new ContainerAppsJob(stack, \"TestJob\", {\n        name: \"test-job\",\n        location: \"eastus\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      expect(job.versionConfig).toBeDefined();\n      expect(job.versionConfig.version).toBe(\"2024-03-01\");\n      expect(job.versionConfig.supportLevel).toBe(VersionSupportLevel.ACTIVE);\n    });\n  });\n\n  describe(\"Outputs\", () => {\n    it(\"should create Terraform outputs\", () => {\n      const job = new ContainerAppsJob(stack, \"TestJob\", {\n        name: \"test-job\",\n        location: \"eastus\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      expect(job.idOutput).toBeDefined();\n      expect(job.locationOutput).toBeDefined();\n      expect(job.nameOutput).toBeDefined();\n      expect(job.tagsOutput).toBeDefined();\n      expect(job.resourceId).toBe(job.id);\n    });\n\n    it(\"should synthesize output logical IDs\", () => {\n      new ContainerAppsJob(stack, \"TestJob\", {\n        name: \"test-job\",\n        location: \"eastus\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain('\"id\"');\n      expect(synthesized).toContain('\"location\"');\n      expect(synthesized).toContain('\"name\"');\n      expect(synthesized).toContain('\"tags\"');\n    });\n  });\n\n  describe(\"Multiple Resources\", () => {\n    it(\"should handle multiple jobs in the same stack\", () => {\n      const job1 = new ContainerAppsJob(stack, \"TestJob1\", {\n        name: \"test-job-1\",\n        location: \"eastus\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      const job2 = new ContainerAppsJob(stack, \"TestJob2\", {\n        name: \"test-job-2\",\n        location: \"westus\",\n        apiVersion: \"2024-03-01\",\n        environmentId,\n        configuration,\n        template,\n      });\n\n      expect(job1.resolvedApiVersion).toBe(\"2024-03-01\");\n      expect(job2.resolvedApiVersion).toBe(\"2024-03-01\");\n      expect(Testing.synth(stack)).toBeDefined();\n    });\n  });\n});\n"]}

package/lib/azure-containerregistry/index.d.ts

@@ -0,0 +1 @@
+export * from "./lib";

package/lib/azure-containerregistry/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtY29udGFpbmVycmVnaXN0cnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYlwiO1xuIl19

package/lib/azure-containerregistry/lib/container-registry-schemas.d.ts

@@ -0,0 +1,32 @@
+/**
+ * API schemas for Azure Container Registry across all supported versions
+ *
+ * This file defines the complete API schemas for Microsoft.ContainerRegistry/registries
+ * across all supported API versions. The schemas are used by the VersionedAzapiResource
+ * framework for validation, transformation, and version management.
+ */
+import { ApiSchema, VersionConfig } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+/**
+ * API Schema for Container Registry version 2023-07-01
+ */
+export declare const CONTAINER_REGISTRY_SCHEMA_2023_07_01: ApiSchema;
+/**
+ * API Schema for Container Registry version 2025-04-01
+ */
+export declare const CONTAINER_REGISTRY_SCHEMA_2025_04_01: ApiSchema;
+/**
+ * Version configuration for Container Registry 2023-07-01
+ */
+export declare const CONTAINER_REGISTRY_VERSION_2023_07_01: VersionConfig;
+/**
+ * Version configuration for Container Registry 2025-04-01
+ */
+export declare const CONTAINER_REGISTRY_VERSION_2025_04_01: VersionConfig;
+/**
+ * All supported Container Registry versions for registration
+ */
+export declare const ALL_CONTAINER_REGISTRY_VERSIONS: VersionConfig[];
+/**
+ * Resource type constant
+ */
+export declare const CONTAINER_REGISTRY_TYPE = "Microsoft.ContainerRegistry/registries";