@microsoft/terraform-cdk-constructs 0.0.3-pre.10 → 0.0.3-pre.12

package/lib/core-azure/lib/resource.js

@@ -75,6 +75,8 @@ class AzureResource extends constructs_1.Construct {
             storageAccountId: props.storageAccountId,
             targetResourceId: this.id,
             logAnalyticsDestinationType: undefined,
+            log: props?.log,
+            metric: props?.metric,
         });
     }
     setupResourceGroup(props) {
@@ -82,7 +84,7 @@ class AzureResource extends constructs_1.Construct {
             // Create a new resource group
             const newResourceGroup = new resource_group_1.ResourceGroup(this, "rg", {
                 name: `rg-${props.name}`,
-                location: props.location,
+                location: props.location || "eastus",
                 tags: props.tags,
             });
             // Use the name of the new resource group
@@ -96,7 +98,7 @@ class AzureResource extends constructs_1.Construct {
 }
 exports.AzureResource = AzureResource;
 _a = JSII_RTTI_SYMBOL_1;
-AzureResource[_a] = { fqn: "@microsoft/terraform-cdk-constructs.core_azure.AzureResource", version: "0.0.3-pre.10" };
+AzureResource[_a] = { fqn: "@microsoft/terraform-cdk-constructs.core_azure.AzureResource", version: "0.0.3-pre.12" };
 class AzureResourceWithAlert extends AzureResource {
     addQueryRuleAlert(props) {
         new queryalert.QueryRuleAlert(this, "queryrulealert", {
@@ -114,5 +116,5 @@ class AzureResourceWithAlert extends AzureResource {
 }
 exports.AzureResourceWithAlert = AzureResourceWithAlert;
 _b = JSII_RTTI_SYMBOL_1;
-AzureResourceWithAlert[_b] = { fqn: "@microsoft/terraform-cdk-constructs.core_azure.AzureResourceWithAlert", version: "0.0.3-pre.10" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource.js","sourceRoot":"","sources":["../../../src/core-azure/lib/resource.ts"],"names":[],"mappings":";;;;;AAAA,+EAA2E;AAC3E,2CAAuC;AACvC,iDAGwB;AACxB,iCAA8B;AAC9B,uDAAuD;AACvD,yDAAyD;AAEzD,MAAsB,aAAc,SAAQ,sBAAS;IAInD,YAAY,KAAgB,EAAE,EAAU;QACtC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,SAAS,CAAC,QAAgB,EAAE,cAAsB;QACvD,IAAI,WAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,EAAE;YACxC,QAAQ,EAAE,QAAQ;YAClB,kBAAkB,EAAE,cAAc;YAClC,KAAK,EAAE,IAAI,CAAC,EAAE;SACf,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACI,eAAe,CACpB,KAAkC;QAElC,OAAO,IAAI,iCAAkB,CAAC,IAAI,EAAE,cAAc,EAAE;YAClD,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,eAAe;YACnC,uBAAuB,EAAE,KAAK,CAAC,uBAAuB;YACtD,2BAA2B,EAAE,KAAK,CAAC,2BAA2B;YAC9D,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,gBAAgB,EAAE,IAAI,CAAC,EAAE;YACzB,2BAA2B,EAAE,SAAS;SACvC,CAAC,CAAC;IACL,CAAC;IAES,kBAAkB,CAAC,KAAU;QACrC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE;YACxB,8BAA8B;YAC9B,MAAM,gBAAgB,GAAG,IAAI,8BAAa,CAAC,IAAI,EAAE,IAAI,EAAE;gBACrD,IAAI,EAAE,MAAM,KAAK,CAAC,IAAI,EAAE;gBACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ;gBACxB,IAAI,EAAE,KAAK,CAAC,IAAI;aACjB,CAAC,CAAC;YACH,yCAAyC;YACzC,OAAO,gBAAgB,CAAC;SACzB;aAAM;YACL,uCAAuC;YACvC,OAAO,KAAK,CAAC,aAAa,CAAC;SAC5B;IACH,CAAC;;AA1FH,sCA2FC;;;AAED,MAAsB,sBAAuB,SAAQ,aAAa;IACzD,iBAAiB,CAAC,KAA8C;QACrE,IAAI,UAAU,CAAC,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE;YACpD,GAAG,KAAK;YACR,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;SAClB,CAAC,CAAC;IACL,CAAC;IAEM,cAAc,CAAC,KAAwC;QAC5D,IAAI,WAAW,CAAC,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE;YAC/C,GAAG,KAAK;YACR,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;SAClB,CAAC,CAAC;IACL,CAAC;;AAdH,wDAeC","sourcesContent":["import { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Construct } from \"constructs\";\nimport {\n  DiagnosticSettings,\n  BaseDiagnosticSettingsProps,\n} from \"./diagsettings\";\nimport { Rbac } from \"./rbac\";\nimport * as metricalert from \"../../azure-metricalert\";\nimport * as queryalert from \"../../azure-queryrulealert\";\n\nexport abstract class AzureResource extends Construct {\n  public id: string;\n  public abstract resourceGroup: ResourceGroup;\n\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n    this.id = id;\n  }\n\n  /**\n   * Adds an access role assignment for a specified Azure AD object (e.g., user, group, service principal) within this RBAC construct's scope.\n   *\n   * This method creates a new role assignment which grants the specified Azure AD object access to resources\n   * at the scope defined by this construct. This is useful for programmatically managing access controls,\n   * ensuring only authorized users or systems can perform specific actions on Azure resources.\n   *\n   * @param objectId - The unique identifier of the Azure AD object (user, group, or service principal) that will receive the role assignment.\n   * @param customRoleName - The human-readable name of the Azure RBAC role to be assigned. This role defines the permissions that the object will have.\n   *\n   * Example usage:\n   * ```typescript\n   * // Example: Assign a \"Reader\" role to a user for the current RBAC scope\n   * rbacInstance.addAccess('user-object-id', 'Reader');\n   * ```\n   */\n  public addAccess(objectId: string, customRoleName: string) {\n    new Rbac(this, objectId + customRoleName, {\n      objectId: objectId,\n      roleDefinitionName: customRoleName,\n      scope: this.id,\n    });\n  }\n\n  /**\n   * Adds diagnostic settings to a specified resource within this construct.\n   *\n   * This method creates and configures a new DiagnosticSettings instance which captures and routes\n   * diagnostic data (logs and metrics) to the specified destinations such as Azure Monitor,\n   * an Event Hubs instance, a Log Analytics workspace, or an Azure Storage account.\n   *\n   * @param props - The properties required to configure the diagnostic settings. These include:\n   *                - `name`: Optional. The name of the diagnostic settings resource. Defaults to 'diag-settings'.\n   *                - `logAnalyticsWorkspaceId`: Optional. The identifier of the Log Analytics workspace to send logs.\n   *                - `eventhubAuthorizationRuleId`: Optional. The authorization rule ID for an Event Hub where logs will be forwarded.\n   *                - `eventhubName`: Optional. The name of the Event Hub to which logs will be sent.\n   *                - `storageAccountId`: Optional. The identifier of the Azure Storage account where logs will be stored.\n   *                - `logAnalyticsDestinationType`: Optional. Determines if logs are sent to dedicated or legacy tables in Log Analytics. Defaults to undefined which uses the default settings.\n   *                The `targetResourceId` is automatically set to the ID of this construct instance.\n   *\n   * @returns An instance of the DiagnosticSettings class, configured with the provided properties.\n   *\n   * Example usage:\n   * ```typescript\n   * const diagSettings = resource.addDiagSettings({\n   *   name: 'custom-diag-settings',\n   *   logAnalyticsWorkspaceId: 'workspace-id',\n   *   eventhubAuthorizationRuleId: 'auth-rule-id',\n   *   eventhubName: 'eventhub-name',\n   *   storageAccountId: 'storage-account-id'\n   * });\n   * ```\n   */\n  public addDiagSettings(\n    props: BaseDiagnosticSettingsProps,\n  ): DiagnosticSettings {\n    return new DiagnosticSettings(this, \"diagsettings\", {\n      name: props.name || \"diag-settings\",\n      logAnalyticsWorkspaceId: props.logAnalyticsWorkspaceId,\n      eventhubAuthorizationRuleId: props.eventhubAuthorizationRuleId,\n      eventhubName: props.eventhubName,\n      storageAccountId: props.storageAccountId,\n      targetResourceId: this.id,\n      logAnalyticsDestinationType: undefined,\n    });\n  }\n\n  protected setupResourceGroup(props: any): ResourceGroup {\n    if (!props.resourceGroup) {\n      // Create a new resource group\n      const newResourceGroup = new ResourceGroup(this, \"rg\", {\n        name: `rg-${props.name}`,\n        location: props.location,\n        tags: props.tags,\n      });\n      // Use the name of the new resource group\n      return newResourceGroup;\n    } else {\n      // Use the provided resource group name\n      return props.resourceGroup;\n    }\n  }\n}\n\nexport abstract class AzureResourceWithAlert extends AzureResource {\n  public addQueryRuleAlert(props: queryalert.BaseAzureQueryRuleAlertProps) {\n    new queryalert.QueryRuleAlert(this, \"queryrulealert\", {\n      ...props,\n      scopes: [this.id],\n    });\n  }\n\n  public addMetricAlert(props: metricalert.IBaseMetricAlertProps) {\n    new metricalert.MetricAlert(this, \"metricalert\", {\n      ...props,\n      resourceGroup: this.resourceGroup,\n      scopes: [this.id],\n    });\n  }\n}\n"]}
+AzureResourceWithAlert[_b] = { fqn: "@microsoft/terraform-cdk-constructs.core_azure.AzureResourceWithAlert", version: "0.0.3-pre.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource.js","sourceRoot":"","sources":["../../../src/core-azure/lib/resource.ts"],"names":[],"mappings":";;;;;AAAA,+EAA2E;AAC3E,2CAAuC;AACvC,iDAGwB;AACxB,iCAA8B;AAC9B,uDAAuD;AACvD,yDAAyD;AAEzD,MAAsB,aAAc,SAAQ,sBAAS;IAInD,YAAY,KAAgB,EAAE,EAAU;QACtC,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACjB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,SAAS,CAAC,QAAgB,EAAE,cAAsB;QACvD,IAAI,WAAI,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,EAAE;YACxC,QAAQ,EAAE,QAAQ;YAClB,kBAAkB,EAAE,cAAc;YAClC,KAAK,EAAE,IAAI,CAAC,EAAE;SACf,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACI,eAAe,CACpB,KAAkC;QAElC,OAAO,IAAI,iCAAkB,CAAC,IAAI,EAAE,cAAc,EAAE;YAClD,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,eAAe;YACnC,uBAAuB,EAAE,KAAK,CAAC,uBAAuB;YACtD,2BAA2B,EAAE,KAAK,CAAC,2BAA2B;YAC9D,YAAY,EAAE,KAAK,CAAC,YAAY;YAChC,gBAAgB,EAAE,KAAK,CAAC,gBAAgB;YACxC,gBAAgB,EAAE,IAAI,CAAC,EAAE;YACzB,2BAA2B,EAAE,SAAS;YACtC,GAAG,EAAE,KAAK,EAAE,GAAG;YACf,MAAM,EAAE,KAAK,EAAE,MAAM;SACtB,CAAC,CAAC;IACL,CAAC;IAES,kBAAkB,CAAC,KAAU;QACrC,IAAI,CAAC,KAAK,CAAC,aAAa,EAAE;YACxB,8BAA8B;YAC9B,MAAM,gBAAgB,GAAG,IAAI,8BAAa,CAAC,IAAI,EAAE,IAAI,EAAE;gBACrD,IAAI,EAAE,MAAM,KAAK,CAAC,IAAI,EAAE;gBACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,QAAQ;gBACpC,IAAI,EAAE,KAAK,CAAC,IAAI;aACjB,CAAC,CAAC;YACH,yCAAyC;YACzC,OAAO,gBAAgB,CAAC;SACzB;aAAM;YACL,uCAAuC;YACvC,OAAO,KAAK,CAAC,aAAa,CAAC;SAC5B;IACH,CAAC;;AA5FH,sCA6FC;;;AAED,MAAsB,sBAAuB,SAAQ,aAAa;IACzD,iBAAiB,CAAC,KAA8C;QACrE,IAAI,UAAU,CAAC,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE;YACpD,GAAG,KAAK;YACR,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;SAClB,CAAC,CAAC;IACL,CAAC;IAEM,cAAc,CAAC,KAAwC;QAC5D,IAAI,WAAW,CAAC,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE;YAC/C,GAAG,KAAK;YACR,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;SAClB,CAAC,CAAC;IACL,CAAC;;AAdH,wDAeC","sourcesContent":["import { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Construct } from \"constructs\";\nimport {\n  DiagnosticSettings,\n  BaseDiagnosticSettingsProps,\n} from \"./diagsettings\";\nimport { Rbac } from \"./rbac\";\nimport * as metricalert from \"../../azure-metricalert\";\nimport * as queryalert from \"../../azure-queryrulealert\";\n\nexport abstract class AzureResource extends Construct {\n  public id: string;\n  public abstract resourceGroup: ResourceGroup;\n\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n    this.id = id;\n  }\n\n  /**\n   * Adds an access role assignment for a specified Azure AD object (e.g., user, group, service principal) within this RBAC construct's scope.\n   *\n   * This method creates a new role assignment which grants the specified Azure AD object access to resources\n   * at the scope defined by this construct. This is useful for programmatically managing access controls,\n   * ensuring only authorized users or systems can perform specific actions on Azure resources.\n   *\n   * @param objectId - The unique identifier of the Azure AD object (user, group, or service principal) that will receive the role assignment.\n   * @param customRoleName - The human-readable name of the Azure RBAC role to be assigned. This role defines the permissions that the object will have.\n   *\n   * Example usage:\n   * ```typescript\n   * // Example: Assign a \"Reader\" role to a user for the current RBAC scope\n   * rbacInstance.addAccess('user-object-id', 'Reader');\n   * ```\n   */\n  public addAccess(objectId: string, customRoleName: string) {\n    new Rbac(this, objectId + customRoleName, {\n      objectId: objectId,\n      roleDefinitionName: customRoleName,\n      scope: this.id,\n    });\n  }\n\n  /**\n   * Adds diagnostic settings to a specified resource within this construct.\n   *\n   * This method creates and configures a new DiagnosticSettings instance which captures and routes\n   * diagnostic data (logs and metrics) to the specified destinations such as Azure Monitor,\n   * an Event Hubs instance, a Log Analytics workspace, or an Azure Storage account.\n   *\n   * @param props - The properties required to configure the diagnostic settings. These include:\n   *                - `name`: Optional. The name of the diagnostic settings resource. Defaults to 'diag-settings'.\n   *                - `logAnalyticsWorkspaceId`: Optional. The identifier of the Log Analytics workspace to send logs.\n   *                - `eventhubAuthorizationRuleId`: Optional. The authorization rule ID for an Event Hub where logs will be forwarded.\n   *                - `eventhubName`: Optional. The name of the Event Hub to which logs will be sent.\n   *                - `storageAccountId`: Optional. The identifier of the Azure Storage account where logs will be stored.\n   *                - `logAnalyticsDestinationType`: Optional. Determines if logs are sent to dedicated or legacy tables in Log Analytics. Defaults to undefined which uses the default settings.\n   *                The `targetResourceId` is automatically set to the ID of this construct instance.\n   *\n   * @returns An instance of the DiagnosticSettings class, configured with the provided properties.\n   *\n   * Example usage:\n   * ```typescript\n   * const diagSettings = resource.addDiagSettings({\n   *   name: 'custom-diag-settings',\n   *   logAnalyticsWorkspaceId: 'workspace-id',\n   *   eventhubAuthorizationRuleId: 'auth-rule-id',\n   *   eventhubName: 'eventhub-name',\n   *   storageAccountId: 'storage-account-id'\n   * });\n   * ```\n   */\n  public addDiagSettings(\n    props: BaseDiagnosticSettingsProps,\n  ): DiagnosticSettings {\n    return new DiagnosticSettings(this, \"diagsettings\", {\n      name: props.name || \"diag-settings\",\n      logAnalyticsWorkspaceId: props.logAnalyticsWorkspaceId,\n      eventhubAuthorizationRuleId: props.eventhubAuthorizationRuleId,\n      eventhubName: props.eventhubName,\n      storageAccountId: props.storageAccountId,\n      targetResourceId: this.id,\n      logAnalyticsDestinationType: undefined,\n      log: props?.log,\n      metric: props?.metric,\n    });\n  }\n\n  protected setupResourceGroup(props: any): ResourceGroup {\n    if (!props.resourceGroup) {\n      // Create a new resource group\n      const newResourceGroup = new ResourceGroup(this, \"rg\", {\n        name: `rg-${props.name}`,\n        location: props.location || \"eastus\",\n        tags: props.tags,\n      });\n      // Use the name of the new resource group\n      return newResourceGroup;\n    } else {\n      // Use the provided resource group name\n      return props.resourceGroup;\n    }\n  }\n}\n\nexport abstract class AzureResourceWithAlert extends AzureResource {\n  public addQueryRuleAlert(props: queryalert.BaseAzureQueryRuleAlertProps) {\n    new queryalert.QueryRuleAlert(this, \"queryrulealert\", {\n      ...props,\n      scopes: [this.id],\n    });\n  }\n\n  public addMetricAlert(props: metricalert.IBaseMetricAlertProps) {\n    new metricalert.MetricAlert(this, \"metricalert\", {\n      ...props,\n      resourceGroup: this.resourceGroup,\n      scopes: [this.id],\n    });\n  }\n}\n"]}

package/lib/core-azure/test/AzureResource.integ.d.ts

@@ -0,0 +1 @@
+import "cdktf/lib/testing/adapters/jest";

package/lib/core-azure/test/AzureResource.integ.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const container_registry_1 = require("@cdktf/provider-azurerm/lib/container-registry");
+const data_azurerm_client_config_1 = require("@cdktf/provider-azurerm/lib/data-azurerm-client-config");
+const log_analytics_workspace_1 = require("@cdktf/provider-azurerm/lib/log-analytics-workspace");
+const provider_1 = require("@cdktf/provider-azurerm/lib/provider");
+const resource_group_1 = require("@cdktf/provider-azurerm/lib/resource-group");
+const cdktf_1 = require("cdktf");
+const testing_1 = require("../../testing");
+const randomName_1 = require("../../util/randomName");
+const lib_1 = require("../lib");
+require("cdktf/lib/testing/adapters/jest");
+describe("Example of deploying an Azure Resource", () => {
+    let stack;
+    let fullSynthResult;
+    const streamOutput = process.env.STREAM_OUTPUT !== "false";
+    beforeEach(() => {
+        const app = cdktf_1.Testing.app();
+        stack = new cdktf_1.TerraformStack(app, "test");
+        const randomName = (0, randomName_1.generateRandomName)(12);
+        class TestACR extends lib_1.AzureResource {
+            constructor(scope, name, resourceGroup, location) {
+                super(scope, name);
+                const containerRegistry = new container_registry_1.ContainerRegistry(this, "containerRegistry", {
+                    name: `acr${name}8898`,
+                    resourceGroupName: resourceGroup.name,
+                    location: location,
+                    sku: "Basic",
+                    adminEnabled: true,
+                });
+                this.id = containerRegistry.id;
+                this.resourceGroup = resourceGroup;
+            }
+        }
+        const clientConfig = new data_azurerm_client_config_1.DataAzurermClientConfig(stack, "CurrentClientConfig", {});
+        new provider_1.AzurermProvider(stack, "azureFeature", { features: {} });
+        // Create a resource group
+        const resourceGroup = new resource_group_1.ResourceGroup(stack, "rg", {
+            name: `rg-${randomName}`,
+            location: "eastus",
+        });
+        const acr = new TestACR(stack, `${randomName}`, resourceGroup, resourceGroup.location);
+        // Test RBAC Methods
+        acr.addAccess(clientConfig.objectId, "Contributor");
+        acr.addAccess(clientConfig.objectId, "Monitoring Reader");
+        const logAnalyticsWorkspace = new log_analytics_workspace_1.LogAnalyticsWorkspace(stack, "log_analytics", {
+            location: "eastus",
+            name: `la-${randomName}`,
+            resourceGroupName: resourceGroup.name,
+        });
+        // Test Diag Settings
+        acr.addDiagSettings({
+            name: "diagsettings",
+            logAnalyticsWorkspaceId: logAnalyticsWorkspace.id,
+            metric: [
+                {
+                    category: "AllMetrics",
+                },
+            ],
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    afterEach(() => {
+        try {
+            (0, testing_1.TerraformDestroy)(fullSynthResult, streamOutput);
+        }
+        catch (error) {
+            console.error("Error during Terraform destroy:", error);
+        }
+    });
+    it("check if this can be deployed", () => {
+        (0, testing_1.TerraformApplyAndCheckIdempotency)(fullSynthResult, streamOutput); // Set to true to stream output
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/testing/index.d.ts

@@ -1,6 +1,40 @@
+/// <reference types="node" />
+import { ExecSyncOptionsWithStringEncoding } from "child_process";
 import { TerraformStack } from "cdktf";
 import { Construct } from "constructs";
 export declare class BaseTestStack extends TerraformStack {
     readonly name: string;
     constructor(scope: Construct, id: string);
 }
+export declare function execTerraformCommand(command: string, opts: ExecSyncOptionsWithStringEncoding, streamOutput: boolean): {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};
+export declare function TerraformApply(stack: any, streamOutput?: boolean): {
+    stdout: string;
+    stderr: string;
+    error: any;
+};
+export declare function TerraformPlanExitCode(stack: any, streamOutput?: boolean): {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    error: any;
+};
+export declare function TerraformIdempotentCheck(stack: any): AssertionReturn;
+export declare function TerraformDestroy(stack: any, streamOutput?: boolean): AssertionReturn;
+export declare function TerraformApplyAndCheckIdempotency(stack: any, streamOutput?: boolean): AssertionReturn;
+export declare function TerraformApplyCheckAndDestroy(stack: any): void;
+export declare function TerraformPlan(stack: any): AssertionReturn;
+export declare class AssertionReturn {
+    readonly message: string;
+    readonly pass: boolean;
+    /**
+     * Create an AssertionReturn
+     * @param message - String message containing information about the result of the assertion
+     * @param pass - Boolean pass denoting the success of the assertion
+     */
+    constructor(message: string, pass: boolean);
+}
+export declare function cleanupCdkTfOutDirs(): void;

package/lib/testing/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseTestStack = void 0;
+exports.cleanupCdkTfOutDirs = exports.AssertionReturn = exports.TerraformPlan = exports.TerraformApplyCheckAndDestroy = exports.TerraformApplyAndCheckIdempotency = exports.TerraformDestroy = exports.TerraformIdempotentCheck = exports.TerraformPlanExitCode = exports.TerraformApply = exports.execTerraformCommand = exports.BaseTestStack = void 0;
+const child_process_1 = require("child_process");
+const fs = require("fs");
+const path = require("path");
 const cdktf = require("cdktf");
 const cdktf_1 = require("cdktf");
 class BaseTestStack extends cdktf_1.TerraformStack {
@@ -15,4 +18,234 @@ class BaseTestStack extends cdktf_1.TerraformStack {
     }
 }
 exports.BaseTestStack = BaseTestStack;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdGVzdGluZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwrQkFBK0I7QUFDL0IsaUNBQXVDO0FBR3ZDLE1BQWEsYUFBYyxTQUFRLHNCQUFjO0lBRy9DLFlBQVksS0FBZ0IsRUFBRSxFQUFVO1FBQ3RDLEtBQUssQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFakIsTUFBTSxJQUFJLEdBQUcsSUFBSSxLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLE1BQU0sRUFBRTtZQUNyRCxJQUFJLEVBQUUsUUFBUTtZQUNkLE9BQU8sRUFBRSxNQUFNO1lBQ2YsV0FBVyxFQUFFLDZDQUE2QztTQUMzRCxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUM7SUFDekIsQ0FBQztDQUNGO0FBZEQsc0NBY0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBjZGt0ZiBmcm9tIFwiY2RrdGZcIjtcbmltcG9ydCB7IFRlcnJhZm9ybVN0YWNrIH0gZnJvbSBcImNka3RmXCI7XG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tIFwiY29uc3RydWN0c1wiO1xuXG5leHBvcnQgY2xhc3MgQmFzZVRlc3RTdGFjayBleHRlbmRzIFRlcnJhZm9ybVN0YWNrIHtcbiAgcHVibGljIHJlYWRvbmx5IG5hbWU6IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkKTtcblxuICAgIGNvbnN0IG5hbWUgPSBuZXcgY2RrdGYuVGVycmFmb3JtVmFyaWFibGUodGhpcywgXCJuYW1lXCIsIHtcbiAgICAgIHR5cGU6IFwic3RyaW5nXCIsXG4gICAgICBkZWZhdWx0OiBcInRlc3RcIixcbiAgICAgIGRlc2NyaXB0aW9uOiBcIlN5c3RlbSBuYW1lIHVzZWQgdG8gcmFuZG9taXplIHRoZSByZXNvdXJjZXNcIixcbiAgICB9KTtcblxuICAgIHRoaXMubmFtZSA9IG5hbWUudmFsdWU7XG4gIH1cbn1cbiJdfQ==
+function execTerraformCommand(command, opts, streamOutput) {
+    try {
+        if (streamOutput) {
+            (0, child_process_1.execSync)(command, { ...opts, stdio: "inherit" });
+            return { stdout: "", stderr: "", exitCode: 0 };
+        }
+        else {
+            const stdout = (0, child_process_1.execSync)(command, { ...opts, stdio: "pipe" }).toString();
+            return { stdout, stderr: "", exitCode: 0 };
+        }
+    }
+    catch (error) {
+        const stdout = error.stdout ? error.stdout.toString() : "";
+        const stderr = error.stderr ? error.stderr.toString() : "";
+        return { stdout, stderr, exitCode: error.status || 1 };
+    }
+}
+exports.execTerraformCommand = execTerraformCommand;
+function TerraformApply(stack, streamOutput = false) {
+    try {
+        const manifest = JSON.parse(fs.readFileSync(path.resolve(stack, "manifest.json"), "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                encoding: "utf-8",
+            };
+            const initResult = execTerraformCommand(`terraform init`, opts, streamOutput);
+            if (initResult.exitCode !== 0)
+                throw new Error(`Terraform init failed: ${initResult.stdout} ${initResult.stderr}`);
+            const applyResult = execTerraformCommand(`terraform apply -auto-approve`, opts, streamOutput);
+            if (applyResult.exitCode !== 0) {
+                return {
+                    stdout: applyResult.stdout,
+                    stderr: applyResult.stderr,
+                    error: new Error(`Terraform apply failed: ${applyResult.stdout} ${applyResult.stderr}`),
+                };
+            }
+        }
+        return { stdout: "Terraform apply succeeded", stderr: "", error: null };
+    }
+    catch (error) {
+        console.error("Error during Terraform init or apply:", error);
+        return { stdout: "", stderr: "", error };
+    }
+}
+exports.TerraformApply = TerraformApply;
+function TerraformPlanExitCode(stack, streamOutput = false) {
+    try {
+        const manifest = JSON.parse(fs.readFileSync(path.resolve(stack, "manifest.json"), "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                encoding: "utf-8",
+            };
+            const initResult = execTerraformCommand(`terraform init`, opts, streamOutput);
+            if (initResult.exitCode !== 0)
+                throw new Error(`Terraform init failed: ${initResult.stdout} ${initResult.stderr}`);
+            const planResult = execTerraformCommand(`terraform plan -input=false -lock=false -detailed-exitcode`, opts, streamOutput);
+            return {
+                stdout: planResult.stdout,
+                stderr: planResult.stderr,
+                exitCode: planResult.exitCode,
+                error: null,
+            };
+        }
+        return {
+            stdout: "Terraform plan succeeded",
+            stderr: "",
+            exitCode: 0,
+            error: null,
+        };
+    }
+    catch (error) {
+        console.error("Error during Terraform init or plan:", error);
+        return { stdout: "", stderr: "", exitCode: 1, error };
+    }
+}
+exports.TerraformPlanExitCode = TerraformPlanExitCode;
+function TerraformIdempotentCheck(stack) {
+    try {
+        const manifest = JSON.parse(fs.readFileSync(path.resolve(stack, "manifest.json"), "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                stdio: "pipe",
+            };
+            (0, child_process_1.execSync)(`terraform init`, opts);
+            let planOutput;
+            try {
+                planOutput = (0, child_process_1.execSync)(`terraform plan -input=false -detailed-exitcode`, opts).toString();
+            }
+            catch (error) {
+                planOutput = error.stdout ? error.stdout.toString() : "";
+            }
+            if (planOutput.includes("No changes. Your infrastructure matches the configuration.")) {
+                return new AssertionReturn(`Expected subject to be idempotent with no changes`, true);
+            }
+            else {
+                throw new Error(`Plan resulted in changes:\n${planOutput}`);
+            }
+        }
+        return new AssertionReturn(`Expected subject to be idempotent with no changes`, true);
+    }
+    catch (error) {
+        console.error("Error during Terraform init or plan:", error);
+        throw error;
+    }
+}
+exports.TerraformIdempotentCheck = TerraformIdempotentCheck;
+function TerraformDestroy(stack, streamOutput = false) {
+    try {
+        const manifest = JSON.parse(fs.readFileSync(path.resolve(stack, "manifest.json"), "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        for (const [, stackDetails] of stacks) {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                encoding: "utf-8",
+            };
+            const initResult = execTerraformCommand(`terraform init`, opts, streamOutput);
+            if (initResult.exitCode !== 0)
+                throw new Error(`Terraform init failed: ${initResult.stdout} ${initResult.stderr}`);
+            const destroyResult = execTerraformCommand(`terraform destroy -auto-approve`, opts, streamOutput);
+            if (destroyResult.exitCode !== 0)
+                throw new Error(`Terraform destroy failed: ${destroyResult.stdout} ${destroyResult.stderr}`);
+        }
+        return new AssertionReturn(`Expected subject to destroy successfully`, true);
+    }
+    catch (error) {
+        console.error("Error during Terraform init or destroy:", error);
+        return new AssertionReturn(`Expected subject to destroy successfully`, false);
+    }
+}
+exports.TerraformDestroy = TerraformDestroy;
+function TerraformApplyAndCheckIdempotency(stack, streamOutput = false) {
+    const applyResult = TerraformApply(stack, streamOutput);
+    if (applyResult.error) {
+        return new AssertionReturn(applyResult.error.message, false);
+    }
+    const planResult = TerraformPlanExitCode(stack, streamOutput);
+    if (planResult.error) {
+        return new AssertionReturn(planResult.error.message, false);
+    }
+    if (planResult.exitCode !== 0) {
+        return new AssertionReturn(`Terraform configuration not idempotent:\n${planResult.stdout}`, false);
+    }
+    return new AssertionReturn(`Terraform apply and idempotency check completed successfully`, true);
+}
+exports.TerraformApplyAndCheckIdempotency = TerraformApplyAndCheckIdempotency;
+function TerraformApplyCheckAndDestroy(stack) {
+    try {
+        const applyAndCheckResult = TerraformApplyAndCheckIdempotency(stack);
+        if (!applyAndCheckResult.pass) {
+            throw new Error(applyAndCheckResult.message);
+        }
+    }
+    catch (error) {
+        console.error("Error during Terraform apply and idempotency check:", error);
+        throw error; // Re-throw the error to ensure the test fails
+    }
+    finally {
+        try {
+            const destroyResult = TerraformDestroy(stack);
+            if (!destroyResult.pass) {
+                console.error("Error during Terraform destroy:", destroyResult.message);
+            }
+        }
+        catch (destroyError) {
+            console.error("Error during Terraform destroy:", destroyError);
+        }
+    }
+}
+exports.TerraformApplyCheckAndDestroy = TerraformApplyCheckAndDestroy;
+function TerraformPlan(stack) {
+    try {
+        // Assuming the presence of a received variable pointing to the relevant directory
+        const manifest = JSON.parse(fs.readFileSync(path.resolve(stack, "manifest.json"), "utf8"));
+        const stacks = Object.entries(manifest.stacks);
+        stacks.forEach(([, stackDetails]) => {
+            const opts = {
+                cwd: path.resolve(stack, stackDetails.workingDirectory),
+                env: process.env,
+                stdio: "pipe",
+            };
+            (0, child_process_1.execSync)(`terraform init`, opts);
+            (0, child_process_1.execSync)(`terraform plan -input=false -lock=false`, opts);
+        });
+        return new AssertionReturn(`Expected subject not to plan successfully`, true);
+    }
+    catch (error) {
+        console.error("Error during Terraform init or plan:", error);
+        throw error;
+        return new AssertionReturn("Expected subject to plan successfully, false", false);
+    }
+}
+exports.TerraformPlan = TerraformPlan;
+class AssertionReturn {
+    /**
+     * Create an AssertionReturn
+     * @param message - String message containing information about the result of the assertion
+     * @param pass - Boolean pass denoting the success of the assertion
+     */
+    constructor(message, pass) {
+        this.message = message;
+        this.pass = pass;
+        if (!pass) {
+            throw new Error(message);
+        }
+    }
+}
+exports.AssertionReturn = AssertionReturn;
+// Define a cleanup function that can be exported and used in tests.
+function cleanupCdkTfOutDirs() {
+    try {
+        (0, child_process_1.execSync)('find /tmp -name "cdktf.outdir.*" -type d -exec rm -rf {} +');
+        // console.log(
+        //   "Cleanup of cdktf.outdir.* directories in /tmp was successful.",
+        // );
+    }
+    catch (error) {
+        console.error("Error during cleanup:", error);
+    }
+}
+exports.cleanupCdkTfOutDirs = cleanupCdkTfOutDirs;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { execSync, ExecSyncOptionsWithStringEncoding } from \"child_process\";\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport * as cdktf from \"cdktf\";\nimport { TerraformStack } from \"cdktf\";\nimport { Construct } from \"constructs\";\n\nexport class BaseTestStack extends TerraformStack {\n  public readonly name: string;\n\n  constructor(scope: Construct, id: string) {\n    super(scope, id);\n\n    const name = new cdktf.TerraformVariable(this, \"name\", {\n      type: \"string\",\n      default: \"test\",\n      description: \"System name used to randomize the resources\",\n    });\n\n    this.name = name.value;\n  }\n}\n\nexport function execTerraformCommand(\n  command: string,\n  opts: ExecSyncOptionsWithStringEncoding,\n  streamOutput: boolean,\n): { stdout: string; stderr: string; exitCode: number } {\n  try {\n    if (streamOutput) {\n      execSync(command, { ...opts, stdio: \"inherit\" });\n      return { stdout: \"\", stderr: \"\", exitCode: 0 };\n    } else {\n      const stdout = execSync(command, { ...opts, stdio: \"pipe\" }).toString();\n      return { stdout, stderr: \"\", exitCode: 0 };\n    }\n  } catch (error: any) {\n    const stdout = error.stdout ? error.stdout.toString() : \"\";\n    const stderr = error.stderr ? error.stderr.toString() : \"\";\n    return { stdout, stderr, exitCode: error.status || 1 };\n  }\n}\n\nexport function TerraformApply(\n  stack: any,\n  streamOutput: boolean = false,\n): { stdout: string; stderr: string; error: any } {\n  try {\n    const manifest = JSON.parse(\n      fs.readFileSync(path.resolve(stack, \"manifest.json\"), \"utf8\"),\n    );\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts: ExecSyncOptionsWithStringEncoding = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        encoding: \"utf-8\",\n      };\n\n      const initResult = execTerraformCommand(\n        `terraform init`,\n        opts,\n        streamOutput,\n      );\n      if (initResult.exitCode !== 0)\n        throw new Error(\n          `Terraform init failed: ${initResult.stdout} ${initResult.stderr}`,\n        );\n\n      const applyResult = execTerraformCommand(\n        `terraform apply -auto-approve`,\n        opts,\n        streamOutput,\n      );\n      if (applyResult.exitCode !== 0) {\n        return {\n          stdout: applyResult.stdout,\n          stderr: applyResult.stderr,\n          error: new Error(\n            `Terraform apply failed: ${applyResult.stdout} ${applyResult.stderr}`,\n          ),\n        };\n      }\n    }\n\n    return { stdout: \"Terraform apply succeeded\", stderr: \"\", error: null };\n  } catch (error: any) {\n    console.error(\"Error during Terraform init or apply:\", error);\n    return { stdout: \"\", stderr: \"\", error };\n  }\n}\n\nexport function TerraformPlanExitCode(\n  stack: any,\n  streamOutput: boolean = false,\n): { stdout: string; stderr: string; exitCode: number; error: any } {\n  try {\n    const manifest = JSON.parse(\n      fs.readFileSync(path.resolve(stack, \"manifest.json\"), \"utf8\"),\n    );\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts: ExecSyncOptionsWithStringEncoding = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        encoding: \"utf-8\",\n      };\n\n      const initResult = execTerraformCommand(\n        `terraform init`,\n        opts,\n        streamOutput,\n      );\n      if (initResult.exitCode !== 0)\n        throw new Error(\n          `Terraform init failed: ${initResult.stdout} ${initResult.stderr}`,\n        );\n\n      const planResult = execTerraformCommand(\n        `terraform plan -input=false -lock=false -detailed-exitcode`,\n        opts,\n        streamOutput,\n      );\n      return {\n        stdout: planResult.stdout,\n        stderr: planResult.stderr,\n        exitCode: planResult.exitCode,\n        error: null,\n      };\n    }\n\n    return {\n      stdout: \"Terraform plan succeeded\",\n      stderr: \"\",\n      exitCode: 0,\n      error: null,\n    };\n  } catch (error: any) {\n    console.error(\"Error during Terraform init or plan:\", error);\n    return { stdout: \"\", stderr: \"\", exitCode: 1, error };\n  }\n}\nexport function TerraformIdempotentCheck(stack: any): AssertionReturn {\n  try {\n    const manifest = JSON.parse(\n      fs.readFileSync(path.resolve(stack, \"manifest.json\"), \"utf8\"),\n    );\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        stdio: \"pipe\",\n      } as any;\n\n      execSync(`terraform init`, opts);\n\n      let planOutput: string;\n      try {\n        planOutput = execSync(\n          `terraform plan -input=false -detailed-exitcode`,\n          opts,\n        ).toString();\n      } catch (error: any) {\n        planOutput = error.stdout ? error.stdout.toString() : \"\";\n      }\n\n      if (\n        planOutput.includes(\n          \"No changes. Your infrastructure matches the configuration.\",\n        )\n      ) {\n        return new AssertionReturn(\n          `Expected subject to be idempotent with no changes`,\n          true,\n        );\n      } else {\n        throw new Error(`Plan resulted in changes:\\n${planOutput}`);\n      }\n    }\n\n    return new AssertionReturn(\n      `Expected subject to be idempotent with no changes`,\n      true,\n    );\n  } catch (error) {\n    console.error(\"Error during Terraform init or plan:\", error);\n    throw error;\n  }\n}\n\nexport function TerraformDestroy(\n  stack: any,\n  streamOutput: boolean = false,\n): AssertionReturn {\n  try {\n    const manifest = JSON.parse(\n      fs.readFileSync(path.resolve(stack, \"manifest.json\"), \"utf8\"),\n    );\n    const stacks = Object.entries(manifest.stacks);\n\n    for (const [, stackDetails] of stacks) {\n      const opts: ExecSyncOptionsWithStringEncoding = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        encoding: \"utf-8\",\n      };\n\n      const initResult = execTerraformCommand(\n        `terraform init`,\n        opts,\n        streamOutput,\n      );\n      if (initResult.exitCode !== 0)\n        throw new Error(\n          `Terraform init failed: ${initResult.stdout} ${initResult.stderr}`,\n        );\n\n      const destroyResult = execTerraformCommand(\n        `terraform destroy -auto-approve`,\n        opts,\n        streamOutput,\n      );\n      if (destroyResult.exitCode !== 0)\n        throw new Error(\n          `Terraform destroy failed: ${destroyResult.stdout} ${destroyResult.stderr}`,\n        );\n    }\n\n    return new AssertionReturn(\n      `Expected subject to destroy successfully`,\n      true,\n    );\n  } catch (error: any) {\n    console.error(\"Error during Terraform init or destroy:\", error);\n    return new AssertionReturn(\n      `Expected subject to destroy successfully`,\n      false,\n    );\n  }\n}\n\nexport function TerraformApplyAndCheckIdempotency(\n  stack: any,\n  streamOutput: boolean = false,\n): AssertionReturn {\n  const applyResult = TerraformApply(stack, streamOutput);\n  if (applyResult.error) {\n    return new AssertionReturn(applyResult.error.message, false);\n  }\n\n  const planResult = TerraformPlanExitCode(stack, streamOutput);\n  if (planResult.error) {\n    return new AssertionReturn(planResult.error.message, false);\n  }\n\n  if (planResult.exitCode !== 0) {\n    return new AssertionReturn(\n      `Terraform configuration not idempotent:\\n${planResult.stdout}`,\n      false,\n    );\n  }\n\n  return new AssertionReturn(\n    `Terraform apply and idempotency check completed successfully`,\n    true,\n  );\n}\n\nexport function TerraformApplyCheckAndDestroy(stack: any): void {\n  try {\n    const applyAndCheckResult = TerraformApplyAndCheckIdempotency(stack);\n    if (!applyAndCheckResult.pass) {\n      throw new Error(applyAndCheckResult.message);\n    }\n  } catch (error) {\n    console.error(\"Error during Terraform apply and idempotency check:\", error);\n    throw error; // Re-throw the error to ensure the test fails\n  } finally {\n    try {\n      const destroyResult = TerraformDestroy(stack);\n      if (!destroyResult.pass) {\n        console.error(\"Error during Terraform destroy:\", destroyResult.message);\n      }\n    } catch (destroyError) {\n      console.error(\"Error during Terraform destroy:\", destroyError);\n    }\n  }\n}\n\nexport function TerraformPlan(stack: any): AssertionReturn {\n  try {\n    // Assuming the presence of a received variable pointing to the relevant directory\n    const manifest = JSON.parse(\n      fs.readFileSync(path.resolve(stack, \"manifest.json\"), \"utf8\"),\n    );\n    const stacks = Object.entries(manifest.stacks);\n    stacks.forEach(([, stackDetails]) => {\n      const opts = {\n        cwd: path.resolve(stack, (stackDetails as any).workingDirectory),\n        env: process.env,\n        stdio: \"pipe\",\n      } as any;\n      execSync(`terraform init`, opts);\n      execSync(`terraform plan -input=false -lock=false`, opts);\n    });\n\n    return new AssertionReturn(\n      `Expected subject not to plan successfully`,\n      true,\n    );\n  } catch (error) {\n    console.error(\"Error during Terraform init or plan:\", error);\n    throw error;\n    return new AssertionReturn(\n      \"Expected subject to plan successfully, false\",\n      false,\n    );\n  }\n}\n\nexport class AssertionReturn {\n  /**\n   * Create an AssertionReturn\n   * @param message - String message containing information about the result of the assertion\n   * @param pass - Boolean pass denoting the success of the assertion\n   */\n  constructor(\n    public readonly message: string,\n    public readonly pass: boolean,\n  ) {\n    if (!pass) {\n      throw new Error(message);\n    }\n  }\n}\n\n// Define a cleanup function that can be exported and used in tests.\nexport function cleanupCdkTfOutDirs() {\n  try {\n    execSync('find /tmp -name \"cdktf.outdir.*\" -type d -exec rm -rf {} +');\n    // console.log(\n    //   \"Cleanup of cdktf.outdir.* directories in /tmp was successful.\",\n    // );\n  } catch (error) {\n    console.error(\"Error during cleanup:\", error);\n  }\n}\n"]}

package/package.json

@@ -17,18 +17,23 @@
     "eslint": "npx projen eslint",
     "package": "npx projen package",
     "package-all": "npx projen package-all",
+    "package:dotnet": "npx projen package:dotnet",
+    "package:java": "npx projen package:java",
     "package:js": "npx projen package:js",
+    "package:python": "npx projen package:python",
     "post-compile": "npx projen post-compile",
     "post-upgrade": "npx projen post-upgrade",
     "pre-compile": "npx projen pre-compile",
     "release": "npx projen release",
-    "test": "npx projen test",
+    "test": "jest --testMatch '**/*.spec.ts'",
     "test:update": "npx projen test:update",
     "test:watch": "npx projen test:watch",
     "unbump": "npx projen unbump",
     "upgrade": "npx projen upgrade",
     "watch": "npx projen watch",
     "projen": "npx projen",
+    "integration": "STREAM_OUTPUT=true jest --testMatch '**/*.integ.ts'",
+    "integration:nostream": "STREAM_OUTPUT=false jest --maxWorkers=12 --testMatch '**/*.integ.ts'",
     "generate-index": "node ./scripts/generate-index.js"
   },
   "author": {
@@ -38,7 +43,7 @@
   },
   "devDependencies": {
     "@cdktf/provider-azurerm": "9.0.8",
-    "@types/jest": "^29.5.11",
+    "@types/jest": "^29.5.12",
     "@types/moment": "^2.13.0",
     "@types/node": "^20",
     "@typescript-eslint/eslint-plugin": "^6",
@@ -53,14 +58,14 @@
     "jest": "^29.7.0",
     "jest-junit": "^15",
     "jsii": "~5.2.0",
-    "jsii-diff": "^1.94.0",
-    "jsii-docgen": "^10.3.9",
-    "jsii-pacmak": "^1.94.0",
+    "jsii-diff": "^1.98.0",
+    "jsii-docgen": "^10.4.9",
+    "jsii-pacmak": "^1.98.0",
     "jsii-rosetta": "~5.2.0",
-    "prettier": "^3.2.4",
-    "projen": "^0.79.1",
+    "prettier": "^3.2.5",
+    "projen": "^0.81.15",
     "standard-version": "^9",
-    "ts-jest": "^29.1.1",
+    "ts-jest": "^29.1.3",
     "ts-node": "^10.9.2",
     "typescript": "~5.2.0"
   },
@@ -98,11 +103,11 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.3-pre.10",
+  "version": "0.0.3-pre.12",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",
-      "<rootDir>/(|src)/**/*(*.)@(spec|test).ts?(x)"
+      "<rootDir>/@(|src)/**/*(*.)@(spec|test|integ).ts?(x)"
     ],
     "clearMocks": true,
     "collectCoverage": true,
@@ -150,7 +155,23 @@
   "stability": "stable",
   "jsii": {
     "outdir": "dist",
-    "targets": {},
+    "targets": {
+      "java": {
+        "package": "com.microsoft.terraformcdkconstructs",
+        "maven": {
+          "groupId": "com.microsoft.terraformcdkconstructs",
+          "artifactId": "cdktf-azure-constructs"
+        }
+      },
+      "python": {
+        "distName": "microsoft-cdktfconstructs",
+        "module": "microsoft_cdktfconstructs"
+      },
+      "dotnet": {
+        "namespace": "Microsoft.Cdktf.Azure.TFConstructs",
+        "packageId": "Microsoft.Cdktf.Azure.TFConstructs"
+      }
+    },
     "tsc": {
       "outDir": "lib",
       "rootDir": "src"

package/cdktf.out/manifest.json

@@ -1,13 +0,0 @@
-{
-  "version": "0.17.3",
-  "stacks": {
-    "testExampleAzureResource": {
-      "name": "testExampleAzureResource",
-      "constructPath": "testExampleAzureResource",
-      "workingDirectory": "stacks/testExampleAzureResource",
-      "synthesizedStackPath": "stacks/testExampleAzureResource/cdk.tf.json",
-      "annotations": [],
-      "dependencies": []
-    }
-  }
-}