0
0
mirror of https://github.com/bpg/terraform-provider-proxmox.git synced 2025-07-05 05:24:01 +00:00

chore(lxc,vm): refactor: move vm and container code to subpackages (#1046)

* chore(lxc,vm): refactor: move vm and container code to subpackages

---------

Signed-off-by: Pavel Boldyrev <627562+bpg@users.noreply.github.com>
This commit is contained in:
Pavel Boldyrev 2024-02-19 22:56:25 -05:00 committed by GitHub
parent 61754069a4
commit 079119444d
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 3112 additions and 2990 deletions

View File

@ -72,6 +72,7 @@ linters:
- gomnd
- ireturn
- maintidx
- nestif
- nlreturn
- perfsprint
- tagliatelle

47
.vscode/settings.json vendored
View File

@ -1,31 +1,76 @@
{
"git.alwaysSignOff": true,
"cSpell.words": [
"aarch",
"ACPI",
"archlinux",
"armhf",
"burstable",
"capi",
"CDROM",
"cloudinit",
"CLRF",
"clusterfirewall",
"cmode",
"cpulimit",
"CPUNUMA",
"cputype",
"cpuunits",
"customdiff",
"deepcode",
"directsync",
"efidisk",
"efidisks",
"FSTRIM",
"gocritic",
"gosimple",
"hookscript",
"hostpci",
"Hotplugged",
"iface",
"importdisk",
"iothread",
"iothreads",
"ivshmem",
"keyctl",
"mbps",
"mdev",
"nameserver",
"nestif",
"nixos",
"nolint",
"NUMA",
"ostype",
"OVMF",
"prealloc",
"proxmoxtf",
"pvesm",
"qcow",
"ROMBAR",
"romfile",
"rootfs",
"seabios",
"signoff",
"SMBIOSSKU",
"SMBIOSUUID",
"stretchr",
"testacc",
"tflog",
"tfstate",
"tfvars",
"tpmstate",
"unmanaged",
"usbdisk",
"vcpus",
"virtio",
"VLANID",
"vmbr",
"VMID",
"vztmpl"
"vztmpl",
"writeback",
"writethrough",
"wvista",
"XVGA"
],
"go.lintTool": "golangci-lint",
"go.lintFlags": [

View File

@ -11,7 +11,9 @@ import (
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource"
clusterfirewall "github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource/cluster/firewall"
container "github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource/container"
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource/firewall"
vm "github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource/vm"
)
func createResourceMap() map[string]*schema.Resource {
@ -19,7 +21,7 @@ func createResourceMap() map[string]*schema.Resource {
"proxmox_virtual_environment_certificate": resource.Certificate(),
"proxmox_virtual_environment_cluster_firewall": clusterfirewall.Firewall(),
"proxmox_virtual_environment_cluster_firewall_security_group": clusterfirewall.SecurityGroup(),
"proxmox_virtual_environment_container": resource.Container(),
"proxmox_virtual_environment_container": container.Container(),
"proxmox_virtual_environment_dns": resource.DNS(),
"proxmox_virtual_environment_file": resource.File(),
"proxmox_virtual_environment_firewall_alias": firewall.Alias(),
@ -28,11 +30,10 @@ func createResourceMap() map[string]*schema.Resource {
"proxmox_virtual_environment_firewall_rules": firewall.Rules(),
"proxmox_virtual_environment_group": resource.Group(),
"proxmox_virtual_environment_hosts": resource.Hosts(),
// "proxmox_virtual_environment_network_linux_bridge": resource.NetworkLinuxBridge(),
"proxmox_virtual_environment_pool": resource.Pool(),
"proxmox_virtual_environment_role": resource.Role(),
"proxmox_virtual_environment_time": resource.Time(),
"proxmox_virtual_environment_user": resource.User(),
"proxmox_virtual_environment_vm": resource.VM(),
"proxmox_virtual_environment_vm": vm.VM(),
}
}

View File

@ -0,0 +1,315 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package resource
import (
"testing"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/test"
)
// TestContainerInstantiation tests whether the Container instance can be instantiated.
func TestContainerInstantiation(t *testing.T) {
t.Parallel()
s := Container()
if s == nil {
t.Fatalf("Cannot instantiate Container")
}
}
// TestContainerSchema tests the Container schema.
func TestContainerSchema(t *testing.T) {
t.Parallel()
s := Container()
test.AssertRequiredArguments(t, s, []string{
mkNodeName,
})
test.AssertOptionalArguments(t, s, []string{
mkCPU,
mkDescription,
mkDisk,
mkInitialization,
mkMemory,
mkMountPoint,
mkOperatingSystem,
mkPoolID,
mkStarted,
mkTags,
mkTemplate,
mkUnprivileged,
mkStartOnBoot,
mkFeatures,
mkVMID,
})
test.AssertValueTypes(t, s, map[string]schema.ValueType{
mkCPU: schema.TypeList,
mkDescription: schema.TypeString,
mkDisk: schema.TypeList,
mkInitialization: schema.TypeList,
mkMemory: schema.TypeList,
mkMountPoint: schema.TypeList,
mkOperatingSystem: schema.TypeList,
mkPoolID: schema.TypeString,
mkStarted: schema.TypeBool,
mkTags: schema.TypeList,
mkTemplate: schema.TypeBool,
mkUnprivileged: schema.TypeBool,
mkStartOnBoot: schema.TypeBool,
mkFeatures: schema.TypeList,
mkVMID: schema.TypeInt,
})
cloneSchema := test.AssertNestedSchemaExistence(t, s, mkClone)
test.AssertRequiredArguments(t, cloneSchema, []string{
mkCloneVMID,
})
test.AssertOptionalArguments(t, cloneSchema, []string{
mkCloneDatastoreID,
mkCloneNodeName,
})
test.AssertValueTypes(t, cloneSchema, map[string]schema.ValueType{
mkCloneDatastoreID: schema.TypeString,
mkCloneNodeName: schema.TypeString,
mkCloneVMID: schema.TypeInt,
})
cpuSchema := test.AssertNestedSchemaExistence(t, s, mkCPU)
test.AssertOptionalArguments(t, cpuSchema, []string{
mkCPUArchitecture,
mkCPUCores,
mkCPUUnits,
})
test.AssertValueTypes(t, cpuSchema, map[string]schema.ValueType{
mkCPUArchitecture: schema.TypeString,
mkCPUCores: schema.TypeInt,
mkCPUUnits: schema.TypeInt,
})
diskSchema := test.AssertNestedSchemaExistence(t, s, mkDisk)
test.AssertOptionalArguments(t, diskSchema, []string{
mkDiskDatastoreID,
})
test.AssertValueTypes(t, diskSchema, map[string]schema.ValueType{
mkDiskDatastoreID: schema.TypeString,
})
featuresSchema := test.AssertNestedSchemaExistence(t, s, mkFeatures)
test.AssertOptionalArguments(t, featuresSchema, []string{
mkFeaturesNesting,
mkFeaturesKeyControl,
mkFeaturesFUSE,
})
test.AssertValueTypes(t, featuresSchema, map[string]schema.ValueType{
mkFeaturesNesting: schema.TypeBool,
mkFeaturesKeyControl: schema.TypeBool,
mkFeaturesFUSE: schema.TypeBool,
})
initializationSchema := test.AssertNestedSchemaExistence(
t,
s,
mkInitialization,
)
test.AssertOptionalArguments(t, initializationSchema, []string{
mkInitializationDNS,
mkInitializationHostname,
mkInitializationIPConfig,
mkInitializationUserAccount,
})
test.AssertValueTypes(t, initializationSchema, map[string]schema.ValueType{
mkInitializationDNS: schema.TypeList,
mkInitializationHostname: schema.TypeString,
mkInitializationIPConfig: schema.TypeList,
mkInitializationUserAccount: schema.TypeList,
})
initializationDNSSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkInitializationDNS,
)
test.AssertOptionalArguments(t, initializationDNSSchema, []string{
mkInitializationDNSDomain,
mkInitializationDNSServer,
mkInitializationDNSServers,
})
test.AssertValueTypes(t, initializationDNSSchema, map[string]schema.ValueType{
mkInitializationDNSDomain: schema.TypeString,
mkInitializationDNSServer: schema.TypeString,
mkInitializationDNSServers: schema.TypeList,
})
initializationIPConfigSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkInitializationIPConfig,
)
test.AssertOptionalArguments(t, initializationIPConfigSchema, []string{
mkInitializationIPConfigIPv4,
mkInitializationIPConfigIPv6,
})
test.AssertValueTypes(t, initializationIPConfigSchema, map[string]schema.ValueType{
mkInitializationIPConfigIPv4: schema.TypeList,
mkInitializationIPConfigIPv6: schema.TypeList,
})
initializationIPConfigIPv4Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkInitializationIPConfigIPv4,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv4Schema, []string{
mkInitializationIPConfigIPv4Address,
mkInitializationIPConfigIPv4Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv4Schema, map[string]schema.ValueType{
mkInitializationIPConfigIPv4Address: schema.TypeString,
mkInitializationIPConfigIPv4Gateway: schema.TypeString,
})
initializationIPConfigIPv6Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkInitializationIPConfigIPv6,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv6Schema, []string{
mkInitializationIPConfigIPv6Address,
mkInitializationIPConfigIPv6Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv6Schema, map[string]schema.ValueType{
mkInitializationIPConfigIPv6Address: schema.TypeString,
mkInitializationIPConfigIPv6Gateway: schema.TypeString,
})
initializationUserAccountSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkInitializationUserAccount,
)
test.AssertOptionalArguments(t, initializationUserAccountSchema, []string{
mkInitializationUserAccountKeys,
mkInitializationUserAccountPassword,
})
test.AssertValueTypes(t, initializationUserAccountSchema, map[string]schema.ValueType{
mkInitializationUserAccountKeys: schema.TypeList,
mkInitializationUserAccountPassword: schema.TypeString,
})
memorySchema := test.AssertNestedSchemaExistence(t, s, mkMemory)
test.AssertOptionalArguments(t, memorySchema, []string{
mkMemoryDedicated,
mkMemorySwap,
})
test.AssertValueTypes(t, memorySchema, map[string]schema.ValueType{
mkMemoryDedicated: schema.TypeInt,
mkMemorySwap: schema.TypeInt,
})
mountPointSchema := test.AssertNestedSchemaExistence(t, s, mkMountPoint)
test.AssertOptionalArguments(t, mountPointSchema, []string{
mkMountPointACL,
mkMountPointBackup,
mkMountPointMountOptions,
mkMountPointQuota,
mkMountPointReadOnly,
mkMountPointReplicate,
mkMountPointShared,
mkMountPointSize,
})
test.AssertValueTypes(t, mountPointSchema, map[string]schema.ValueType{
mkMountPointACL: schema.TypeBool,
mkMountPointBackup: schema.TypeBool,
mkMountPointMountOptions: schema.TypeList,
mkMountPointPath: schema.TypeString,
mkMountPointQuota: schema.TypeBool,
mkMountPointReadOnly: schema.TypeBool,
mkMountPointReplicate: schema.TypeBool,
mkMountPointShared: schema.TypeBool,
mkMountPointSize: schema.TypeString,
mkMountPointVolume: schema.TypeString,
})
networkInterfaceSchema := test.AssertNestedSchemaExistence(
t,
s,
mkNetworkInterface,
)
test.AssertRequiredArguments(t, networkInterfaceSchema, []string{
mkNetworkInterfaceName,
})
test.AssertOptionalArguments(t, networkInterfaceSchema, []string{
mkNetworkInterfaceBridge,
mkNetworkInterfaceEnabled,
mkNetworkInterfaceMACAddress,
mkNetworkInterfaceRateLimit,
mkNetworkInterfaceVLANID,
mkNetworkInterfaceMTU,
})
test.AssertValueTypes(t, networkInterfaceSchema, map[string]schema.ValueType{
mkNetworkInterfaceBridge: schema.TypeString,
mkNetworkInterfaceEnabled: schema.TypeBool,
mkNetworkInterfaceMACAddress: schema.TypeString,
mkNetworkInterfaceName: schema.TypeString,
mkNetworkInterfaceRateLimit: schema.TypeFloat,
mkNetworkInterfaceVLANID: schema.TypeInt,
mkNetworkInterfaceMTU: schema.TypeInt,
})
operatingSystemSchema := test.AssertNestedSchemaExistence(
t,
s,
mkOperatingSystem,
)
test.AssertRequiredArguments(t, operatingSystemSchema, []string{
mkOperatingSystemTemplateFileID,
})
test.AssertOptionalArguments(t, operatingSystemSchema, []string{
mkOperatingSystemType,
})
test.AssertValueTypes(t, operatingSystemSchema, map[string]schema.ValueType{
mkOperatingSystemTemplateFileID: schema.TypeString,
mkOperatingSystemType: schema.TypeString,
})
}

View File

@ -0,0 +1,55 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package resource
import (
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
)
// MountTypeValidator returns a schema validation function for a mount type on a lxc container.
func MountTypeValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"cifs",
"nfs",
}, false))
}
// ConsoleModeValidator returns a schema validation function for a console mode on a lxc container.
func ConsoleModeValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"console",
"shell",
"tty",
}, false))
}
// CPUArchitectureValidator returns a schema validation function for a CPU architecture on a lxc container.
func CPUArchitectureValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"amd64",
"arm64",
"armhf",
"i386",
}, false))
}
// OperatingSystemTypeValidator returns a schema validation function for an operating system type on a lxc container.
func OperatingSystemTypeValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"alpine",
"archlinux",
"centos",
"debian",
"fedora",
"gentoo",
"nixos",
"opensuse",
"ubuntu",
"unmanaged",
}, false))
}

View File

@ -1,315 +0,0 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package resource
import (
"testing"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/test"
)
// TestContainerInstantiation tests whether the Container instance can be instantiated.
func TestContainerInstantiation(t *testing.T) {
t.Parallel()
s := Container()
if s == nil {
t.Fatalf("Cannot instantiate Container")
}
}
// TestContainerSchema tests the Container schema.
func TestContainerSchema(t *testing.T) {
t.Parallel()
s := Container()
test.AssertRequiredArguments(t, s, []string{
mkResourceVirtualEnvironmentContainerNodeName,
})
test.AssertOptionalArguments(t, s, []string{
mkResourceVirtualEnvironmentContainerCPU,
mkResourceVirtualEnvironmentContainerDescription,
mkResourceVirtualEnvironmentContainerDisk,
mkResourceVirtualEnvironmentContainerInitialization,
mkResourceVirtualEnvironmentContainerMemory,
mkResourceVirtualEnvironmentContainerMountPoint,
mkResourceVirtualEnvironmentContainerOperatingSystem,
mkResourceVirtualEnvironmentContainerPoolID,
mkResourceVirtualEnvironmentContainerStarted,
mkResourceVirtualEnvironmentContainerTags,
mkResourceVirtualEnvironmentContainerTemplate,
mkResourceVirtualEnvironmentContainerUnprivileged,
mkResourceVirtualEnvironmentContainerStartOnBoot,
mkResourceVirtualEnvironmentContainerFeatures,
mkResourceVirtualEnvironmentContainerVMID,
})
test.AssertValueTypes(t, s, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerCPU: schema.TypeList,
mkResourceVirtualEnvironmentContainerDescription: schema.TypeString,
mkResourceVirtualEnvironmentContainerDisk: schema.TypeList,
mkResourceVirtualEnvironmentContainerInitialization: schema.TypeList,
mkResourceVirtualEnvironmentContainerMemory: schema.TypeList,
mkResourceVirtualEnvironmentContainerMountPoint: schema.TypeList,
mkResourceVirtualEnvironmentContainerOperatingSystem: schema.TypeList,
mkResourceVirtualEnvironmentContainerPoolID: schema.TypeString,
mkResourceVirtualEnvironmentContainerStarted: schema.TypeBool,
mkResourceVirtualEnvironmentContainerTags: schema.TypeList,
mkResourceVirtualEnvironmentContainerTemplate: schema.TypeBool,
mkResourceVirtualEnvironmentContainerUnprivileged: schema.TypeBool,
mkResourceVirtualEnvironmentContainerStartOnBoot: schema.TypeBool,
mkResourceVirtualEnvironmentContainerFeatures: schema.TypeList,
mkResourceVirtualEnvironmentContainerVMID: schema.TypeInt,
})
cloneSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentContainerClone)
test.AssertRequiredArguments(t, cloneSchema, []string{
mkResourceVirtualEnvironmentContainerCloneVMID,
})
test.AssertOptionalArguments(t, cloneSchema, []string{
mkResourceVirtualEnvironmentContainerCloneDatastoreID,
mkResourceVirtualEnvironmentContainerCloneNodeName,
})
test.AssertValueTypes(t, cloneSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerCloneDatastoreID: schema.TypeString,
mkResourceVirtualEnvironmentContainerCloneNodeName: schema.TypeString,
mkResourceVirtualEnvironmentContainerCloneVMID: schema.TypeInt,
})
cpuSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentContainerCPU)
test.AssertOptionalArguments(t, cpuSchema, []string{
mkResourceVirtualEnvironmentContainerCPUArchitecture,
mkResourceVirtualEnvironmentContainerCPUCores,
mkResourceVirtualEnvironmentContainerCPUUnits,
})
test.AssertValueTypes(t, cpuSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerCPUArchitecture: schema.TypeString,
mkResourceVirtualEnvironmentContainerCPUCores: schema.TypeInt,
mkResourceVirtualEnvironmentContainerCPUUnits: schema.TypeInt,
})
diskSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentContainerDisk)
test.AssertOptionalArguments(t, diskSchema, []string{
mkResourceVirtualEnvironmentContainerDiskDatastoreID,
})
test.AssertValueTypes(t, diskSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerDiskDatastoreID: schema.TypeString,
})
featuresSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentContainerFeatures)
test.AssertOptionalArguments(t, featuresSchema, []string{
mkResourceVirtualEnvironmentContainerFeaturesNesting,
mkResourceVirtualEnvironmentContainerFeaturesKeyControl,
mkResourceVirtualEnvironmentContainerFeaturesFUSE,
})
test.AssertValueTypes(t, featuresSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerFeaturesNesting: schema.TypeBool,
mkResourceVirtualEnvironmentContainerFeaturesKeyControl: schema.TypeBool,
mkResourceVirtualEnvironmentContainerFeaturesFUSE: schema.TypeBool,
})
initializationSchema := test.AssertNestedSchemaExistence(
t,
s,
mkResourceVirtualEnvironmentContainerInitialization,
)
test.AssertOptionalArguments(t, initializationSchema, []string{
mkResourceVirtualEnvironmentContainerInitializationDNS,
mkResourceVirtualEnvironmentContainerInitializationHostname,
mkResourceVirtualEnvironmentContainerInitializationIPConfig,
mkResourceVirtualEnvironmentContainerInitializationUserAccount,
})
test.AssertValueTypes(t, initializationSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerInitializationDNS: schema.TypeList,
mkResourceVirtualEnvironmentContainerInitializationHostname: schema.TypeString,
mkResourceVirtualEnvironmentContainerInitializationIPConfig: schema.TypeList,
mkResourceVirtualEnvironmentContainerInitializationUserAccount: schema.TypeList,
})
initializationDNSSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkResourceVirtualEnvironmentContainerInitializationDNS,
)
test.AssertOptionalArguments(t, initializationDNSSchema, []string{
mkResourceVirtualEnvironmentContainerInitializationDNSDomain,
mkResourceVirtualEnvironmentContainerInitializationDNSServer,
mkResourceVirtualEnvironmentContainerInitializationDNSServers,
})
test.AssertValueTypes(t, initializationDNSSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerInitializationDNSDomain: schema.TypeString,
mkResourceVirtualEnvironmentContainerInitializationDNSServer: schema.TypeString,
mkResourceVirtualEnvironmentContainerInitializationDNSServers: schema.TypeList,
})
initializationIPConfigSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkResourceVirtualEnvironmentContainerInitializationIPConfig,
)
test.AssertOptionalArguments(t, initializationIPConfigSchema, []string{
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv4,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv6,
})
test.AssertValueTypes(t, initializationIPConfigSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv4: schema.TypeList,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv6: schema.TypeList,
})
initializationIPConfigIPv4Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv4,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv4Schema, []string{
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv4Address,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv4Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv4Schema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv4Address: schema.TypeString,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv4Gateway: schema.TypeString,
})
initializationIPConfigIPv6Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv6,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv6Schema, []string{
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv6Address,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv6Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv6Schema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv6Address: schema.TypeString,
mkResourceVirtualEnvironmentContainerInitializationIPConfigIPv6Gateway: schema.TypeString,
})
initializationUserAccountSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkResourceVirtualEnvironmentContainerInitializationUserAccount,
)
test.AssertOptionalArguments(t, initializationUserAccountSchema, []string{
mkResourceVirtualEnvironmentContainerInitializationUserAccountKeys,
mkResourceVirtualEnvironmentContainerInitializationUserAccountPassword,
})
test.AssertValueTypes(t, initializationUserAccountSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerInitializationUserAccountKeys: schema.TypeList,
mkResourceVirtualEnvironmentContainerInitializationUserAccountPassword: schema.TypeString,
})
memorySchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentContainerMemory)
test.AssertOptionalArguments(t, memorySchema, []string{
mkResourceVirtualEnvironmentContainerMemoryDedicated,
mkResourceVirtualEnvironmentContainerMemorySwap,
})
test.AssertValueTypes(t, memorySchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerMemoryDedicated: schema.TypeInt,
mkResourceVirtualEnvironmentContainerMemorySwap: schema.TypeInt,
})
mountPointSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentContainerMountPoint)
test.AssertOptionalArguments(t, mountPointSchema, []string{
mkResourceVirtualEnvironmentContainerMountPointACL,
mkResourceVirtualEnvironmentContainerMountPointBackup,
mkResourceVirtualEnvironmentContainerMountPointMountOptions,
mkResourceVirtualEnvironmentContainerMountPointQuota,
mkResourceVirtualEnvironmentContainerMountPointReadOnly,
mkResourceVirtualEnvironmentContainerMountPointReplicate,
mkResourceVirtualEnvironmentContainerMountPointShared,
mkResourceVirtualEnvironmentContainerMountPointSize,
})
test.AssertValueTypes(t, mountPointSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerMountPointACL: schema.TypeBool,
mkResourceVirtualEnvironmentContainerMountPointBackup: schema.TypeBool,
mkResourceVirtualEnvironmentContainerMountPointMountOptions: schema.TypeList,
mkResourceVirtualEnvironmentContainerMountPointPath: schema.TypeString,
mkResourceVirtualEnvironmentContainerMountPointQuota: schema.TypeBool,
mkResourceVirtualEnvironmentContainerMountPointReadOnly: schema.TypeBool,
mkResourceVirtualEnvironmentContainerMountPointReplicate: schema.TypeBool,
mkResourceVirtualEnvironmentContainerMountPointShared: schema.TypeBool,
mkResourceVirtualEnvironmentContainerMountPointSize: schema.TypeString,
mkResourceVirtualEnvironmentContainerMountPointVolume: schema.TypeString,
})
networkInterfaceSchema := test.AssertNestedSchemaExistence(
t,
s,
mkResourceVirtualEnvironmentContainerNetworkInterface,
)
test.AssertRequiredArguments(t, networkInterfaceSchema, []string{
mkResourceVirtualEnvironmentContainerNetworkInterfaceName,
})
test.AssertOptionalArguments(t, networkInterfaceSchema, []string{
mkResourceVirtualEnvironmentContainerNetworkInterfaceBridge,
mkResourceVirtualEnvironmentContainerNetworkInterfaceEnabled,
mkResourceVirtualEnvironmentContainerNetworkInterfaceMACAddress,
mkResourceVirtualEnvironmentContainerNetworkInterfaceRateLimit,
mkResourceVirtualEnvironmentContainerNetworkInterfaceVLANID,
mkResourceVirtualEnvironmentContainerNetworkInterfaceMTU,
})
test.AssertValueTypes(t, networkInterfaceSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerNetworkInterfaceBridge: schema.TypeString,
mkResourceVirtualEnvironmentContainerNetworkInterfaceEnabled: schema.TypeBool,
mkResourceVirtualEnvironmentContainerNetworkInterfaceMACAddress: schema.TypeString,
mkResourceVirtualEnvironmentContainerNetworkInterfaceName: schema.TypeString,
mkResourceVirtualEnvironmentContainerNetworkInterfaceRateLimit: schema.TypeFloat,
mkResourceVirtualEnvironmentContainerNetworkInterfaceVLANID: schema.TypeInt,
mkResourceVirtualEnvironmentContainerNetworkInterfaceMTU: schema.TypeInt,
})
operatingSystemSchema := test.AssertNestedSchemaExistence(
t,
s,
mkResourceVirtualEnvironmentContainerOperatingSystem,
)
test.AssertRequiredArguments(t, operatingSystemSchema, []string{
mkResourceVirtualEnvironmentContainerOperatingSystemTemplateFileID,
})
test.AssertOptionalArguments(t, operatingSystemSchema, []string{
mkResourceVirtualEnvironmentContainerOperatingSystemType,
})
test.AssertValueTypes(t, operatingSystemSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentContainerOperatingSystemTemplateFileID: schema.TypeString,
mkResourceVirtualEnvironmentContainerOperatingSystemType: schema.TypeString,
})
}

View File

@ -14,7 +14,7 @@ import (
"github.com/bpg/terraform-provider-proxmox/proxmox/firewall"
"github.com/bpg/terraform-provider-proxmox/proxmoxtf"
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource/validator"
resource "github.com/bpg/terraform-provider-proxmox/proxmoxtf/resource/vm"
)
const (
@ -35,14 +35,14 @@ func selectorSchema() map[string]*schema.Schema {
Optional: true,
Description: "The ID of the VM to manage the firewall for.",
RequiredWith: []string{mkSelectorNodeName},
ValidateDiagFunc: validator.VMID(),
ValidateDiagFunc: resource.VMIDValidator(),
},
mkSelectorContainerID: {
Type: schema.TypeInt,
Optional: true,
Description: "The ID of the container to manage the firewall for.",
RequiredWith: []string{mkSelectorNodeName},
ValidateDiagFunc: validator.VMID(),
ValidateDiagFunc: resource.VMIDValidator(),
},
}
}

View File

@ -1,20 +0,0 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package validator
import (
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
)
// MountType returns a schema validation function for a mount type on a lxc container.
func MountType() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"cifs",
"nfs",
}, false))
}

View File

@ -16,6 +16,16 @@ import (
"github.com/bpg/terraform-provider-proxmox/proxmox/types"
)
// ContentType returns a schema validation function for a content type on a storage device.
func ContentType() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"dump",
"iso",
"snippets",
"vztmpl",
}, false))
}
// FileFormat returns a schema validation function for a file format.
func FileFormat() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{

View File

@ -4,24 +4,26 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package validator
package resource
import (
"fmt"
"regexp"
"strings"
"time"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
)
// VMID returns a schema validation function for a VM ID.
func VMID() schema.SchemaValidateDiagFunc {
// VMIDValidator returns a schema validation function for a VM ID.
func VMIDValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(func(i interface{}, k string) ([]string, []error) {
minID := 100
maxID := 2147483647
var ws []string
var es []error
v, ok := i.(int)
@ -42,26 +44,24 @@ func VMID() schema.SchemaValidateDiagFunc {
})
}
// BIOS returns a schema validation function for a BIOS type.
func BIOS() schema.SchemaValidateDiagFunc {
// BIOSValidator returns a schema validation function for a BIOSValidator type.
func BIOSValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"ovmf",
"seabios",
}, false))
}
// ContentType returns a schema validation function for a content type on a storage device.
func ContentType() schema.SchemaValidateDiagFunc {
// CPUArchitectureValidator returns a schema validation function for a CPU architecture.
func CPUArchitectureValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"dump",
"iso",
"snippets",
"vztmpl",
"aarch64",
"x86_64",
}, false))
}
// CPUType returns a schema validation function for a CPU type.
func CPUType() schema.SchemaValidateDiagFunc {
// CPUTypeValidator returns a schema validation function for a CPU type.
func CPUTypeValidator() schema.SchemaValidateDiagFunc {
standardTypes := []string{
"486",
"Broadwell",
@ -144,18 +144,18 @@ func CPUType() schema.SchemaValidateDiagFunc {
))
}
// NetworkDeviceModel is a schema validation function for network device models.
func NetworkDeviceModel() schema.SchemaValidateDiagFunc {
// NetworkDeviceModelValidator is a schema validation function for network device models.
func NetworkDeviceModelValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{"e1000", "rtl8139", "virtio", "vmxnet3"}, false))
}
// QEMUAgentType is a schema validation function for QEMU agent types.
func QEMUAgentType() schema.SchemaValidateDiagFunc {
// QEMUAgentTypeValidator is a schema validation function for QEMU agent types.
func QEMUAgentTypeValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{"isa", "virtio"}, false))
}
// KeyboardLayout is a schema validation function for keyboard layouts.
func KeyboardLayout() schema.SchemaValidateDiagFunc {
// KeyboardLayoutValidator is a schema validation function for keyboard layouts.
func KeyboardLayoutValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"da",
"de",
@ -185,20 +185,21 @@ func KeyboardLayout() schema.SchemaValidateDiagFunc {
}, false))
}
// MachineType is a schema validation function for machine types.
func MachineType() schema.SchemaValidateDiagFunc {
// MachineTypeValidator is a schema validation function for machine types.
func MachineTypeValidator() schema.SchemaValidateDiagFunc {
//nolint:lll
r := regexp.MustCompile(`^$|^(pc|pc(-i440fx)?-\d+(\.\d+)+(\+pve\d+)?(\.pxe)?|q35|pc-q35-\d+(\.\d+)+(\+pve\d+)?(\.pxe)?|virt(?:-\d+(\.\d+)+)?(\+pve\d+)?)$`)
return validation.ToDiagFunc(validation.StringMatch(r, "must be a valid machine type"))
}
// Timeout is a schema validation function for timeouts.
func Timeout() schema.SchemaValidateDiagFunc {
// TimeoutValidator is a schema validation function for timeouts.
func TimeoutValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(func(i interface{}, k string) ([]string, []error) {
v, ok := i.(string)
var ws []string
var es []error
if !ok {
@ -216,13 +217,13 @@ func Timeout() schema.SchemaValidateDiagFunc {
})
}
// VGAMemory is a schema validation function for VGA memory sizes.
func VGAMemory() schema.SchemaValidateDiagFunc {
// VGAMemoryValidator is a schema validation function for VGA memory sizes.
func VGAMemoryValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.IntBetween(4, 512))
}
// VGAType is a schema validation function for VGA device types.
func VGAType() schema.SchemaValidateDiagFunc {
// VGATypeValidator is a schema validation function for VGA device types.
func VGATypeValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"cirrus",
"qxl",
@ -239,8 +240,8 @@ func VGAType() schema.SchemaValidateDiagFunc {
}, false))
}
// SCSIHardware is a schema validation function for SCSI hardware.
func SCSIHardware() schema.SchemaValidateDiagFunc {
// SCSIHardwareValidator is a schema validation function for SCSI hardware.
func SCSIHardwareValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"lsi",
"lsi53c810",
@ -251,8 +252,8 @@ func SCSIHardware() schema.SchemaValidateDiagFunc {
}, false))
}
// IDEInterface is a schema validation function for IDE interfaces.
func IDEInterface() schema.SchemaValidateDiagFunc {
// IDEInterfaceValidator is a schema validation function for IDE interfaces.
func IDEInterfaceValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"ide0",
"ide1",
@ -261,9 +262,9 @@ func IDEInterface() schema.SchemaValidateDiagFunc {
}, false))
}
// CloudInitInterface is a schema validation function that accepts either an IDE interface identifier or an
// CloudInitInterfaceValidator is a schema validation function that accepts either an IDE interface identifier or an
// empty string, which is used as the default and means "detect which interface should be used automatically".
func CloudInitInterface() schema.SchemaValidateDiagFunc {
func CloudInitInterfaceValidator() schema.SchemaValidateDiagFunc {
r := regexp.MustCompile(`^ide[0-3]|sata[0-5]|scsi(?:30|[12][0-9]|[0-9])$`)
return validation.ToDiagFunc(validation.Any(
@ -272,10 +273,66 @@ func CloudInitInterface() schema.SchemaValidateDiagFunc {
))
}
// CloudInitType is a schema validation function for cloud-init types.
func CloudInitType() schema.SchemaValidateDiagFunc {
// CloudInitTypeValidator is a schema validation function for cloud-init types.
func CloudInitTypeValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"configdrive2",
"nocloud",
}, false))
}
// AudioDeviceValidator is a schema validation function for audio devices.
func AudioDeviceValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"AC97",
"ich9-intel-hda",
"intel-hda",
}, false))
}
// AudioDriverValidator is a schema validation function for audio drivers.
func AudioDriverValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"spice",
}, false))
}
// OperatingSystemTypeValidator is a schema validation function for operating system types.
func OperatingSystemTypeValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(validation.StringInSlice([]string{
"l24",
"l26",
"other",
"solaris",
"w2k",
"w2k3",
"w2k8",
"win7",
"win8",
"win10",
"win11",
"wvista",
"wxp",
}, false))
}
// SerialDeviceValidator is a schema validation function for serial devices.
func SerialDeviceValidator() schema.SchemaValidateDiagFunc {
return validation.ToDiagFunc(func(i interface{}, k string) ([]string, []error) {
v, ok := i.(string)
var es []error
if !ok {
es = append(es, fmt.Errorf("expected type of %s to be string", k))
return nil, es
}
if !strings.HasPrefix(v, "/dev/") && v != "socket" {
es = append(es, fmt.Errorf("expected %s to be '/dev/*' or 'socket'", k))
return nil, es
}
return nil, es
})
}

View File

@ -4,7 +4,7 @@
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package validator
package resource
import (
"testing"
@ -32,7 +32,7 @@ func TestCPUType(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
f := CPUType()
f := CPUTypeValidator()
res := f(tt.value, nil)
if tt.valid {
@ -66,7 +66,7 @@ func TestMachineType(t *testing.T) {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
f := MachineType()
f := MachineTypeValidator()
res := f(tt.value, nil)
if tt.valid {

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,493 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package resource
import (
"testing"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/stretchr/testify/require"
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/test"
)
// TestVMInstantiation tests whether the VM instance can be instantiated.
func TestVMInstantiation(t *testing.T) {
t.Parallel()
s := VM()
if s == nil {
t.Fatalf("Cannot instantiate VM")
}
}
// TestVMSchema tests the VM schema.
func TestVMSchema(t *testing.T) {
t.Parallel()
s := VM()
test.AssertRequiredArguments(t, s, []string{
mkNodeName,
})
test.AssertOptionalArguments(t, s, []string{
mkACPI,
mkAgent,
mkAudioDevice,
mkBIOS,
mkBootOrder,
mkCDROM,
mkClone,
mkCPU,
mkDescription,
mkDisk,
mkEFIDisk,
mkInitialization,
mkHostPCI,
mkHostUSB,
mkKeyboardLayout,
mkKVMArguments,
mkMachine,
mkMemory,
mkName,
mkNetworkDevice,
mkOperatingSystem,
mkPoolID,
mkSerialDevice,
mkStarted,
mkTabletDevice,
mkTemplate,
mkVMID,
mkSCSIHardware,
})
test.AssertComputedAttributes(t, s, []string{
mkIPv4Addresses,
mkIPv6Addresses,
mkMACAddresses,
mkNetworkInterfaceNames,
})
test.AssertValueTypes(t, s, map[string]schema.ValueType{
mkACPI: schema.TypeBool,
mkAgent: schema.TypeList,
mkAudioDevice: schema.TypeList,
mkBIOS: schema.TypeString,
mkBootOrder: schema.TypeList,
mkCDROM: schema.TypeList,
mkCPU: schema.TypeList,
mkDescription: schema.TypeString,
mkDisk: schema.TypeList,
mkEFIDisk: schema.TypeList,
mkHostPCI: schema.TypeList,
mkHostUSB: schema.TypeList,
mkInitialization: schema.TypeList,
mkIPv4Addresses: schema.TypeList,
mkIPv6Addresses: schema.TypeList,
mkKeyboardLayout: schema.TypeString,
mkKVMArguments: schema.TypeString,
mkMachine: schema.TypeString,
mkMemory: schema.TypeList,
mkName: schema.TypeString,
mkNetworkDevice: schema.TypeList,
mkMACAddresses: schema.TypeList,
mkNetworkInterfaceNames: schema.TypeList,
mkOperatingSystem: schema.TypeList,
mkPoolID: schema.TypeString,
mkSerialDevice: schema.TypeList,
mkStarted: schema.TypeBool,
mkTabletDevice: schema.TypeBool,
mkTemplate: schema.TypeBool,
mkVMID: schema.TypeInt,
mkSCSIHardware: schema.TypeString,
})
agentSchema := test.AssertNestedSchemaExistence(t, s, mkAgent)
test.AssertOptionalArguments(t, agentSchema, []string{
mkAgentEnabled,
mkAgentTimeout,
mkAgentTrim,
mkAgentType,
})
test.AssertValueTypes(t, agentSchema, map[string]schema.ValueType{
mkAgentEnabled: schema.TypeBool,
mkAgentTrim: schema.TypeBool,
mkAgentType: schema.TypeString,
})
audioDeviceSchema := test.AssertNestedSchemaExistence(t, s, mkAudioDevice)
test.AssertOptionalArguments(t, audioDeviceSchema, []string{
mkAudioDeviceDevice,
mkAudioDeviceDriver,
})
test.AssertValueTypes(t, audioDeviceSchema, map[string]schema.ValueType{
mkAudioDeviceDevice: schema.TypeString,
mkAudioDeviceDriver: schema.TypeString,
})
cdromSchema := test.AssertNestedSchemaExistence(t, s, mkCDROM)
test.AssertOptionalArguments(t, cdromSchema, []string{
mkCDROMEnabled,
mkCDROMFileID,
})
test.AssertValueTypes(t, cdromSchema, map[string]schema.ValueType{
mkCDROMEnabled: schema.TypeBool,
mkCDROMFileID: schema.TypeString,
})
cloneSchema := test.AssertNestedSchemaExistence(t, s, mkClone)
test.AssertRequiredArguments(t, cloneSchema, []string{
mkCloneVMID,
})
test.AssertOptionalArguments(t, cloneSchema, []string{
mkCloneDatastoreID,
mkCloneNodeName,
})
test.AssertValueTypes(t, cloneSchema, map[string]schema.ValueType{
mkCloneDatastoreID: schema.TypeString,
mkCloneNodeName: schema.TypeString,
mkCloneVMID: schema.TypeInt,
})
cpuSchema := test.AssertNestedSchemaExistence(t, s, mkCPU)
test.AssertOptionalArguments(t, cpuSchema, []string{
mkCPUArchitecture,
mkCPUCores,
mkCPUFlags,
mkCPUHotplugged,
mkCPUNUMA,
mkCPUSockets,
mkCPUType,
mkCPUUnits,
})
test.AssertValueTypes(t, cpuSchema, map[string]schema.ValueType{
mkCPUArchitecture: schema.TypeString,
mkCPUCores: schema.TypeInt,
mkCPUFlags: schema.TypeList,
mkCPUHotplugged: schema.TypeInt,
mkCPUNUMA: schema.TypeBool,
mkCPUSockets: schema.TypeInt,
mkCPUType: schema.TypeString,
mkCPUUnits: schema.TypeInt,
})
diskSchema := test.AssertNestedSchemaExistence(t, s, mkDisk)
test.AssertOptionalArguments(t, diskSchema, []string{
mkDiskDatastoreID,
mkDiskPathInDatastore,
mkDiskFileFormat,
mkDiskFileID,
mkDiskSize,
})
test.AssertValueTypes(t, diskSchema, map[string]schema.ValueType{
mkDiskDatastoreID: schema.TypeString,
mkDiskPathInDatastore: schema.TypeString,
mkDiskFileFormat: schema.TypeString,
mkDiskFileID: schema.TypeString,
mkDiskSize: schema.TypeInt,
})
diskSpeedSchema := test.AssertNestedSchemaExistence(
t,
diskSchema,
mkDiskSpeed,
)
test.AssertOptionalArguments(t, diskSpeedSchema, []string{
mkDiskSpeedRead,
mkDiskSpeedReadBurstable,
mkDiskSpeedWrite,
mkDiskSpeedWriteBurstable,
})
test.AssertValueTypes(t, diskSpeedSchema, map[string]schema.ValueType{
mkDiskSpeedRead: schema.TypeInt,
mkDiskSpeedReadBurstable: schema.TypeInt,
mkDiskSpeedWrite: schema.TypeInt,
mkDiskSpeedWriteBurstable: schema.TypeInt,
})
efiDiskSchema := test.AssertNestedSchemaExistence(t, s, mkEFIDisk)
test.AssertOptionalArguments(t, efiDiskSchema, []string{
mkEFIDiskDatastoreID,
mkEFIDiskFileFormat,
mkEFIDiskType,
})
test.AssertValueTypes(t, efiDiskSchema, map[string]schema.ValueType{
mkEFIDiskDatastoreID: schema.TypeString,
mkEFIDiskFileFormat: schema.TypeString,
mkEFIDiskType: schema.TypeString,
})
initializationSchema := test.AssertNestedSchemaExistence(
t,
s,
mkInitialization,
)
test.AssertOptionalArguments(t, initializationSchema, []string{
mkInitializationDatastoreID,
mkInitializationInterface,
mkInitializationDNS,
mkInitializationIPConfig,
mkInitializationUserAccount,
})
test.AssertValueTypes(t, initializationSchema, map[string]schema.ValueType{
mkInitializationDatastoreID: schema.TypeString,
mkInitializationInterface: schema.TypeString,
mkInitializationDNS: schema.TypeList,
mkInitializationIPConfig: schema.TypeList,
mkInitializationUserAccount: schema.TypeList,
})
hostPCISchema := test.AssertNestedSchemaExistence(t, s, mkHostPCI)
test.AssertOptionalArguments(t, hostPCISchema, []string{
mkHostPCIDeviceMDev,
mkHostPCIDevicePCIE,
mkHostPCIDeviceROMBAR,
mkHostPCIDeviceROMFile,
mkHostPCIDeviceXVGA,
})
test.AssertValueTypes(t, hostPCISchema, map[string]schema.ValueType{
mkHostPCIDevice: schema.TypeString,
mkHostPCIDeviceMDev: schema.TypeString,
mkHostPCIDevicePCIE: schema.TypeBool,
mkHostPCIDeviceROMBAR: schema.TypeBool,
mkHostPCIDeviceROMFile: schema.TypeString,
mkHostPCIDeviceXVGA: schema.TypeBool,
})
hostUSBSchema := test.AssertNestedSchemaExistence(t, s, mkHostUSB)
test.AssertOptionalArguments(t, hostUSBSchema, []string{
mkHostUSBDeviceMapping,
})
test.AssertValueTypes(t, hostUSBSchema, map[string]schema.ValueType{
mkHostUSBDevice: schema.TypeString,
mkHostUSBDeviceUSB3: schema.TypeBool,
})
initializationDNSSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkInitializationDNS,
)
test.AssertOptionalArguments(t, initializationDNSSchema, []string{
mkInitializationDNSDomain,
mkInitializationDNSServer,
mkInitializationDNSServers,
})
test.AssertValueTypes(t, initializationDNSSchema, map[string]schema.ValueType{
mkInitializationDNSDomain: schema.TypeString,
mkInitializationDNSServer: schema.TypeString,
mkInitializationDNSServers: schema.TypeList,
})
initializationIPConfigSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkInitializationIPConfig,
)
test.AssertOptionalArguments(t, initializationIPConfigSchema, []string{
mkInitializationIPConfigIPv4,
mkInitializationIPConfigIPv6,
})
test.AssertValueTypes(t, initializationIPConfigSchema, map[string]schema.ValueType{
mkInitializationIPConfigIPv4: schema.TypeList,
mkInitializationIPConfigIPv6: schema.TypeList,
})
initializationIPConfigIPv4Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkInitializationIPConfigIPv4,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv4Schema, []string{
mkInitializationIPConfigIPv4Address,
mkInitializationIPConfigIPv4Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv4Schema, map[string]schema.ValueType{
mkInitializationIPConfigIPv4Address: schema.TypeString,
mkInitializationIPConfigIPv4Gateway: schema.TypeString,
})
initializationIPConfigIPv6Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkInitializationIPConfigIPv6,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv6Schema, []string{
mkInitializationIPConfigIPv6Address,
mkInitializationIPConfigIPv6Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv6Schema, map[string]schema.ValueType{
mkInitializationIPConfigIPv6Address: schema.TypeString,
mkInitializationIPConfigIPv6Gateway: schema.TypeString,
})
initializationUserAccountSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkInitializationUserAccount,
)
test.AssertOptionalArguments(t, initializationUserAccountSchema, []string{
mkInitializationUserAccountKeys,
mkInitializationUserAccountPassword,
mkInitializationUserAccountUsername,
})
test.AssertValueTypes(t, initializationUserAccountSchema, map[string]schema.ValueType{
mkInitializationUserAccountKeys: schema.TypeList,
mkInitializationUserAccountPassword: schema.TypeString,
mkInitializationUserAccountUsername: schema.TypeString,
})
memorySchema := test.AssertNestedSchemaExistence(t, s, mkMemory)
test.AssertOptionalArguments(t, memorySchema, []string{
mkMemoryDedicated,
mkMemoryFloating,
mkMemoryShared,
})
test.AssertValueTypes(t, memorySchema, map[string]schema.ValueType{
mkMemoryDedicated: schema.TypeInt,
mkMemoryFloating: schema.TypeInt,
mkMemoryShared: schema.TypeInt,
})
networkDeviceSchema := test.AssertNestedSchemaExistence(
t,
s,
mkNetworkDevice,
)
test.AssertOptionalArguments(t, networkDeviceSchema, []string{
mkNetworkDeviceBridge,
mkNetworkDeviceEnabled,
mkNetworkDeviceMACAddress,
mkNetworkDeviceModel,
mkNetworkDeviceRateLimit,
mkNetworkDeviceVLANID,
mkNetworkDeviceMTU,
})
test.AssertValueTypes(t, networkDeviceSchema, map[string]schema.ValueType{
mkNetworkDeviceBridge: schema.TypeString,
mkNetworkDeviceEnabled: schema.TypeBool,
mkNetworkDeviceMACAddress: schema.TypeString,
mkNetworkDeviceModel: schema.TypeString,
mkNetworkDeviceRateLimit: schema.TypeFloat,
mkNetworkDeviceVLANID: schema.TypeInt,
mkNetworkDeviceMTU: schema.TypeInt,
})
operatingSystemSchema := test.AssertNestedSchemaExistence(
t,
s,
mkOperatingSystem,
)
test.AssertOptionalArguments(t, operatingSystemSchema, []string{
mkOperatingSystemType,
})
test.AssertValueTypes(t, operatingSystemSchema, map[string]schema.ValueType{
mkOperatingSystemType: schema.TypeString,
})
serialDeviceSchema := test.AssertNestedSchemaExistence(
t,
s,
mkSerialDevice,
)
test.AssertOptionalArguments(t, serialDeviceSchema, []string{
mkSerialDeviceDevice,
})
test.AssertValueTypes(t, serialDeviceSchema, map[string]schema.ValueType{
mkSerialDeviceDevice: schema.TypeString,
})
vgaSchema := test.AssertNestedSchemaExistence(t, s, mkVGA)
test.AssertOptionalArguments(t, vgaSchema, []string{
mkVGAEnabled,
mkVGAMemory,
mkVGAType,
})
test.AssertValueTypes(t, vgaSchema, map[string]schema.ValueType{
mkVGAEnabled: schema.TypeBool,
mkVGAMemory: schema.TypeInt,
mkVGAType: schema.TypeString,
})
}
func Test_parseImportIDWIthNodeName(t *testing.T) {
t.Parallel()
tests := []struct {
name string
value string
valid bool
expectedNodeName string
expectedID string
}{
{"empty", "", false, "", ""},
{"missing slash", "invalid", false, "", ""},
{"valid", "host/id", true, "host", "id"},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
nodeName, id, err := parseImportIDWithNodeName(tt.value)
if !tt.valid {
require.Error(t, err)
return
}
require.NoError(t, err)
require.Equal(t, tt.expectedNodeName, nodeName)
require.Equal(t, tt.expectedID, id)
})
}
}

View File

@ -1,492 +0,0 @@
/*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*/
package resource
import (
"testing"
"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
"github.com/stretchr/testify/require"
"github.com/bpg/terraform-provider-proxmox/proxmoxtf/test"
)
// TestVMInstantiation tests whether the VM instance can be instantiated.
func TestVMInstantiation(t *testing.T) {
t.Parallel()
s := VM()
if s == nil {
t.Fatalf("Cannot instantiate VM")
}
}
// TestVMSchema tests the VM schema.
func TestVMSchema(t *testing.T) {
t.Parallel()
s := VM()
test.AssertRequiredArguments(t, s, []string{
mkResourceVirtualEnvironmentVMNodeName,
})
test.AssertOptionalArguments(t, s, []string{
mkResourceVirtualEnvironmentVMACPI,
mkResourceVirtualEnvironmentVMAgent,
mkResourceVirtualEnvironmentVMAudioDevice,
mkResourceVirtualEnvironmentVMBIOS,
mkResourceVirtualEnvironmentVMBootOrder,
mkResourceVirtualEnvironmentVMCDROM,
mkResourceVirtualEnvironmentVMClone,
mkResourceVirtualEnvironmentVMCPU,
mkResourceVirtualEnvironmentVMDescription,
mkResourceVirtualEnvironmentVMDisk,
mkResourceVirtualEnvironmentVMEFIDisk,
mkResourceVirtualEnvironmentVMInitialization,
mkResourceVirtualEnvironmentVMHostPCI,
mkResourceVirtualEnvironmentVMHostUSB,
mkResourceVirtualEnvironmentVMKeyboardLayout,
mkResourceVirtualEnvironmentVMKVMArguments,
mkResourceVirtualEnvironmentVMMachine,
mkResourceVirtualEnvironmentVMMemory,
mkResourceVirtualEnvironmentVMName,
mkResourceVirtualEnvironmentVMNetworkDevice,
mkResourceVirtualEnvironmentVMOperatingSystem,
mkResourceVirtualEnvironmentVMPoolID,
mkResourceVirtualEnvironmentVMSerialDevice,
mkResourceVirtualEnvironmentVMStarted,
mkResourceVirtualEnvironmentVMTabletDevice,
mkResourceVirtualEnvironmentVMTemplate,
mkResourceVirtualEnvironmentVMVMID,
mkResourceVirtualEnvironmentVMSCSIHardware,
})
test.AssertComputedAttributes(t, s, []string{
mkResourceVirtualEnvironmentVMIPv4Addresses,
mkResourceVirtualEnvironmentVMIPv6Addresses,
mkResourceVirtualEnvironmentVMMACAddresses,
mkResourceVirtualEnvironmentVMNetworkInterfaceNames,
})
test.AssertValueTypes(t, s, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMACPI: schema.TypeBool,
mkResourceVirtualEnvironmentVMAgent: schema.TypeList,
mkResourceVirtualEnvironmentVMAudioDevice: schema.TypeList,
mkResourceVirtualEnvironmentVMBIOS: schema.TypeString,
mkResourceVirtualEnvironmentVMBootOrder: schema.TypeList,
mkResourceVirtualEnvironmentVMCDROM: schema.TypeList,
mkResourceVirtualEnvironmentVMCPU: schema.TypeList,
mkResourceVirtualEnvironmentVMDescription: schema.TypeString,
mkResourceVirtualEnvironmentVMDisk: schema.TypeList,
mkResourceVirtualEnvironmentVMEFIDisk: schema.TypeList,
mkResourceVirtualEnvironmentVMHostPCI: schema.TypeList,
mkResourceVirtualEnvironmentVMHostUSB: schema.TypeList,
mkResourceVirtualEnvironmentVMInitialization: schema.TypeList,
mkResourceVirtualEnvironmentVMIPv4Addresses: schema.TypeList,
mkResourceVirtualEnvironmentVMIPv6Addresses: schema.TypeList,
mkResourceVirtualEnvironmentVMKeyboardLayout: schema.TypeString,
mkResourceVirtualEnvironmentVMKVMArguments: schema.TypeString,
mkResourceVirtualEnvironmentVMMachine: schema.TypeString,
mkResourceVirtualEnvironmentVMMemory: schema.TypeList,
mkResourceVirtualEnvironmentVMName: schema.TypeString,
mkResourceVirtualEnvironmentVMNetworkDevice: schema.TypeList,
mkResourceVirtualEnvironmentVMMACAddresses: schema.TypeList,
mkResourceVirtualEnvironmentVMNetworkInterfaceNames: schema.TypeList,
mkResourceVirtualEnvironmentVMOperatingSystem: schema.TypeList,
mkResourceVirtualEnvironmentVMPoolID: schema.TypeString,
mkResourceVirtualEnvironmentVMSerialDevice: schema.TypeList,
mkResourceVirtualEnvironmentVMStarted: schema.TypeBool,
mkResourceVirtualEnvironmentVMTabletDevice: schema.TypeBool,
mkResourceVirtualEnvironmentVMTemplate: schema.TypeBool,
mkResourceVirtualEnvironmentVMVMID: schema.TypeInt,
mkResourceVirtualEnvironmentVMSCSIHardware: schema.TypeString,
})
agentSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMAgent)
test.AssertOptionalArguments(t, agentSchema, []string{
mkResourceVirtualEnvironmentVMAgentEnabled,
mkResourceVirtualEnvironmentVMAgentTimeout,
mkResourceVirtualEnvironmentVMAgentTrim,
mkResourceVirtualEnvironmentVMAgentType,
})
test.AssertValueTypes(t, agentSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMAgentEnabled: schema.TypeBool,
mkResourceVirtualEnvironmentVMAgentTrim: schema.TypeBool,
mkResourceVirtualEnvironmentVMAgentType: schema.TypeString,
})
audioDeviceSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMAudioDevice)
test.AssertOptionalArguments(t, audioDeviceSchema, []string{
mkResourceVirtualEnvironmentVMAudioDeviceDevice,
mkResourceVirtualEnvironmentVMAudioDeviceDriver,
})
test.AssertValueTypes(t, audioDeviceSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMAudioDeviceDevice: schema.TypeString,
mkResourceVirtualEnvironmentVMAudioDeviceDriver: schema.TypeString,
})
cdromSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMCDROM)
test.AssertOptionalArguments(t, cdromSchema, []string{
mkResourceVirtualEnvironmentVMCDROMEnabled,
mkResourceVirtualEnvironmentVMCDROMFileID,
})
test.AssertValueTypes(t, cdromSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMCDROMEnabled: schema.TypeBool,
mkResourceVirtualEnvironmentVMCDROMFileID: schema.TypeString,
})
cloneSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMClone)
test.AssertRequiredArguments(t, cloneSchema, []string{
mkResourceVirtualEnvironmentVMCloneVMID,
})
test.AssertOptionalArguments(t, cloneSchema, []string{
mkResourceVirtualEnvironmentVMCloneDatastoreID,
mkResourceVirtualEnvironmentVMCloneNodeName,
})
test.AssertValueTypes(t, cloneSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMCloneDatastoreID: schema.TypeString,
mkResourceVirtualEnvironmentVMCloneNodeName: schema.TypeString,
mkResourceVirtualEnvironmentVMCloneVMID: schema.TypeInt,
})
cpuSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMCPU)
test.AssertOptionalArguments(t, cpuSchema, []string{
mkResourceVirtualEnvironmentVMCPUArchitecture,
mkResourceVirtualEnvironmentVMCPUCores,
mkResourceVirtualEnvironmentVMCPUFlags,
mkResourceVirtualEnvironmentVMCPUHotplugged,
mkResourceVirtualEnvironmentVMCPUNUMA,
mkResourceVirtualEnvironmentVMCPUSockets,
mkResourceVirtualEnvironmentVMCPUType,
mkResourceVirtualEnvironmentVMCPUUnits,
})
test.AssertValueTypes(t, cpuSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMCPUArchitecture: schema.TypeString,
mkResourceVirtualEnvironmentVMCPUCores: schema.TypeInt,
mkResourceVirtualEnvironmentVMCPUFlags: schema.TypeList,
mkResourceVirtualEnvironmentVMCPUHotplugged: schema.TypeInt,
mkResourceVirtualEnvironmentVMCPUNUMA: schema.TypeBool,
mkResourceVirtualEnvironmentVMCPUSockets: schema.TypeInt,
mkResourceVirtualEnvironmentVMCPUType: schema.TypeString,
mkResourceVirtualEnvironmentVMCPUUnits: schema.TypeInt,
})
diskSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMDisk)
test.AssertOptionalArguments(t, diskSchema, []string{
mkResourceVirtualEnvironmentVMDiskDatastoreID,
mkResourceVirtualEnvironmentVMDiskPathInDatastore,
mkResourceVirtualEnvironmentVMDiskFileFormat,
mkResourceVirtualEnvironmentVMDiskFileID,
mkResourceVirtualEnvironmentVMDiskSize,
})
test.AssertValueTypes(t, diskSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMDiskDatastoreID: schema.TypeString,
mkResourceVirtualEnvironmentVMDiskPathInDatastore: schema.TypeString,
mkResourceVirtualEnvironmentVMDiskFileFormat: schema.TypeString,
mkResourceVirtualEnvironmentVMDiskFileID: schema.TypeString,
mkResourceVirtualEnvironmentVMDiskSize: schema.TypeInt,
})
diskSpeedSchema := test.AssertNestedSchemaExistence(
t,
diskSchema,
mkResourceVirtualEnvironmentVMDiskSpeed,
)
test.AssertOptionalArguments(t, diskSpeedSchema, []string{
mkResourceVirtualEnvironmentVMDiskSpeedRead,
mkResourceVirtualEnvironmentVMDiskSpeedReadBurstable,
mkResourceVirtualEnvironmentVMDiskSpeedWrite,
mkResourceVirtualEnvironmentVMDiskSpeedWriteBurstable,
})
test.AssertValueTypes(t, diskSpeedSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMDiskSpeedRead: schema.TypeInt,
mkResourceVirtualEnvironmentVMDiskSpeedReadBurstable: schema.TypeInt,
mkResourceVirtualEnvironmentVMDiskSpeedWrite: schema.TypeInt,
mkResourceVirtualEnvironmentVMDiskSpeedWriteBurstable: schema.TypeInt,
})
efiDiskSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMEFIDisk)
test.AssertOptionalArguments(t, efiDiskSchema, []string{
mkResourceVirtualEnvironmentVMEFIDiskDatastoreID,
mkResourceVirtualEnvironmentVMEFIDiskFileFormat,
mkResourceVirtualEnvironmentVMEFIDiskType,
})
test.AssertValueTypes(t, efiDiskSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMEFIDiskDatastoreID: schema.TypeString,
mkResourceVirtualEnvironmentVMEFIDiskFileFormat: schema.TypeString,
mkResourceVirtualEnvironmentVMEFIDiskType: schema.TypeString,
})
initializationSchema := test.AssertNestedSchemaExistence(
t,
s,
mkResourceVirtualEnvironmentVMInitialization,
)
test.AssertOptionalArguments(t, initializationSchema, []string{
mkResourceVirtualEnvironmentVMInitializationDatastoreID,
mkResourceVirtualEnvironmentVMInitializationInterface,
mkResourceVirtualEnvironmentVMInitializationDNS,
mkResourceVirtualEnvironmentVMInitializationIPConfig,
mkResourceVirtualEnvironmentVMInitializationUserAccount,
})
test.AssertValueTypes(t, initializationSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMInitializationDatastoreID: schema.TypeString,
mkResourceVirtualEnvironmentVMInitializationInterface: schema.TypeString,
mkResourceVirtualEnvironmentVMInitializationDNS: schema.TypeList,
mkResourceVirtualEnvironmentVMInitializationIPConfig: schema.TypeList,
mkResourceVirtualEnvironmentVMInitializationUserAccount: schema.TypeList,
})
hostPCISchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMHostPCI)
test.AssertOptionalArguments(t, hostPCISchema, []string{
mkResourceVirtualEnvironmentVMHostPCIDeviceMDev,
mkResourceVirtualEnvironmentVMHostPCIDevicePCIE,
mkResourceVirtualEnvironmentVMHostPCIDeviceROMBAR,
mkResourceVirtualEnvironmentVMHostPCIDeviceROMFile,
mkResourceVirtualEnvironmentVMHostPCIDeviceXVGA,
})
test.AssertValueTypes(t, hostPCISchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMHostPCIDevice: schema.TypeString,
mkResourceVirtualEnvironmentVMHostPCIDeviceMDev: schema.TypeString,
mkResourceVirtualEnvironmentVMHostPCIDevicePCIE: schema.TypeBool,
mkResourceVirtualEnvironmentVMHostPCIDeviceROMBAR: schema.TypeBool,
mkResourceVirtualEnvironmentVMHostPCIDeviceROMFile: schema.TypeString,
mkResourceVirtualEnvironmentVMHostPCIDeviceXVGA: schema.TypeBool,
})
hostUSBSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMHostUSB)
test.AssertOptionalArguments(t, hostUSBSchema, []string{
mkResourceVirtualEnvironmentVMHostUSBDeviceMapping,
})
test.AssertValueTypes(t, hostUSBSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMHostUSBDevice: schema.TypeString,
mkResourceVirtualEnvironmentVMHostUSBDeviceUSB3: schema.TypeBool,
})
initializationDNSSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkResourceVirtualEnvironmentVMInitializationDNS,
)
test.AssertOptionalArguments(t, initializationDNSSchema, []string{
mkResourceVirtualEnvironmentVMInitializationDNSDomain,
mkResourceVirtualEnvironmentVMInitializationDNSServer,
mkResourceVirtualEnvironmentVMInitializationDNSServers,
})
test.AssertValueTypes(t, initializationDNSSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMInitializationDNSDomain: schema.TypeString,
mkResourceVirtualEnvironmentVMInitializationDNSServer: schema.TypeString,
mkResourceVirtualEnvironmentVMInitializationDNSServers: schema.TypeList,
})
initializationIPConfigSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkResourceVirtualEnvironmentVMInitializationIPConfig,
)
test.AssertOptionalArguments(t, initializationIPConfigSchema, []string{
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6,
})
test.AssertValueTypes(t, initializationIPConfigSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4: schema.TypeList,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6: schema.TypeList,
})
initializationIPConfigIPv4Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv4Schema, []string{
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Address,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv4Schema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Address: schema.TypeString,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv4Gateway: schema.TypeString,
})
initializationIPConfigIPv6Schema := test.AssertNestedSchemaExistence(
t,
initializationIPConfigSchema,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6,
)
test.AssertOptionalArguments(t, initializationIPConfigIPv6Schema, []string{
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Address,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Gateway,
})
test.AssertValueTypes(t, initializationIPConfigIPv6Schema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Address: schema.TypeString,
mkResourceVirtualEnvironmentVMInitializationIPConfigIPv6Gateway: schema.TypeString,
})
initializationUserAccountSchema := test.AssertNestedSchemaExistence(
t,
initializationSchema,
mkResourceVirtualEnvironmentVMInitializationUserAccount,
)
test.AssertOptionalArguments(t, initializationUserAccountSchema, []string{
mkResourceVirtualEnvironmentVMInitializationUserAccountKeys,
mkResourceVirtualEnvironmentVMInitializationUserAccountPassword,
mkResourceVirtualEnvironmentVMInitializationUserAccountUsername,
})
test.AssertValueTypes(t, initializationUserAccountSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMInitializationUserAccountKeys: schema.TypeList,
mkResourceVirtualEnvironmentVMInitializationUserAccountPassword: schema.TypeString,
mkResourceVirtualEnvironmentVMInitializationUserAccountUsername: schema.TypeString,
})
memorySchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMMemory)
test.AssertOptionalArguments(t, memorySchema, []string{
mkResourceVirtualEnvironmentVMMemoryDedicated,
mkResourceVirtualEnvironmentVMMemoryFloating,
mkResourceVirtualEnvironmentVMMemoryShared,
})
test.AssertValueTypes(t, memorySchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMMemoryDedicated: schema.TypeInt,
mkResourceVirtualEnvironmentVMMemoryFloating: schema.TypeInt,
mkResourceVirtualEnvironmentVMMemoryShared: schema.TypeInt,
})
networkDeviceSchema := test.AssertNestedSchemaExistence(
t,
s,
mkResourceVirtualEnvironmentVMNetworkDevice,
)
test.AssertOptionalArguments(t, networkDeviceSchema, []string{
mkResourceVirtualEnvironmentVMNetworkDeviceBridge,
mkResourceVirtualEnvironmentVMNetworkDeviceEnabled,
mkResourceVirtualEnvironmentVMNetworkDeviceMACAddress,
mkResourceVirtualEnvironmentVMNetworkDeviceModel,
mkResourceVirtualEnvironmentVMNetworkDeviceRateLimit,
mkResourceVirtualEnvironmentVMNetworkDeviceVLANID,
mkResourceVirtualEnvironmentVMNetworkDeviceMTU,
})
test.AssertValueTypes(t, networkDeviceSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMNetworkDeviceBridge: schema.TypeString,
mkResourceVirtualEnvironmentVMNetworkDeviceEnabled: schema.TypeBool,
mkResourceVirtualEnvironmentVMNetworkDeviceMACAddress: schema.TypeString,
mkResourceVirtualEnvironmentVMNetworkDeviceModel: schema.TypeString,
mkResourceVirtualEnvironmentVMNetworkDeviceRateLimit: schema.TypeFloat,
mkResourceVirtualEnvironmentVMNetworkDeviceVLANID: schema.TypeInt,
mkResourceVirtualEnvironmentVMNetworkDeviceMTU: schema.TypeInt,
})
operatingSystemSchema := test.AssertNestedSchemaExistence(
t,
s,
mkResourceVirtualEnvironmentVMOperatingSystem,
)
test.AssertOptionalArguments(t, operatingSystemSchema, []string{
mkResourceVirtualEnvironmentVMOperatingSystemType,
})
test.AssertValueTypes(t, operatingSystemSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMOperatingSystemType: schema.TypeString,
})
serialDeviceSchema := test.AssertNestedSchemaExistence(
t,
s,
mkResourceVirtualEnvironmentVMSerialDevice,
)
test.AssertOptionalArguments(t, serialDeviceSchema, []string{
mkResourceVirtualEnvironmentVMSerialDeviceDevice,
})
test.AssertValueTypes(t, serialDeviceSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMSerialDeviceDevice: schema.TypeString,
})
vgaSchema := test.AssertNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentVMVGA)
test.AssertOptionalArguments(t, vgaSchema, []string{
mkResourceVirtualEnvironmentVMVGAEnabled,
mkResourceVirtualEnvironmentVMVGAMemory,
mkResourceVirtualEnvironmentVMVGAType,
})
test.AssertValueTypes(t, vgaSchema, map[string]schema.ValueType{
mkResourceVirtualEnvironmentVMVGAEnabled: schema.TypeBool,
mkResourceVirtualEnvironmentVMVGAMemory: schema.TypeInt,
mkResourceVirtualEnvironmentVMVGAType: schema.TypeString,
})
}
func Test_parseImportIDWIthNodeName(t *testing.T) {
t.Parallel()
tests := []struct {
name string
value string
valid bool
expectedNodeName string
expectedID string
}{
{"empty", "", false, "", ""},
{"missing slash", "invalid", false, "", ""},
{"valid", "host/id", true, "host", "id"},
}
for _, tt := range tests {
tt := tt
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
nodeName, id, err := parseImportIDWithNodeName(tt.value)
if !tt.valid {
require.Error(t, err)
return
}
require.NoError(t, err)
require.Equal(t, tt.expectedNodeName, nodeName)
require.Equal(t, tt.expectedID, id)
})
}
}