@microsoft/terraform-cdk-constructs 0.0.3-pre.6

package/lib/azure-virtualmachine/lib/vm.d.ts

@@ -0,0 +1,205 @@
+import { LinuxVirtualMachineSourceImageReference, LinuxVirtualMachineOsDisk, LinuxVirtualMachineAdminSshKey, LinuxVirtualMachineIdentity, LinuxVirtualMachineSecret, LinuxVirtualMachineAdditionalCapabilities } from "@cdktf/provider-azurerm/lib/linux-virtual-machine";
+import { ResourceGroup } from "@cdktf/provider-azurerm/lib/resource-group";
+import { Subnet } from "@cdktf/provider-azurerm/lib/subnet";
+import { WindowsVirtualMachineOsDisk, WindowsVirtualMachineSourceImageReference } from "@cdktf/provider-azurerm/lib/windows-virtual-machine";
+import * as cdktf from "cdktf";
+import { Construct } from "constructs";
+import { AzureResource } from "../../core-azure/lib";
+export interface WindowsVMProps {
+    /**
+     * The Azure location where the virtual machine should be created.
+     * @default "eastus"
+     */
+    readonly location?: string;
+    /**
+     * The name of the virtual machine.
+     * @default - Uses the name derived from the construct path.
+     */
+    readonly name?: string;
+    /**
+     * The name of the resource group in which the virtual machine will be created.
+     */
+    readonly resourceGroup: ResourceGroup;
+    /**
+     * The size of the virtual machine.
+     * @default "Standard_B2s"
+     */
+    readonly size?: string;
+    /**
+     * The admin username for the virtual machine.
+     */
+    readonly adminUsername: string;
+    /**
+     * The admin password for the virtual machine.
+     */
+    readonly adminPassword: string;
+    /**
+     * The source image reference for the virtual machine.
+     * @default - Uses WindowsServer2022DatacenterCore.
+     */
+    readonly sourceImageReference?: WindowsVirtualMachineSourceImageReference;
+    /**
+     * The ID of the source image for the virtual machine.
+     */
+    readonly sourceImageId?: string;
+    /**
+     * Tags to apply to the virtual machine.
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+    /**
+     * The OS disk configuration for the virtual machine.
+     * @default - Uses a disk with caching set to "ReadWrite" and storage account type "Standard_LRS".
+     */
+    readonly osDisk?: WindowsVirtualMachineOsDisk;
+    /**
+     * The subnet in which the virtual machine will be placed.
+     * @default - Uses the default subnet from a new virtual network.
+     */
+    readonly subnet?: Subnet;
+    /**
+     * The allocation method for the public IP.
+     */
+    readonly publicIPAllocationMethod?: string;
+    /**
+     * Custom data to pass to the virtual machine upon creation.
+     */
+    readonly customData?: string;
+    /**
+     * Custom data to bootstrap the virtual machine. Automatically triggers Azure Custom Script extension to deploy code in custom data.
+     */
+    readonly boostrapCustomData?: string;
+    /**
+     * Bootdiagnostics settings for the VM.
+     */
+    readonly bootDiagnosticsStorageURI?: string;
+}
+export declare class WindowsVM extends AzureResource {
+    readonly props: WindowsVMProps;
+    resourceGroup: ResourceGroup;
+    id: string;
+    readonly name: string;
+    readonly publicIp?: string;
+    /**
+     * Constructs a new instance of the AzureWindowsVirtualMachine class.
+     *
+     * @param scope - The scope in which this construct is defined.
+     * @param id - The ID of this construct.
+     * @param props - The properties for defining a Windows Virtual Machine.
+     */
+    constructor(scope: Construct, id: string, props: WindowsVMProps);
+}
+export interface LinuxVMProps {
+    /**
+     * The Azure location where the virtual machine should be created.
+     * @default "eastus"
+     */
+    readonly location?: string;
+    /**
+     * The name of the virtual machine.
+     * @default - Uses the name derived from the construct path.
+     */
+    readonly name?: string;
+    /**
+     * The name of the resource group in which the virtual machine will be created.
+     */
+    readonly resourceGroup: ResourceGroup;
+    /**
+     * The size of the virtual machine.
+     * @default "Standard_B2s"
+     */
+    readonly size?: string;
+    /**
+     * The ID of the availability set in which the VM should be placed.
+     */
+    readonly availabilitySetId?: string;
+    /**
+     * Custom data to pass to the virtual machine upon creation.
+     */
+    readonly userData?: string;
+    /**
+     * An array of SSH keys for the admin user.
+     */
+    readonly adminSshKey?: LinuxVirtualMachineAdminSshKey[] | cdktf.IResolvable;
+    /**
+     * The availability zone in which the VM should be placed.
+     */
+    readonly zone?: string;
+    /**
+     * Managed identity settings for the VM.
+     */
+    readonly identity?: LinuxVirtualMachineIdentity;
+    /**
+     * Additional capabilities like Ultra Disk compatibility.
+     */
+    readonly additionalCapabilities?: LinuxVirtualMachineAdditionalCapabilities;
+    /**
+     * An array of secrets to be passed to the VM.
+     */
+    readonly secret?: LinuxVirtualMachineSecret[];
+    /**
+     * The admin username for the virtual machine.
+     */
+    readonly adminUsername?: string;
+    /**
+     * The admin password for the virtual machine.
+     */
+    readonly adminPassword?: string;
+    /**
+     * The source image reference for the virtual machine.
+     * @default - Uses WindowsServer2022DatacenterCore.
+     */
+    readonly sourceImageReference?: LinuxVirtualMachineSourceImageReference;
+    /**
+     * The ID of the source image for the virtual machine.
+     */
+    readonly sourceImageId?: string;
+    /**
+     * Tags to apply to the virtual machine.
+     */
+    readonly tags?: {
+        [key: string]: string;
+    };
+    /**
+     * The OS disk configuration for the virtual machine.
+     * @default - Uses a disk with caching set to "ReadWrite" and storage account type "Standard_LRS".
+     */
+    readonly osDisk?: LinuxVirtualMachineOsDisk;
+    /**
+     * The subnet in which the virtual machine will be placed.
+     * @default - Uses the default subnet from a new virtual network.
+     */
+    readonly subnet?: Subnet;
+    /**
+     * The allocation method for the public IP.
+     */
+    readonly publicIPAllocationMethod?: string;
+    /**
+     * Custom data to pass to the virtual machine upon creation.
+     */
+    readonly customData?: string;
+    /**
+     * Enable SSH Azure AD Login, required managed identity to be set.
+     */
+    readonly enableSshAzureADLogin?: boolean;
+    /**
+     * Bootdiagnostics settings for the VM.
+     */
+    readonly bootDiagnosticsStorageURI?: string;
+}
+export declare class LinuxVM extends AzureResource {
+    readonly props: LinuxVMProps;
+    resourceGroup: ResourceGroup;
+    id: string;
+    readonly name: string;
+    readonly publicIp?: string;
+    /**
+     * Constructs a new instance of the AzureLinuxVirtualMachine class.
+     *
+     * @param scope - The scope in which this construct is defined.
+     * @param id - The ID of this construct.
+     * @param props - The properties for defining a Linux Virtual Machine.
+     */
+    constructor(scope: Construct, id: string, props: LinuxVMProps);
+}

package/lib/azure-virtualmachine/lib/vm.js

@@ -0,0 +1,207 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinuxVM = exports.WindowsVM = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const linux_virtual_machine_1 = require("@cdktf/provider-azurerm/lib/linux-virtual-machine");
+const network_interface_1 = require("@cdktf/provider-azurerm/lib/network-interface");
+const public_ip_1 = require("@cdktf/provider-azurerm/lib/public-ip");
+const virtual_machine_extension_1 = require("@cdktf/provider-azurerm/lib/virtual-machine-extension");
+const windows_virtual_machine_1 = require("@cdktf/provider-azurerm/lib/windows-virtual-machine");
+const image_references_1 = require("./image-references");
+const network_1 = require("../../azure-virtualnetwork/lib/network");
+const lib_1 = require("../../core-azure/lib");
+class WindowsVM extends lib_1.AzureResource {
+    /**
+     * Constructs a new instance of the AzureWindowsVirtualMachine class.
+     *
+     * @param scope - The scope in which this construct is defined.
+     * @param id - The ID of this construct.
+     * @param props - The properties for defining a Windows Virtual Machine.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.resourceGroup = props.resourceGroup;
+        // Default configurations for the virtual machine.
+        const defaults = {
+            name: props.name || this.node.path.split("/")[0],
+            location: props.location || "eastus",
+            size: props.size || "Standard_B2s",
+            osDisk: props.osDisk || {
+                caching: "ReadWrite",
+                storageAccountType: "Standard_LRS",
+            },
+            sourceImageReference: props.sourceImageReference ||
+                image_references_1.WindowsImageReferences.windowsServer2022DatacenterCore,
+            subnet: props.subnet ||
+                new network_1.Network(this, "vnet", {
+                    resourceGroup: props.resourceGroup,
+                }).subnets.default,
+        };
+        // Create Public IP if specified.
+        let publicIpId;
+        if (props.publicIPAllocationMethod) {
+            const azurermPublicIp = new public_ip_1.PublicIp(this, "public-ip", {
+                name: `pip-${defaults.name}`,
+                resourceGroupName: props.resourceGroup.name,
+                location: defaults.location,
+                allocationMethod: props.publicIPAllocationMethod,
+                tags: props.tags,
+            });
+            publicIpId = azurermPublicIp.id;
+            this.publicIp = azurermPublicIp.ipAddress;
+        }
+        // Create the Network Interface.
+        const azurermNetworkInterface = new network_interface_1.NetworkInterface(this, "nic", {
+            ...defaults,
+            name: `nic-${defaults.name}`,
+            resourceGroupName: props.resourceGroup.name,
+            ipConfiguration: [
+                {
+                    name: "internal",
+                    subnetId: defaults.subnet.id,
+                    privateIpAddressAllocation: "Dynamic",
+                    publicIpAddressId: publicIpId,
+                },
+            ],
+            tags: props.tags,
+        });
+        // Base64 encode custom data if provided.
+        const customData = props.customData || props.boostrapCustomData;
+        const base64CustomData = customData
+            ? Buffer.from(customData).toString("base64")
+            : undefined;
+        // Create the Windows Virtual Machine.
+        const azurermWindowsVirtualMachine = new windows_virtual_machine_1.WindowsVirtualMachine(this, "vm", {
+            ...defaults,
+            resourceGroupName: props.resourceGroup.name,
+            adminUsername: props.adminUsername,
+            adminPassword: props.adminPassword,
+            tags: props.tags,
+            networkInterfaceIds: [azurermNetworkInterface.id],
+            sourceImageId: props.sourceImageId,
+            customData: base64CustomData,
+            bootDiagnostics: { storageAccountUri: props.bootDiagnosticsStorageURI },
+        });
+        this.id = azurermWindowsVirtualMachine.id;
+        this.name = azurermWindowsVirtualMachine.name;
+        // Bootstrap VM with custom script extension if bootstrap custom data is provided.
+        if (props.boostrapCustomData) {
+            new virtual_machine_extension_1.VirtualMachineExtension(this, "script-ext", {
+                name: `${this.name}-script-ext`,
+                virtualMachineId: this.id,
+                publisher: "Microsoft.Compute",
+                type: "CustomScriptExtension",
+                typeHandlerVersion: "1.10",
+                protectedSettings: '{"commandToExecute": "rename  C:\\\\AzureData\\\\CustomData.bin  postdeploy.ps1 & powershell -ExecutionPolicy Unrestricted -File C:\\\\AzureData\\\\postdeploy.ps1"}',
+            });
+        }
+    }
+}
+exports.WindowsVM = WindowsVM;
+_a = JSII_RTTI_SYMBOL_1;
+WindowsVM[_a] = { fqn: "@microsoft/terraform-cdk-constructs.azure_virtualmachine.WindowsVM", version: "0.0.3-pre.6" };
+class LinuxVM extends lib_1.AzureResource {
+    /**
+     * Constructs a new instance of the AzureLinuxVirtualMachine class.
+     *
+     * @param scope - The scope in which this construct is defined.
+     * @param id - The ID of this construct.
+     * @param props - The properties for defining a Linux Virtual Machine.
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        // Assigning the properties
+        this.props = props;
+        this.resourceGroup = props.resourceGroup;
+        // Extracting the name from the node path
+        const pathName = this.node.path.split("/")[0];
+        // Setting default configurations for the virtual machine
+        const defaults = {
+            name: props.name || pathName,
+            adminUsername: props.adminUsername || `admin${pathName}`,
+            location: props.location || "eastus",
+            size: props.size || "Standard_B2s",
+            osDisk: props.osDisk || {
+                caching: "ReadWrite",
+                storageAccountType: "Standard_LRS",
+            },
+            sourceImageReference: props.sourceImageReference ||
+                image_references_1.WindowsImageReferences.windowsServer2022DatacenterCore,
+            subnet: props.subnet ||
+                new network_1.Network(this, "vnet", {
+                    resourceGroup: props.resourceGroup,
+                }).subnets.default,
+        };
+        // Create Public IP if specified
+        let publicIpId;
+        if (props.publicIPAllocationMethod) {
+            const azurermPublicIp = new public_ip_1.PublicIp(this, "public-ip", {
+                name: `pip-${defaults.name}`,
+                resourceGroupName: props.resourceGroup.name,
+                location: defaults.location,
+                allocationMethod: props.publicIPAllocationMethod,
+                tags: props.tags,
+            });
+            publicIpId = azurermPublicIp.id;
+            this.publicIp = azurermPublicIp.ipAddress;
+        }
+        // Create the Network Interface
+        const azurermNetworkInterface = new network_interface_1.NetworkInterface(this, "nic", {
+            ...defaults,
+            name: `nic-${defaults.name}`,
+            resourceGroupName: props.resourceGroup.name,
+            ipConfiguration: [
+                {
+                    name: "internal",
+                    subnetId: defaults.subnet.id,
+                    privateIpAddressAllocation: "Dynamic",
+                    publicIpAddressId: publicIpId,
+                },
+            ],
+            tags: props.tags,
+        });
+        // Create the Linux Virtual Machine
+        const azurermLinuxVirtualMachine = new linux_virtual_machine_1.LinuxVirtualMachine(this, "vm", {
+            ...defaults,
+            resourceGroupName: props.resourceGroup.name,
+            adminPassword: props.adminPassword,
+            tags: props.tags,
+            networkInterfaceIds: [azurermNetworkInterface.id],
+            sourceImageId: props.sourceImageId,
+            customData: props.customData
+                ? Buffer.from(props.customData).toString("base64")
+                : undefined,
+            userData: props.userData
+                ? Buffer.from(props.userData).toString("base64")
+                : undefined,
+            availabilitySetId: props.availabilitySetId,
+            adminSshKey: props.adminSshKey,
+            bootDiagnostics: { storageAccountUri: props.bootDiagnosticsStorageURI },
+            zone: props.zone,
+            identity: props.identity,
+            additionalCapabilities: props.additionalCapabilities,
+            secret: props.secret,
+            disablePasswordAuthentication: props.adminPassword ? false : true,
+        });
+        // Assigning the VM's ID and name to the class properties
+        this.id = azurermLinuxVirtualMachine.id;
+        this.name = azurermLinuxVirtualMachine.name;
+        // Enable SSH Azure AD Login if specified
+        if (props.enableSshAzureADLogin) {
+            new virtual_machine_extension_1.VirtualMachineExtension(this, "AADSSHlogin", {
+                name: "AADSSHLoginForLinux",
+                virtualMachineId: this.id,
+                publisher: "Microsoft.Azure.ActiveDirectory",
+                type: "AADSSHLoginForLinux",
+                typeHandlerVersion: "1.0",
+                tags: props.tags,
+            });
+        }
+    }
+}
+exports.LinuxVM = LinuxVM;
+_b = JSII_RTTI_SYMBOL_1;
+LinuxVM[_b] = { fqn: "@microsoft/terraform-cdk-constructs.azure_virtualmachine.LinuxVM", version: "0.0.3-pre.6" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vm.js","sourceRoot":"","sources":["../../../src/azure-virtualmachine/lib/vm.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  LinuxVirtualMachine,\n  LinuxVirtualMachineSourceImageReference,\n  LinuxVirtualMachineOsDisk,\n  LinuxVirtualMachineAdminSshKey,\n  LinuxVirtualMachineIdentity,\n  LinuxVirtualMachineSecret,\n  LinuxVirtualMachineAdditionalCapabilities,\n} from \"@cdktf/provider-azurerm/lib/linux-virtual-machine\";\nimport { NetworkInterface } from \"@cdktf/provider-azurerm/lib/network-interface\";\nimport { PublicIp } from \"@cdktf/provider-azurerm/lib/public-ip\";\nimport { ResourceGroup } from \"@cdktf/provider-azurerm/lib/resource-group\";\nimport { Subnet } from \"@cdktf/provider-azurerm/lib/subnet\";\nimport { VirtualMachineExtension } from \"@cdktf/provider-azurerm/lib/virtual-machine-extension\";\nimport {\n  WindowsVirtualMachine,\n  WindowsVirtualMachineOsDisk,\n  WindowsVirtualMachineSourceImageReference,\n} from \"@cdktf/provider-azurerm/lib/windows-virtual-machine\";\nimport * as cdktf from \"cdktf\";\nimport { Construct } from \"constructs\";\n\nimport { WindowsImageReferences } from \"./image-references\";\nimport { Network } from \"../../azure-virtualnetwork/lib/network\";\nimport { AzureResource } from \"../../core-azure/lib\";\n\nexport interface WindowsVMProps {\n  /**\n   * The Azure location where the virtual machine should be created.\n   * @default \"eastus\"\n   */\n  readonly location?: string;\n\n  /**\n   * The name of the virtual machine.\n   * @default - Uses the name derived from the construct path.\n   */\n  readonly name?: string;\n\n  /**\n   * The name of the resource group in which the virtual machine will be created.\n   */\n  readonly resourceGroup: ResourceGroup;\n\n  /**\n   * The size of the virtual machine.\n   * @default \"Standard_B2s\"\n   */\n  readonly size?: string;\n\n  /**\n   * The admin username for the virtual machine.\n   */\n  readonly adminUsername: string;\n\n  /**\n   * The admin password for the virtual machine.\n   */\n  readonly adminPassword: string;\n\n  /**\n   * The source image reference for the virtual machine.\n   * @default - Uses WindowsServer2022DatacenterCore.\n   */\n  readonly sourceImageReference?: WindowsVirtualMachineSourceImageReference;\n\n  /**\n   * The ID of the source image for the virtual machine.\n   */\n  readonly sourceImageId?: string;\n\n  /**\n   * Tags to apply to the virtual machine.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * The OS disk configuration for the virtual machine.\n   * @default - Uses a disk with caching set to \"ReadWrite\" and storage account type \"Standard_LRS\".\n   */\n  readonly osDisk?: WindowsVirtualMachineOsDisk;\n\n  /**\n   * The subnet in which the virtual machine will be placed.\n   * @default - Uses the default subnet from a new virtual network.\n   */\n  readonly subnet?: Subnet;\n\n  /**\n   * The allocation method for the public IP.\n   */\n  readonly publicIPAllocationMethod?: string;\n\n  /**\n   * Custom data to pass to the virtual machine upon creation.\n   */\n  readonly customData?: string;\n\n  /**\n   * Custom data to bootstrap the virtual machine. Automatically triggers Azure Custom Script extension to deploy code in custom data.\n   */\n  readonly boostrapCustomData?: string;\n\n  /**\n   * Bootdiagnostics settings for the VM.\n   */\n  readonly bootDiagnosticsStorageURI?: string;\n}\n\nexport class WindowsVM extends AzureResource {\n  public readonly props: WindowsVMProps;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  public readonly name: string;\n  public readonly publicIp?: string;\n\n  /**\n   * Constructs a new instance of the AzureWindowsVirtualMachine class.\n   *\n   * @param scope - The scope in which this construct is defined.\n   * @param id - The ID of this construct.\n   * @param props - The properties for defining a Windows Virtual Machine.\n   */\n  constructor(scope: Construct, id: string, props: WindowsVMProps) {\n    super(scope, id);\n\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    // Default configurations for the virtual machine.\n    const defaults = {\n      name: props.name || this.node.path.split(\"/\")[0],\n      location: props.location || \"eastus\",\n      size: props.size || \"Standard_B2s\",\n      osDisk: props.osDisk || {\n        caching: \"ReadWrite\",\n        storageAccountType: \"Standard_LRS\",\n      },\n      sourceImageReference:\n        props.sourceImageReference ||\n        WindowsImageReferences.windowsServer2022DatacenterCore,\n      subnet:\n        props.subnet ||\n        new Network(this, \"vnet\", {\n          resourceGroup: props.resourceGroup,\n        }).subnets.default,\n    };\n\n    // Create Public IP if specified.\n    let publicIpId: string | undefined;\n    if (props.publicIPAllocationMethod) {\n      const azurermPublicIp = new PublicIp(this, \"public-ip\", {\n        name: `pip-${defaults.name}`,\n        resourceGroupName: props.resourceGroup.name,\n        location: defaults.location,\n        allocationMethod: props.publicIPAllocationMethod,\n        tags: props.tags,\n      });\n\n      publicIpId = azurermPublicIp.id;\n      this.publicIp = azurermPublicIp.ipAddress;\n    }\n\n    // Create the Network Interface.\n    const azurermNetworkInterface = new NetworkInterface(this, \"nic\", {\n      ...defaults,\n      name: `nic-${defaults.name}`,\n      resourceGroupName: props.resourceGroup.name,\n      ipConfiguration: [\n        {\n          name: \"internal\",\n          subnetId: defaults.subnet.id,\n          privateIpAddressAllocation: \"Dynamic\",\n          publicIpAddressId: publicIpId,\n        },\n      ],\n      tags: props.tags,\n    });\n\n    // Base64 encode custom data if provided.\n    const customData = props.customData || props.boostrapCustomData;\n    const base64CustomData = customData\n      ? Buffer.from(customData).toString(\"base64\")\n      : undefined;\n\n    // Create the Windows Virtual Machine.\n    const azurermWindowsVirtualMachine = new WindowsVirtualMachine(this, \"vm\", {\n      ...defaults,\n      resourceGroupName: props.resourceGroup.name,\n      adminUsername: props.adminUsername,\n      adminPassword: props.adminPassword,\n      tags: props.tags,\n      networkInterfaceIds: [azurermNetworkInterface.id],\n      sourceImageId: props.sourceImageId,\n      customData: base64CustomData,\n      bootDiagnostics: { storageAccountUri: props.bootDiagnosticsStorageURI },\n    });\n\n    this.id = azurermWindowsVirtualMachine.id;\n    this.name = azurermWindowsVirtualMachine.name;\n\n    // Bootstrap VM with custom script extension if bootstrap custom data is provided.\n    if (props.boostrapCustomData) {\n      new VirtualMachineExtension(this, \"script-ext\", {\n        name: `${this.name}-script-ext`,\n        virtualMachineId: this.id,\n        publisher: \"Microsoft.Compute\",\n        type: \"CustomScriptExtension\",\n        typeHandlerVersion: \"1.10\",\n        protectedSettings:\n          '{\"commandToExecute\": \"rename  C:\\\\\\\\AzureData\\\\\\\\CustomData.bin  postdeploy.ps1 & powershell -ExecutionPolicy Unrestricted -File C:\\\\\\\\AzureData\\\\\\\\postdeploy.ps1\"}',\n      });\n    }\n  }\n}\n\nexport interface LinuxVMProps {\n  /**\n   * The Azure location where the virtual machine should be created.\n   * @default \"eastus\"\n   */\n  readonly location?: string;\n\n  /**\n   * The name of the virtual machine.\n   * @default - Uses the name derived from the construct path.\n   */\n  readonly name?: string;\n\n  /**\n   * The name of the resource group in which the virtual machine will be created.\n   */\n  readonly resourceGroup: ResourceGroup;\n\n  /**\n   * The size of the virtual machine.\n   * @default \"Standard_B2s\"\n   */\n  readonly size?: string;\n\n  /**\n   * The ID of the availability set in which the VM should be placed.\n   */\n  readonly availabilitySetId?: string;\n\n  /**\n   * Custom data to pass to the virtual machine upon creation.\n   */\n  readonly userData?: string;\n\n  /**\n   * An array of SSH keys for the admin user.\n   */\n  readonly adminSshKey?: LinuxVirtualMachineAdminSshKey[] | cdktf.IResolvable;\n\n  /**\n   * The availability zone in which the VM should be placed.\n   */\n  readonly zone?: string;\n\n  /**\n   * Managed identity settings for the VM.\n   */\n  readonly identity?: LinuxVirtualMachineIdentity;\n\n  /**\n   * Additional capabilities like Ultra Disk compatibility.\n   */\n  readonly additionalCapabilities?: LinuxVirtualMachineAdditionalCapabilities;\n\n  /**\n   * An array of secrets to be passed to the VM.\n   */\n  readonly secret?: LinuxVirtualMachineSecret[];\n\n  /**\n   * The admin username for the virtual machine.\n   */\n  readonly adminUsername?: string;\n\n  /**\n   * The admin password for the virtual machine.\n   */\n  readonly adminPassword?: string;\n\n  /**\n   * The source image reference for the virtual machine.\n   * @default - Uses WindowsServer2022DatacenterCore.\n   */\n  readonly sourceImageReference?: LinuxVirtualMachineSourceImageReference;\n\n  /**\n   * The ID of the source image for the virtual machine.\n   */\n  readonly sourceImageId?: string;\n\n  /**\n   * Tags to apply to the virtual machine.\n   */\n  readonly tags?: { [key: string]: string };\n\n  /**\n   * The OS disk configuration for the virtual machine.\n   * @default - Uses a disk with caching set to \"ReadWrite\" and storage account type \"Standard_LRS\".\n   */\n  readonly osDisk?: LinuxVirtualMachineOsDisk;\n\n  /**\n   * The subnet in which the virtual machine will be placed.\n   * @default - Uses the default subnet from a new virtual network.\n   */\n  readonly subnet?: Subnet;\n\n  /**\n   * The allocation method for the public IP.\n   */\n  readonly publicIPAllocationMethod?: string;\n\n  /**\n   * Custom data to pass to the virtual machine upon creation.\n   */\n  readonly customData?: string;\n\n  /**\n   * Enable SSH Azure AD Login, required managed identity to be set.\n   */\n  readonly enableSshAzureADLogin?: boolean;\n\n  /**\n   * Bootdiagnostics settings for the VM.\n   */\n  readonly bootDiagnosticsStorageURI?: string;\n}\n\nexport class LinuxVM extends AzureResource {\n  // Properties of the AzureLinuxVirtualMachine class\n  readonly props: LinuxVMProps;\n  public resourceGroup: ResourceGroup;\n  public id: string;\n  public readonly name: string;\n  public readonly publicIp?: string;\n\n  /**\n   * Constructs a new instance of the AzureLinuxVirtualMachine class.\n   *\n   * @param scope - The scope in which this construct is defined.\n   * @param id - The ID of this construct.\n   * @param props - The properties for defining a Linux Virtual Machine.\n   */\n  constructor(scope: Construct, id: string, props: LinuxVMProps) {\n    super(scope, id);\n\n    // Assigning the properties\n    this.props = props;\n    this.resourceGroup = props.resourceGroup;\n\n    // Extracting the name from the node path\n    const pathName = this.node.path.split(\"/\")[0];\n\n    // Setting default configurations for the virtual machine\n    const defaults = {\n      name: props.name || pathName,\n      adminUsername: props.adminUsername || `admin${pathName}`,\n      location: props.location || \"eastus\",\n      size: props.size || \"Standard_B2s\",\n      osDisk: props.osDisk || {\n        caching: \"ReadWrite\",\n        storageAccountType: \"Standard_LRS\",\n      },\n      sourceImageReference:\n        props.sourceImageReference ||\n        WindowsImageReferences.windowsServer2022DatacenterCore,\n      subnet:\n        props.subnet ||\n        new Network(this, \"vnet\", {\n          resourceGroup: props.resourceGroup,\n        }).subnets.default,\n    };\n\n    // Create Public IP if specified\n    let publicIpId: string | undefined;\n    if (props.publicIPAllocationMethod) {\n      const azurermPublicIp = new PublicIp(this, \"public-ip\", {\n        name: `pip-${defaults.name}`,\n        resourceGroupName: props.resourceGroup.name,\n        location: defaults.location,\n        allocationMethod: props.publicIPAllocationMethod,\n        tags: props.tags,\n      });\n\n      publicIpId = azurermPublicIp.id;\n      this.publicIp = azurermPublicIp.ipAddress;\n    }\n\n    // Create the Network Interface\n    const azurermNetworkInterface = new NetworkInterface(this, \"nic\", {\n      ...defaults,\n      name: `nic-${defaults.name}`,\n      resourceGroupName: props.resourceGroup.name,\n      ipConfiguration: [\n        {\n          name: \"internal\",\n          subnetId: defaults.subnet.id,\n          privateIpAddressAllocation: \"Dynamic\",\n          publicIpAddressId: publicIpId,\n        },\n      ],\n      tags: props.tags,\n    });\n\n    // Create the Linux Virtual Machine\n    const azurermLinuxVirtualMachine = new LinuxVirtualMachine(this, \"vm\", {\n      ...defaults,\n      resourceGroupName: props.resourceGroup.name,\n      adminPassword: props.adminPassword,\n      tags: props.tags,\n      networkInterfaceIds: [azurermNetworkInterface.id],\n      sourceImageId: props.sourceImageId,\n      customData: props.customData\n        ? Buffer.from(props.customData).toString(\"base64\")\n        : undefined,\n      userData: props.userData\n        ? Buffer.from(props.userData).toString(\"base64\")\n        : undefined,\n      availabilitySetId: props.availabilitySetId,\n      adminSshKey: props.adminSshKey,\n      bootDiagnostics: { storageAccountUri: props.bootDiagnosticsStorageURI },\n      zone: props.zone,\n      identity: props.identity,\n      additionalCapabilities: props.additionalCapabilities,\n      secret: props.secret,\n      disablePasswordAuthentication: props.adminPassword ? false : true,\n    });\n\n    // Assigning the VM's ID and name to the class properties\n    this.id = azurermLinuxVirtualMachine.id;\n    this.name = azurermLinuxVirtualMachine.name;\n\n    // Enable SSH Azure AD Login if specified\n    if (props.enableSshAzureADLogin) {\n      new VirtualMachineExtension(this, \"AADSSHlogin\", {\n        name: \"AADSSHLoginForLinux\",\n        virtualMachineId: this.id,\n        publisher: \"Microsoft.Azure.ActiveDirectory\",\n        type: \"AADSSHLoginForLinux\",\n        typeHandlerVersion: \"1.0\",\n        tags: props.tags,\n      });\n    }\n  }\n}\n"]}

package/lib/azure-virtualmachine/test/AzureLinuxVirtualMachine.spec.d.ts

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

package/lib/azure-virtualmachine/test/AzureLinuxVirtualMachine.spec.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+require("cdktf/lib/testing/adapters/jest");
+const vm = require("..");
+const ExampleAzureLinuxVirtualMachine_1 = require("../test/ExampleAzureLinuxVirtualMachine");
+describe("Azure Linux Virtual Machine With Defaults", () => {
+    let stack;
+    let fullSynthResult;
+    beforeEach(() => {
+        const app = cdktf_1.Testing.app();
+        stack = new cdktf_1.TerraformStack(app, "testAzureVMWithDefaults");
+        new provider_1.AzurermProvider(stack, "azureFeature", { features: {} });
+        const rg = new resource_group_1.ResourceGroup(stack, "MyResourceGroup", {
+            name: "rg-test",
+            location: "eastus",
+        });
+        new vm.LinuxVM(stack, "testVirtualMachine", {
+            resourceGroup: rg,
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    it("renders an Azure Linux Virtual Machine with defaults and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(stack)).toMatchSnapshot(); // Compare the already prepared stack
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        expect(fullSynthResult).toBeValidTerraform(); // Use the saved result
+    });
+    it("check if this can be planned", () => {
+        expect(fullSynthResult).toPlanSuccessfully(); // Use the saved result
+    });
+});
+describe("Azure Linux Virtual Machine Example", () => {
+    it("renders the Azure Linux Virtual Machine and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(new ExampleAzureLinuxVirtualMachine_1.exampleAzureLinuxVirtualMachine(cdktf_1.Testing.app(), "testAzureLinuxVirtualMachineExample"))).toMatchSnapshot();
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureLinuxVirtualMachine_1.exampleAzureLinuxVirtualMachine(cdktf_1.Testing.app(), "testAzureLinuxVirtualMachineExample"))).toBeValidTerraform();
+    });
+    it("check if this can be planned", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureLinuxVirtualMachine_1.exampleAzureLinuxVirtualMachine(cdktf_1.Testing.app(), "testAzureLinuxVirtualMachineExample"))).toPlanSuccessfully();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-virtualmachine/test/AzureWindowsVirtualMachine.spec.d.ts

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

package/lib/azure-virtualmachine/test/AzureWindowsVirtualMachine.spec.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+require("cdktf/lib/testing/adapters/jest");
+const ExampleAzureWindowsVirtualMachine_1 = require("./ExampleAzureWindowsVirtualMachine");
+const vm = require("..");
+describe("Azure Windows Virtual Machine With Defaults", () => {
+    let stack;
+    let fullSynthResult;
+    beforeEach(() => {
+        const app = cdktf_1.Testing.app();
+        stack = new cdktf_1.TerraformStack(app, "testAzureVMWithDefaults");
+        new provider_1.AzurermProvider(stack, "azureFeature", { features: {} });
+        const rg = new resource_group_1.ResourceGroup(stack, "MyResourceGroup", {
+            name: "rg-test",
+            location: "eastus",
+        });
+        new vm.WindowsVM(stack, "testVirtualMachine", {
+            resourceGroup: rg,
+            adminUsername: "testAdmin",
+            adminPassword: "testPassword&@34$$123",
+        });
+        fullSynthResult = cdktf_1.Testing.fullSynth(stack); // Save the result for reuse
+    });
+    it("renders an Azure Windows Virtual Machine with defaults and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(stack)).toMatchSnapshot(); // Compare the already prepared stack
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        expect(fullSynthResult).toBeValidTerraform(); // Use the saved result
+    });
+    it("check if this can be planned", () => {
+        expect(fullSynthResult).toPlanSuccessfully(); // Use the saved result
+    });
+});
+describe("Azure Windows Virtual Machine Example", () => {
+    it("renders the Azure Windows Virtual Machine and checks snapshot", () => {
+        expect(cdktf_1.Testing.synth(new ExampleAzureWindowsVirtualMachine_1.exampleAzureWindowsVirtualMachine(cdktf_1.Testing.app(), "testAzureWindowsVirtualMachineExample"))).toMatchSnapshot();
+    });
+    it("check if the produced terraform configuration is valid", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureWindowsVirtualMachine_1.exampleAzureWindowsVirtualMachine(cdktf_1.Testing.app(), "testAzureWindowsVirtualMachineExample"))).toBeValidTerraform();
+    });
+    it("check if this can be planned", () => {
+        // We need to do a full synth to plan the terraform configuration
+        expect(cdktf_1.Testing.fullSynth(new ExampleAzureWindowsVirtualMachine_1.exampleAzureWindowsVirtualMachine(cdktf_1.Testing.app(), "testAzureWindowsVirtualMachineExample"))).toPlanSuccessfully();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQXp1cmVXaW5kb3dzVmlydHVhbE1hY2hpbmUuc3BlYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9henVyZS12aXJ0dWFsbWFjaGluZS90ZXN0L0F6dXJlV2luZG93c1ZpcnR1YWxNYWNoaW5lLnNwZWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxtRUFBdUU7QUFDdkUsK0VBQTJFO0FBQzNFLGlDQUFnRDtBQUNoRCwyQ0FBeUM7QUFDekMsMkZBQXdGO0FBQ3hGLHlCQUF5QjtBQUV6QixRQUFRLENBQUMsNkNBQTZDLEVBQUUsR0FBRyxFQUFFO0lBQzNELElBQUksS0FBcUIsQ0FBQztJQUMxQixJQUFJLGVBQW9CLENBQUM7SUFFekIsVUFBVSxDQUFDLEdBQUcsRUFBRTtRQUNkLE1BQU0sR0FBRyxHQUFHLGVBQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztRQUMxQixLQUFLLEdBQUcsSUFBSSxzQkFBYyxDQUFDLEdBQUcsRUFBRSx5QkFBeUIsQ0FBQyxDQUFDO1FBRTNELElBQUksMEJBQWUsQ0FBQyxLQUFLLEVBQUUsY0FBYyxFQUFFLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFFN0QsTUFBTSxFQUFFLEdBQUcsSUFBSSw4QkFBYSxDQUFDLEtBQUssRUFBRSxpQkFBaUIsRUFBRTtZQUNyRCxJQUFJLEVBQUUsU0FBUztZQUNmLFFBQVEsRUFBRSxRQUFRO1NBQ25CLENBQUMsQ0FBQztRQUVILElBQUksRUFBRSxDQUFDLFNBQVMsQ0FBQyxLQUFLLEVBQUUsb0JBQW9CLEVBQUU7WUFDNUMsYUFBYSxFQUFFLEVBQUU7WUFDakIsYUFBYSxFQUFFLFdBQVc7WUFDMUIsYUFBYSxFQUFFLHVCQUF1QjtTQUN2QyxDQUFDLENBQUM7UUFFSCxlQUFlLEdBQUcsZUFBTyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLDRCQUE0QjtJQUMxRSxDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyw0RUFBNEUsRUFBRSxHQUFHLEVBQUU7UUFDcEYsTUFBTSxDQUFDLGVBQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxlQUFlLEVBQUUsQ0FBQyxDQUFDLHFDQUFxQztJQUN2RixDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyx3REFBd0QsRUFBRSxHQUFHLEVBQUU7UUFDaEUsTUFBTSxDQUFDLGVBQWUsQ0FBQyxDQUFDLGtCQUFrQixFQUFFLENBQUMsQ0FBQyx1QkFBdUI7SUFDdkUsQ0FBQyxDQUFDLENBQUM7SUFFSCxFQUFFLENBQUMsOEJBQThCLEVBQUUsR0FBRyxFQUFFO1FBQ3RDLE1BQU0sQ0FBQyxlQUFlLENBQUMsQ0FBQyxrQkFBa0IsRUFBRSxDQUFDLENBQUMsdUJBQXVCO0lBQ3ZFLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDLENBQUM7QUFFSCxRQUFRLENBQUMsdUNBQXVDLEVBQUUsR0FBRyxFQUFFO0lBQ3JELEVBQUUsQ0FBQywrREFBK0QsRUFBRSxHQUFHLEVBQUU7UUFDdkUsTUFBTSxDQUNKLGVBQU8sQ0FBQyxLQUFLLENBQ1gsSUFBSSxxRUFBaUMsQ0FDbkMsZUFBTyxDQUFDLEdBQUcsRUFBRSxFQUNiLHVDQUF1QyxDQUN4QyxDQUNGLENBQ0YsQ0FBQyxlQUFlLEVBQUUsQ0FBQztJQUN0QixDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyx3REFBd0QsRUFBRSxHQUFHLEVBQUU7UUFDaEUsaUVBQWlFO1FBQ2pFLE1BQU0sQ0FDSixlQUFPLENBQUMsU0FBUyxDQUNmLElBQUkscUVBQWlDLENBQ25DLGVBQU8sQ0FBQyxHQUFHLEVBQUUsRUFDYix1Q0FBdUMsQ0FDeEMsQ0FDRixDQUNGLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztJQUN6QixDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyw4QkFBOEIsRUFBRSxHQUFHLEVBQUU7UUFDdEMsaUVBQWlFO1FBQ2pFLE1BQU0sQ0FDSixlQUFPLENBQUMsU0FBUyxDQUNmLElBQUkscUVBQWlDLENBQ25DLGVBQU8sQ0FBQyxHQUFHLEVBQUUsRUFDYix1Q0FBdUMsQ0FDeEMsQ0FDRixDQUNGLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztJQUN6QixDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXp1cmVybVByb3ZpZGVyIH0gZnJvbSBcIkBjZGt0Zi9wcm92aWRlci1henVyZXJtL2xpYi9wcm92aWRlclwiO1xuaW1wb3J0IHsgUmVzb3VyY2VHcm91cCB9IGZyb20gXCJAY2RrdGYvcHJvdmlkZXItYXp1cmVybS9saWIvcmVzb3VyY2UtZ3JvdXBcIjtcbmltcG9ydCB7IFRlc3RpbmcsIFRlcnJhZm9ybVN0YWNrIH0gZnJvbSBcImNka3RmXCI7XG5pbXBvcnQgXCJjZGt0Zi9saWIvdGVzdGluZy9hZGFwdGVycy9qZXN0XCI7XG5pbXBvcnQgeyBleGFtcGxlQXp1cmVXaW5kb3dzVmlydHVhbE1hY2hpbmUgfSBmcm9tIFwiLi9FeGFtcGxlQXp1cmVXaW5kb3dzVmlydHVhbE1hY2hpbmVcIjtcbmltcG9ydCAqIGFzIHZtIGZyb20gXCIuLlwiO1xuXG5kZXNjcmliZShcIkF6dXJlIFdpbmRvd3MgVmlydHVhbCBNYWNoaW5lIFdpdGggRGVmYXVsdHNcIiwgKCkgPT4ge1xuICBsZXQgc3RhY2s6IFRlcnJhZm9ybVN0YWNrO1xuICBsZXQgZnVsbFN5bnRoUmVzdWx0OiBhbnk7XG5cbiAgYmVmb3JlRWFjaCgoKSA9PiB7XG4gICAgY29uc3QgYXBwID0gVGVzdGluZy5hcHAoKTtcbiAgICBzdGFjayA9IG5ldyBUZXJyYWZvcm1TdGFjayhhcHAsIFwidGVzdEF6dXJlVk1XaXRoRGVmYXVsdHNcIik7XG5cbiAgICBuZXcgQXp1cmVybVByb3ZpZGVyKHN0YWNrLCBcImF6dXJlRmVhdHVyZVwiLCB7IGZlYXR1cmVzOiB7fSB9KTtcblxuICAgIGNvbnN0IHJnID0gbmV3IFJlc291cmNlR3JvdXAoc3RhY2ssIFwiTXlSZXNvdXJjZUdyb3VwXCIsIHtcbiAgICAgIG5hbWU6IFwicmctdGVzdFwiLFxuICAgICAgbG9jYXRpb246IFwiZWFzdHVzXCIsXG4gICAgfSk7XG5cbiAgICBuZXcgdm0uV2luZG93c1ZNKHN0YWNrLCBcInRlc3RWaXJ0dWFsTWFjaGluZVwiLCB7XG4gICAgICByZXNvdXJjZUdyb3VwOiByZyxcbiAgICAgIGFkbWluVXNlcm5hbWU6IFwidGVzdEFkbWluXCIsXG4gICAgICBhZG1pblBhc3N3b3JkOiBcInRlc3RQYXNzd29yZCZAMzQkJDEyM1wiLFxuICAgIH0pO1xuXG4gICAgZnVsbFN5bnRoUmVzdWx0ID0gVGVzdGluZy5mdWxsU3ludGgoc3RhY2spOyAvLyBTYXZlIHRoZSByZXN1bHQgZm9yIHJldXNlXG4gIH0pO1xuXG4gIGl0KFwicmVuZGVycyBhbiBBenVyZSBXaW5kb3dzIFZpcnR1YWwgTWFjaGluZSB3aXRoIGRlZmF1bHRzIGFuZCBjaGVja3Mgc25hcHNob3RcIiwgKCkgPT4ge1xuICAgIGV4cGVjdChUZXN0aW5nLnN5bnRoKHN0YWNrKSkudG9NYXRjaFNuYXBzaG90KCk7IC8vIENvbXBhcmUgdGhlIGFscmVhZHkgcHJlcGFyZWQgc3RhY2tcbiAgfSk7XG5cbiAgaXQoXCJjaGVjayBpZiB0aGUgcHJvZHVjZWQgdGVycmFmb3JtIGNvbmZpZ3VyYXRpb24gaXMgdmFsaWRcIiwgKCkgPT4ge1xuICAgIGV4cGVjdChmdWxsU3ludGhSZXN1bHQpLnRvQmVWYWxpZFRlcnJhZm9ybSgpOyAvLyBVc2UgdGhlIHNhdmVkIHJlc3VsdFxuICB9KTtcblxuICBpdChcImNoZWNrIGlmIHRoaXMgY2FuIGJlIHBsYW5uZWRcIiwgKCkgPT4ge1xuICAgIGV4cGVjdChmdWxsU3ludGhSZXN1bHQpLnRvUGxhblN1Y2Nlc3NmdWxseSgpOyAvLyBVc2UgdGhlIHNhdmVkIHJlc3VsdFxuICB9KTtcbn0pO1xuXG5kZXNjcmliZShcIkF6dXJlIFdpbmRvd3MgVmlydHVhbCBNYWNoaW5lIEV4YW1wbGVcIiwgKCkgPT4ge1xuICBpdChcInJlbmRlcnMgdGhlIEF6dXJlIFdpbmRvd3MgVmlydHVhbCBNYWNoaW5lIGFuZCBjaGVja3Mgc25hcHNob3RcIiwgKCkgPT4ge1xuICAgIGV4cGVjdChcbiAgICAgIFRlc3Rpbmcuc3ludGgoXG4gICAgICAgIG5ldyBleGFtcGxlQXp1cmVXaW5kb3dzVmlydHVhbE1hY2hpbmUoXG4gICAgICAgICAgVGVzdGluZy5hcHAoKSxcbiAgICAgICAgICBcInRlc3RBenVyZVdpbmRvd3NWaXJ0dWFsTWFjaGluZUV4YW1wbGVcIixcbiAgICAgICAgKSxcbiAgICAgICksXG4gICAgKS50b01hdGNoU25hcHNob3QoKTtcbiAgfSk7XG5cbiAgaXQoXCJjaGVjayBpZiB0aGUgcHJvZHVjZWQgdGVycmFmb3JtIGNvbmZpZ3VyYXRpb24gaXMgdmFsaWRcIiwgKCkgPT4ge1xuICAgIC8vIFdlIG5lZWQgdG8gZG8gYSBmdWxsIHN5bnRoIHRvIHBsYW4gdGhlIHRlcnJhZm9ybSBjb25maWd1cmF0aW9uXG4gICAgZXhwZWN0KFxuICAgICAgVGVzdGluZy5mdWxsU3ludGgoXG4gICAgICAgIG5ldyBleGFtcGxlQXp1cmVXaW5kb3dzVmlydHVhbE1hY2hpbmUoXG4gICAgICAgICAgVGVzdGluZy5hcHAoKSxcbiAgICAgICAgICBcInRlc3RBenVyZVdpbmRvd3NWaXJ0dWFsTWFjaGluZUV4YW1wbGVcIixcbiAgICAgICAgKSxcbiAgICAgICksXG4gICAgKS50b0JlVmFsaWRUZXJyYWZvcm0oKTtcbiAgfSk7XG5cbiAgaXQoXCJjaGVjayBpZiB0aGlzIGNhbiBiZSBwbGFubmVkXCIsICgpID0+IHtcbiAgICAvLyBXZSBuZWVkIHRvIGRvIGEgZnVsbCBzeW50aCB0byBwbGFuIHRoZSB0ZXJyYWZvcm0gY29uZmlndXJhdGlvblxuICAgIGV4cGVjdChcbiAgICAgIFRlc3RpbmcuZnVsbFN5bnRoKFxuICAgICAgICBuZXcgZXhhbXBsZUF6dXJlV2luZG93c1ZpcnR1YWxNYWNoaW5lKFxuICAgICAgICAgIFRlc3RpbmcuYXBwKCksXG4gICAgICAgICAgXCJ0ZXN0QXp1cmVXaW5kb3dzVmlydHVhbE1hY2hpbmVFeGFtcGxlXCIsXG4gICAgICAgICksXG4gICAgICApLFxuICAgICkudG9QbGFuU3VjY2Vzc2Z1bGx5KCk7XG4gIH0pO1xufSk7XG4iXX0=

package/lib/azure-virtualmachine/test/ExampleAzureLinuxVirtualMachine.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { BaseTestStack } from "../../testing";
+export declare class exampleAzureLinuxVirtualMachine extends BaseTestStack {
+    constructor(scope: Construct, id: string);
+}