@microsoft/terraform-cdk-constructs 0.0.3-pre.7 → 1.2.0

package/lib/azure-vmss/test/virtual-machine-scale-set.integ.js

@@ -0,0 +1,261 @@
+"use strict";
+/**
+ * Integration test for Azure Virtual Machine Scale Set
+ *
+ * This test demonstrates key usage patterns of the VirtualMachineScaleSet construct
+ * and validates deployment, idempotency, and cleanup.
+ *
+ * Test Coverage:
+ * - Uniform orchestration mode with monitoring and SSH authentication
+ * - Flexible orchestration mode with password authentication
+ * - Monitoring integration with custom thresholds
+ * - Automatic network API version resolution
+ *
+ * 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_resourcegroup_1 = require("../../azure-resourcegroup");
+const azure_subnet_1 = require("../../azure-subnet");
+const azure_virtualnetwork_1 = require("../../azure-virtualnetwork");
+const data_azapi_client_config_1 = require("../../core-azure/lib/azapi/providers-azapi/data-azapi-client-config");
+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_scale_set_1 = require("../lib/virtual-machine-scale-set");
+// Generate unique test run metadata for this test suite
+const testMetadata = new metadata_1.TestRunMetadata("vmss-integration", {
+    maxAgeHours: 4,
+});
+/**
+ * Example stack demonstrating comprehensive Virtual Machine Scale Set usage
+ */
+class VirtualMachineScaleSetExampleStack 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", "vmss");
+        // Create a resource group
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "example-rg", {
+            name: rgName,
+            location: "eastus2",
+            tags: {
+                ...this.systemTags(),
+            },
+        });
+        // Create virtual network
+        const vnet = new azure_virtualnetwork_1.VirtualNetwork(this, "example-vnet", {
+            name: "vmss-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: "vmss-subnet",
+            resourceGroupId: resourceGroup.id,
+            virtualNetworkName: vnet.props.name,
+            virtualNetworkId: vnet.id, // Creates explicit Terraform dependency
+            addressPrefix: "10.0.1.0/24",
+        });
+        // Get current Azure client configuration for subscription ID
+        const clientConfig = new data_azapi_client_config_1.DataAzapiClientConfig(this, "current-client-config", {});
+        // Create Action Group for monitoring alerts
+        const actionGroup = new azure_actiongroup_1.ActionGroup(this, "vmss-action-group", {
+            name: "vmss-alerts",
+            location: "global",
+            resourceGroupId: resourceGroup.id,
+            groupShortName: "vmssalert",
+            emailReceivers: [
+                {
+                    name: "admin-email",
+                    emailAddress: "admin@example.com",
+                },
+            ],
+        });
+        // Create Log Analytics Workspace for diagnostics (simple inline resource)
+        // Note: Using a simplified workspace creation for testing purposes
+        const workspaceId = `\${${clientConfig.fqn}.subscription_id}/resourceGroups/${resourceGroup.props.name}/providers/Microsoft.OperationalInsights/workspaces/vmss-workspace`;
+        // Uniform VMSS with monitoring and SSH authentication
+        // Combines: basic uniform orchestration + monitoring + security features
+        new virtual_machine_scale_set_1.VirtualMachineScaleSet(this, "uniform-vmss", {
+            name: "uniformvmss",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            sku: {
+                name: "Standard_B1s", // Smallest size for cost efficiency
+                capacity: 2,
+            },
+            orchestrationMode: "Uniform",
+            upgradePolicy: {
+                mode: "Automatic",
+            },
+            virtualMachineProfile: {
+                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: {
+                    computerNamePrefix: "vmss-vm",
+                    adminUsername: "azureuser",
+                    linuxConfiguration: {
+                        disablePasswordAuthentication: true,
+                        ssh: {
+                            publicKeys: [
+                                {
+                                    path: "/home/azureuser/.ssh/authorized_keys",
+                                    // This is a dummy SSH public key for testing purposes only
+                                    // Generated with: ssh-keygen -t rsa -b 2048 -f /tmp/test_key (public key only)
+                                    keyData: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC3gkXHiCN4VNdmDlMrFK6Io5sDMV9e7S4xxqy9FoASXfLPe1BxIsqVRxfPhHRXmwgZReCZHl2/qFBUrWpRMSCG8MXx7bvqJDYlCZ9yvFLx0wZnFuQVvLLCMfJ1l4gRXXFmRVUFtWLzGlNQVKqGqKqJ1l6fPMM7O+VtxqZlhLRg3Qz0kD4xlZdHxqYxr/AHmBkQQ3vTx5dNh5qbX9kFRlRJFqhvDkqLh4L8jIgQfzJwpZwqzZ0Hj3rYvH2nHa2sJMbY8nBxJKlDdvQwCLh7CqB7x3Hv3k2K3TjvXBF9xMZvx8HwCvKlVZqPQ3VpGhHv3CvMkBvC2L3vKvMxB3vLxHK9 test-key-for-integration-tests",
+                                },
+                            ],
+                        },
+                    },
+                },
+                networkProfile: {
+                    networkInterfaceConfigurations: [
+                        {
+                            name: "nic-config",
+                            properties: {
+                                primary: true,
+                                ipConfigurations: [
+                                    {
+                                        name: "ip-config",
+                                        properties: {
+                                            subnet: {
+                                                id: subnet.id,
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                },
+            },
+            identity: {
+                type: "SystemAssigned",
+            },
+            overprovision: true,
+            // Add monitoring with custom thresholds to test monitoring integration
+            monitoring: virtual_machine_scale_set_1.VirtualMachineScaleSet.defaultMonitoring(actionGroup.id, workspaceId, {
+                cpuThreshold: 85,
+                memoryThreshold: 536870912, // 512MB
+                enableDiskQueueAlert: false,
+                cpuAlertSeverity: 1, // Error level
+            }),
+            tags: {
+                ...this.systemTags(),
+                orchestration: "uniform",
+                example: "monitoring",
+            },
+            ignoreChanges: ["tags"], // Azure adds azsecpack tag automatically
+        });
+        // Flexible VMSS with password authentication
+        // Tests: flexible orchestration mode + automatic network API version resolution
+        new virtual_machine_scale_set_1.VirtualMachineScaleSet(this, "flexible-vmss", {
+            name: "flexiblevmss",
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            sku: {
+                name: "Standard_B1s",
+                capacity: 2, // Reduced from 3 to 2 for cost efficiency
+            },
+            orchestrationMode: "Flexible",
+            platformFaultDomainCount: 1,
+            singlePlacementGroup: false,
+            upgradePolicy: {
+                mode: "Manual",
+            },
+            // Note: Rolling upgrade mode and automaticRepairsPolicy require a health extension
+            // Using Manual mode for simplicity in this integration test
+            virtualMachineProfile: {
+                storageProfile: {
+                    imageReference: {
+                        publisher: "Canonical",
+                        offer: "0001-com-ubuntu-server-jammy",
+                        sku: "22_04-lts-gen2",
+                        version: "latest",
+                    },
+                    osDisk: {
+                        createOption: "FromImage",
+                        managedDisk: {
+                            storageAccountType: "Standard_LRS",
+                        },
+                    },
+                },
+                osProfile: {
+                    computerNamePrefix: "flexvm",
+                    adminUsername: "azureuser",
+                    // Test password only - resources are ephemeral and destroyed after test
+                    adminPassword: "P@ssw0rd1234!SecurePassword",
+                },
+                networkProfile: {
+                    networkInterfaceConfigurations: [
+                        {
+                            name: "nic-config",
+                            properties: {
+                                primary: true,
+                                ipConfigurations: [
+                                    {
+                                        name: "ip-config",
+                                        properties: {
+                                            subnet: {
+                                                id: subnet.id,
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                    ],
+                    // networkApiVersion is automatically resolved to the latest version
+                    // Uncomment to pin to a specific version:
+                    // networkApiVersion: "2024-10-01"
+                },
+            },
+            tags: {
+                ...this.systemTags(),
+                orchestration: "flexible",
+                example: "flexible-mode",
+            },
+            ignoreChanges: ["tags"], // Azure adds azsecpack tag automatically
+        });
+    }
+}
+describe("Virtual Machine Scale Set Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup VMSS resources", () => {
+        const app = cdktf_1.Testing.app();
+        const stack = new VirtualMachineScaleSetExampleStack(app, "test-virtual-machine-scale-set");
+        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 VMSS deployment and cleanup
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual-machine-scale-set.integ.js","sourceRoot":"","sources":["../../../src/azure-vmss/test/virtual-machine-scale-set.integ.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Integration test for Azure Virtual Machine Scale Set\n *\n * This test demonstrates key usage patterns of the VirtualMachineScaleSet construct\n * and validates deployment, idempotency, and cleanup.\n *\n * Test Coverage:\n * - Uniform orchestration mode with monitoring and SSH authentication\n * - Flexible orchestration mode with password authentication\n * - Monitoring integration with custom thresholds\n * - Automatic network API version resolution\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 { ResourceGroup } from \"../../azure-resourcegroup\";\nimport { Subnet } from \"../../azure-subnet\";\nimport { VirtualNetwork } from \"../../azure-virtualnetwork\";\nimport { DataAzapiClientConfig } from \"../../core-azure/lib/azapi/providers-azapi/data-azapi-client-config\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { VirtualMachineScaleSet } from \"../lib/virtual-machine-scale-set\";\n\n// Generate unique test run metadata for this test suite\nconst testMetadata = new TestRunMetadata(\"vmss-integration\", {\n  maxAgeHours: 4,\n});\n\n/**\n * Example stack demonstrating comprehensive Virtual Machine Scale Set usage\n */\nclass VirtualMachineScaleSetExampleStack 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      \"vmss\",\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 virtual network\n    const vnet = new VirtualNetwork(this, \"example-vnet\", {\n      name: \"vmss-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: \"vmss-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    // Get current Azure client configuration for subscription ID\n    const clientConfig = new DataAzapiClientConfig(\n      this,\n      \"current-client-config\",\n      {},\n    );\n\n    // Create Action Group for monitoring alerts\n    const actionGroup = new ActionGroup(this, \"vmss-action-group\", {\n      name: \"vmss-alerts\",\n      location: \"global\",\n      resourceGroupId: resourceGroup.id,\n      groupShortName: \"vmssalert\",\n      emailReceivers: [\n        {\n          name: \"admin-email\",\n          emailAddress: \"admin@example.com\",\n        },\n      ],\n    });\n\n    // Create Log Analytics Workspace for diagnostics (simple inline resource)\n    // Note: Using a simplified workspace creation for testing purposes\n    const workspaceId = `\\${${clientConfig.fqn}.subscription_id}/resourceGroups/${resourceGroup.props.name}/providers/Microsoft.OperationalInsights/workspaces/vmss-workspace`;\n\n    // Uniform VMSS with monitoring and SSH authentication\n    // Combines: basic uniform orchestration + monitoring + security features\n    new VirtualMachineScaleSet(this, \"uniform-vmss\", {\n      name: \"uniformvmss\",\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      sku: {\n        name: \"Standard_B1s\", // Smallest size for cost efficiency\n        capacity: 2,\n      },\n      orchestrationMode: \"Uniform\",\n      upgradePolicy: {\n        mode: \"Automatic\",\n      },\n      virtualMachineProfile: {\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          computerNamePrefix: \"vmss-vm\",\n          adminUsername: \"azureuser\",\n          linuxConfiguration: {\n            disablePasswordAuthentication: true,\n            ssh: {\n              publicKeys: [\n                {\n                  path: \"/home/azureuser/.ssh/authorized_keys\",\n                  // This is a dummy SSH public key for testing purposes only\n                  // Generated with: ssh-keygen -t rsa -b 2048 -f /tmp/test_key (public key only)\n                  keyData:\n                    \"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC3gkXHiCN4VNdmDlMrFK6Io5sDMV9e7S4xxqy9FoASXfLPe1BxIsqVRxfPhHRXmwgZReCZHl2/qFBUrWpRMSCG8MXx7bvqJDYlCZ9yvFLx0wZnFuQVvLLCMfJ1l4gRXXFmRVUFtWLzGlNQVKqGqKqJ1l6fPMM7O+VtxqZlhLRg3Qz0kD4xlZdHxqYxr/AHmBkQQ3vTx5dNh5qbX9kFRlRJFqhvDkqLh4L8jIgQfzJwpZwqzZ0Hj3rYvH2nHa2sJMbY8nBxJKlDdvQwCLh7CqB7x3Hv3k2K3TjvXBF9xMZvx8HwCvKlVZqPQ3VpGhHv3CvMkBvC2L3vKvMxB3vLxHK9 test-key-for-integration-tests\",\n                },\n              ],\n            },\n          },\n        },\n        networkProfile: {\n          networkInterfaceConfigurations: [\n            {\n              name: \"nic-config\",\n              properties: {\n                primary: true,\n                ipConfigurations: [\n                  {\n                    name: \"ip-config\",\n                    properties: {\n                      subnet: {\n                        id: subnet.id,\n                      },\n                    },\n                  },\n                ],\n              },\n            },\n          ],\n        },\n      },\n      identity: {\n        type: \"SystemAssigned\",\n      },\n      overprovision: true,\n      // Add monitoring with custom thresholds to test monitoring integration\n      monitoring: VirtualMachineScaleSet.defaultMonitoring(\n        actionGroup.id,\n        workspaceId,\n        {\n          cpuThreshold: 85,\n          memoryThreshold: 536870912, // 512MB\n          enableDiskQueueAlert: false,\n          cpuAlertSeverity: 1, // Error level\n        },\n      ),\n      tags: {\n        ...this.systemTags(),\n        orchestration: \"uniform\",\n        example: \"monitoring\",\n      },\n      ignoreChanges: [\"tags\"], // Azure adds azsecpack tag automatically\n    });\n\n    // Flexible VMSS with password authentication\n    // Tests: flexible orchestration mode + automatic network API version resolution\n    new VirtualMachineScaleSet(this, \"flexible-vmss\", {\n      name: \"flexiblevmss\",\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      sku: {\n        name: \"Standard_B1s\",\n        capacity: 2, // Reduced from 3 to 2 for cost efficiency\n      },\n      orchestrationMode: \"Flexible\",\n      platformFaultDomainCount: 1,\n      singlePlacementGroup: false,\n      upgradePolicy: {\n        mode: \"Manual\",\n      },\n      // Note: Rolling upgrade mode and automaticRepairsPolicy require a health extension\n      // Using Manual mode for simplicity in this integration test\n      virtualMachineProfile: {\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          },\n        },\n        osProfile: {\n          computerNamePrefix: \"flexvm\",\n          adminUsername: \"azureuser\",\n          // Test password only - resources are ephemeral and destroyed after test\n          adminPassword: \"P@ssw0rd1234!SecurePassword\",\n        },\n        networkProfile: {\n          networkInterfaceConfigurations: [\n            {\n              name: \"nic-config\",\n              properties: {\n                primary: true,\n                ipConfigurations: [\n                  {\n                    name: \"ip-config\",\n                    properties: {\n                      subnet: {\n                        id: subnet.id,\n                      },\n                    },\n                  },\n                ],\n              },\n            },\n          ],\n          // networkApiVersion is automatically resolved to the latest version\n          // Uncomment to pin to a specific version:\n          // networkApiVersion: \"2024-10-01\"\n        },\n      },\n      tags: {\n        ...this.systemTags(),\n        orchestration: \"flexible\",\n        example: \"flexible-mode\",\n      },\n      ignoreChanges: [\"tags\"], // Azure adds azsecpack tag automatically\n    });\n  }\n}\n\ndescribe(\"Virtual Machine Scale Set Integration Test\", () => {\n  it(\"should deploy, validate idempotency, and cleanup VMSS resources\", () => {\n    const app = Testing.app();\n    const stack = new VirtualMachineScaleSetExampleStack(\n      app,\n      \"test-virtual-machine-scale-set\",\n    );\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 VMSS deployment and cleanup\n});\n"]}

package/lib/azure-vmss/test/virtual-machine-scale-set.spec.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Comprehensive tests for the VirtualMachineScaleSet implementation
+ *
+ * This test suite validates the VirtualMachineScaleSet class using the AzapiResource framework.
+ * Tests cover automatic version resolution, explicit version pinning, schema validation,
+ * property transformation, orchestration modes, and full backward compatibility.
+ */
+export {};