@microsoft/terraform-cdk-constructs 1.0.0 → 1.2.0

package/lib/azure-virtualmachine/test/virtual-machine.integ.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * Integration test for Azure Virtual Machine
+ *
+ * This test demonstrates comprehensive usage of the VirtualMachine construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Run with: npm run integration:nostream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktf_1 = require("cdktf");
+require("cdktf/lib/testing/adapters/jest");
+const azure_actiongroup_1 = require("../../azure-actiongroup");
+const azure_networkinterface_1 = require("../../azure-networkinterface");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const azure_subnet_1 = require("../../azure-subnet");
+const azure_virtualnetwork_1 = require("../../azure-virtualnetwork");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const testing_1 = require("../../testing");
+const metadata_1 = require("../../testing/lib/metadata");
+const virtual_machine_1 = require("../lib/virtual-machine");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("virtual-machine-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating comprehensive Virtual Machine usage
+ */
+class VirtualMachineExampleStack extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id, {
+            testRunOptions: {
+                maxAgeHours: testMetadata.maxAgeHours,
+                autoCleanup: testMetadata.autoCleanup,
+                cleanupPolicy: testMetadata.cleanupPolicy,
+            },
+        });
+        // Configure AZAPI provider
+        new provider_1.AzapiProvider(this, "azapi", {});
+        // Generate unique names
+        const rgName = this.generateResourceName("Microsoft.Resources/resourceGroups", "vm");
+        // Create a resource group
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "example-rg", {
+            name: rgName,
+            location: "eastus2",
+            tags: {
+                ...this.systemTags(),
+            },
+        });
+        // Create Action Group for monitoring
+        const actionGroup = new azure_actiongroup_1.ActionGroup(this, "example-action-group", {
+            name: "vm-monitoring-action-group",
+            resourceGroupId: resourceGroup.id,
+            location: "global",
+            groupShortName: "vmmon",
+            emailReceivers: [
+                {
+                    name: "admin-email",
+                    emailAddress: "admin@example.com",
+                    useCommonAlertSchema: true,
+                },
+            ],
+        });
+        // Create virtual network
+        const vnet = new azure_virtualnetwork_1.VirtualNetwork(this, "example-vnet", {
+            name: "vm-vnet",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            addressSpace: {
+                addressPrefixes: ["10.0.0.0/16"],
+            },
+        });
+        // Create subnet with explicit VNet dependency
+        const subnet = new azure_subnet_1.Subnet(this, "example-subnet", {
+            name: "vm-subnet",
+            resourceGroupId: resourceGroup.id,
+            virtualNetworkName: vnet.props.name,
+            virtualNetworkId: vnet.id, // Creates explicit Terraform dependency
+            addressPrefix: "10.0.1.0/24",
+        });
+        // Create network interface for Linux VM
+        const linuxNic = new azure_networkinterface_1.NetworkInterface(this, "linux-nic", {
+            name: "linux-nic",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            ipConfigurations: [
+                {
+                    name: "ipconfig1",
+                    subnet: { id: subnet.id },
+                    privateIPAllocationMethod: "Dynamic",
+                    primary: true,
+                },
+            ],
+        });
+        // Create network interface for Windows VM
+        const windowsNic = new azure_networkinterface_1.NetworkInterface(this, "windows-nic", {
+            name: "windows-nic",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            ipConfigurations: [
+                {
+                    name: "ipconfig1",
+                    subnet: { id: subnet.id },
+                    privateIPAllocationMethod: "Dynamic",
+                    primary: true,
+                },
+            ],
+        });
+        // Linux VM with SSH authentication and integrated monitoring
+        new virtual_machine_1.VirtualMachine(this, "linux-vm", {
+            name: "linuxvm",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            hardwareProfile: {
+                vmSize: "Standard_B1s", // Smallest size for cost efficiency
+            },
+            storageProfile: {
+                imageReference: {
+                    publisher: "Canonical",
+                    offer: "0001-com-ubuntu-server-jammy",
+                    sku: "22_04-lts-gen2",
+                    version: "latest",
+                },
+                osDisk: {
+                    createOption: "FromImage",
+                    managedDisk: {
+                        storageAccountType: "Standard_LRS",
+                    },
+                    diskSizeGB: 30,
+                },
+            },
+            osProfile: {
+                computerName: "linuxvm",
+                adminUsername: "azureuser",
+                adminPassword: "P@ssw0rd1234!SecurePassword",
+                linuxConfiguration: {
+                    disablePasswordAuthentication: false,
+                },
+            },
+            networkProfile: {
+                networkInterfaces: [
+                    {
+                        id: linuxNic.id,
+                    },
+                ],
+            },
+            identity: {
+                type: "SystemAssigned",
+            },
+            tags: {
+                ...this.systemTags(),
+                os: "linux",
+                example: "basic",
+                monitoring: "enabled",
+                azsecpack: "nonprod", // Required by Azure Policy
+            },
+            monitoring: virtual_machine_1.VirtualMachine.defaultMonitoring(actionGroup.id),
+        });
+        // Windows VM with password authentication
+        new virtual_machine_1.VirtualMachine(this, "windows-vm", {
+            name: "windowsvm",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            hardwareProfile: {
+                vmSize: "Standard_B2s", // Slightly larger for Windows
+            },
+            storageProfile: {
+                imageReference: {
+                    publisher: "MicrosoftWindowsServer",
+                    offer: "WindowsServer",
+                    sku: "2022-datacenter-azure-edition-core-smalldisk",
+                    version: "latest",
+                },
+                osDisk: {
+                    createOption: "FromImage",
+                    managedDisk: {
+                        storageAccountType: "Standard_LRS",
+                    },
+                    diskSizeGB: 64,
+                },
+            },
+            osProfile: {
+                computerName: "windowsvm",
+                adminUsername: "azureuser",
+                adminPassword: "P@ssw0rd1234!SecurePassword",
+                windowsConfiguration: {
+                    provisionVMAgent: true,
+                    enableAutomaticUpdates: true,
+                },
+            },
+            networkProfile: {
+                networkInterfaces: [
+                    {
+                        id: windowsNic.id,
+                    },
+                ],
+            },
+            licenseType: "Windows_Server",
+            tags: {
+                ...this.systemTags(),
+                os: "windows",
+                example: "basic",
+                azsecpack: "nonprod", // Required by Azure Policy
+            },
+        });
+    }
+}
+describe("Virtual Machine Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup Virtual Machine resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new VirtualMachineExampleStack(app, "test-virtual-machine");
+        const synthesized = cdktf_1.Testing.fullSynth(stack);
+        // This will:
+        // 1. Run terraform apply to deploy resources
+        // 2. Run terraform plan to check idempotency (no changes expected)
+        // 3. Run terraform destroy to cleanup resources
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
+    }, 900000); // 15 minute timeout for VM deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-machine.integ.js","sourceRoot":"","sources":["../../../src/azure-virtualmachine/test/virtual-machine.integ.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Integration test for Azure Virtual Machine\n *\n * This test demonstrates comprehensive usage of the VirtualMachine construct\n * and validates deployment, idempotency, and cleanup.\n *\n * Run with: npm run integration:nostream\n */\n\nimport { Testing } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport \"cdktf/lib/testing/adapters/jest\";\nimport { ActionGroup } from \"../../azure-actiongroup\";\nimport { NetworkInterface } from \"../../azure-networkinterface\";\nimport { ResourceGroup } from \"../../azure-resourcegroup\";\nimport { Subnet } from \"../../azure-subnet\";\nimport { VirtualNetwork } from \"../../azure-virtualnetwork\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { VirtualMachine } from \"../lib/virtual-machine\";\n\n// Generate unique test run metadata for this test suite\nconst testMetadata = new TestRunMetadata(\"virtual-machine-integration\", {\n  maxAgeHours: 4,\n});\n\n/**\n * Example stack demonstrating comprehensive Virtual Machine usage\n */\nclass VirtualMachineExampleStack extends BaseTestStack {\n  constructor(scope: Construct, id: string) {\n    super(scope, id, {\n      testRunOptions: {\n        maxAgeHours: testMetadata.maxAgeHours,\n        autoCleanup: testMetadata.autoCleanup,\n        cleanupPolicy: testMetadata.cleanupPolicy,\n      },\n    });\n\n    // Configure AZAPI provider\n    new AzapiProvider(this, \"azapi\", {});\n\n    // Generate unique names\n    const rgName = this.generateResourceName(\n      \"Microsoft.Resources/resourceGroups\",\n      \"vm\",\n    );\n\n    // Create a resource group\n    const resourceGroup = new ResourceGroup(this, \"example-rg\", {\n      name: rgName,\n      location: \"eastus2\",\n      tags: {\n        ...this.systemTags(),\n      },\n    });\n\n    // Create Action Group for monitoring\n    const actionGroup = new ActionGroup(this, \"example-action-group\", {\n      name: \"vm-monitoring-action-group\",\n      resourceGroupId: resourceGroup.id,\n      location: \"global\",\n      groupShortName: \"vmmon\",\n      emailReceivers: [\n        {\n          name: \"admin-email\",\n          emailAddress: \"admin@example.com\",\n          useCommonAlertSchema: true,\n        },\n      ],\n    });\n\n    // Create virtual network\n    const vnet = new VirtualNetwork(this, \"example-vnet\", {\n      name: \"vm-vnet\",\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      addressSpace: {\n        addressPrefixes: [\"10.0.0.0/16\"],\n      },\n    });\n\n    // Create subnet with explicit VNet dependency\n    const subnet = new Subnet(this, \"example-subnet\", {\n      name: \"vm-subnet\",\n      resourceGroupId: resourceGroup.id,\n      virtualNetworkName: vnet.props.name!,\n      virtualNetworkId: vnet.id, // Creates explicit Terraform dependency\n      addressPrefix: \"10.0.1.0/24\",\n    });\n\n    // Create network interface for Linux VM\n    const linuxNic = new NetworkInterface(this, \"linux-nic\", {\n      name: \"linux-nic\",\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      ipConfigurations: [\n        {\n          name: \"ipconfig1\",\n          subnet: { id: subnet.id },\n          privateIPAllocationMethod: \"Dynamic\",\n          primary: true,\n        },\n      ],\n    });\n\n    // Create network interface for Windows VM\n    const windowsNic = new NetworkInterface(this, \"windows-nic\", {\n      name: \"windows-nic\",\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      ipConfigurations: [\n        {\n          name: \"ipconfig1\",\n          subnet: { id: subnet.id },\n          privateIPAllocationMethod: \"Dynamic\",\n          primary: true,\n        },\n      ],\n    });\n\n    // Linux VM with SSH authentication and integrated monitoring\n    new VirtualMachine(this, \"linux-vm\", {\n      name: \"linuxvm\",\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      hardwareProfile: {\n        vmSize: \"Standard_B1s\", // Smallest size for cost efficiency\n      },\n      storageProfile: {\n        imageReference: {\n          publisher: \"Canonical\",\n          offer: \"0001-com-ubuntu-server-jammy\",\n          sku: \"22_04-lts-gen2\",\n          version: \"latest\",\n        },\n        osDisk: {\n          createOption: \"FromImage\",\n          managedDisk: {\n            storageAccountType: \"Standard_LRS\",\n          },\n          diskSizeGB: 30,\n        },\n      },\n      osProfile: {\n        computerName: \"linuxvm\",\n        adminUsername: \"azureuser\",\n        adminPassword: \"P@ssw0rd1234!SecurePassword\",\n        linuxConfiguration: {\n          disablePasswordAuthentication: false,\n        },\n      },\n      networkProfile: {\n        networkInterfaces: [\n          {\n            id: linuxNic.id,\n          },\n        ],\n      },\n      identity: {\n        type: \"SystemAssigned\",\n      },\n      tags: {\n        ...this.systemTags(),\n        os: \"linux\",\n        example: \"basic\",\n        monitoring: \"enabled\",\n        azsecpack: \"nonprod\", // Required by Azure Policy\n      },\n      monitoring: VirtualMachine.defaultMonitoring(actionGroup.id),\n    });\n\n    // Windows VM with password authentication\n    new VirtualMachine(this, \"windows-vm\", {\n      name: \"windowsvm\",\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      hardwareProfile: {\n        vmSize: \"Standard_B2s\", // Slightly larger for Windows\n      },\n      storageProfile: {\n        imageReference: {\n          publisher: \"MicrosoftWindowsServer\",\n          offer: \"WindowsServer\",\n          sku: \"2022-datacenter-azure-edition-core-smalldisk\",\n          version: \"latest\",\n        },\n        osDisk: {\n          createOption: \"FromImage\",\n          managedDisk: {\n            storageAccountType: \"Standard_LRS\",\n          },\n          diskSizeGB: 64,\n        },\n      },\n      osProfile: {\n        computerName: \"windowsvm\",\n        adminUsername: \"azureuser\",\n        adminPassword: \"P@ssw0rd1234!SecurePassword\",\n        windowsConfiguration: {\n          provisionVMAgent: true,\n          enableAutomaticUpdates: true,\n        },\n      },\n      networkProfile: {\n        networkInterfaces: [\n          {\n            id: windowsNic.id,\n          },\n        ],\n      },\n      licenseType: \"Windows_Server\",\n      tags: {\n        ...this.systemTags(),\n        os: \"windows\",\n        example: \"basic\",\n        azsecpack: \"nonprod\", // Required by Azure Policy\n      },\n    });\n  }\n}\n\ndescribe(\"Virtual Machine Integration Test\", () => {\n  it(\"should deploy, validate idempotency, and cleanup Virtual Machine resources\", () => {\n    const app = Testing.app();\n    const stack = new VirtualMachineExampleStack(app, \"test-virtual-machine\");\n    const synthesized = Testing.fullSynth(stack);\n\n    // This will:\n    // 1. Run terraform apply to deploy resources\n    // 2. Run terraform plan to check idempotency (no changes expected)\n    // 3. Run terraform destroy to cleanup resources\n    TerraformApplyCheckAndDestroy(synthesized, { verifyCleanup: true });\n  }, 900000); // 15 minute timeout for VM deployment and cleanup\n});\n"]}

package/lib/azure-virtualmachine/test/virtual-machine.spec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Comprehensive tests for the unified VirtualMachine implementation
+ *
+ * This test suite validates the unified VirtualMachine class that replaces all
+ * version-specific implementations using the VersionedAzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * property transformation, and full backward compatibility.
+ */
+export {};