mirrors/terraform-provider-proxmox
0
0
Fork 0
mirror of https://github.com/bpg/terraform-provider-proxmox.git synced 2025-08-22 19:38:35 +00:00
Code

Minor refactoring

Browse Source
This commit is contained in:
Dan Petersen 2019-12-14 15:25:10 +01:00
parent 107267f93f
commit 3ba91855cc
27 changed files with 620 additions and 273 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
README.md
View File

@ -101,11 +101,11 @@ This data source doesn't accept arguments.
###### Attributes
* `comment` - The pool comment
* `members` - The pool members
* `datastore_id` - The datastore id
* `id` - The member id
* `node` - The node id
* `storage` - The storage id
* `node_name` - The node name
* `type` - The member type
* `virtual_machine_id` - The virtual machine id
* `vm_id` - The virtual machine id
##### Pools (proxmox_virtual_environment_pools)
@ -174,7 +174,7 @@ This data source doesn't accept arguments.
This data source doesn't accept arguments.
###### Attributes
* `keyboard` - The keyboard layout
* `keyboard_layout` - The keyboard layout
* `release` - The release number
* `repository_id` - The repository id
* `version` - The version string
@ -216,11 +216,11 @@ This data source doesn't accept arguments.
###### Attributes
* `members` - The pool members
* `datastore_id` - The datastore id
* `id` - The member id
* `node` - The node id
* `storage` - The storage id
* `node_name` - The node name
* `type` - The member type
* `virtual_machine_id` - The virtual machine id
* `vm_id` - The virtual machine id
##### Role (proxmox_virtual_environment_role)

41
data_source_virtual_environment_datastores_test.go
View File

@ -5,6 +5,7 @@
package main
import (
"github.com/hashicorp/terraform/helper/schema"
"testing"
)
@ -21,7 +22,11 @@ func TestDataSourceVirtualEnvironmentDatastoresInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentDatastoresSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentDatastores()
attributeKeys := []string{
testRequiredArguments(t, s, []string{
mkDataSourceVirtualEnvironmentDatastoresNodeName,
})
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentDatastoresActive,
mkDataSourceVirtualEnvironmentDatastoresContentTypes,
mkDataSourceVirtualEnvironmentDatastoresDatastoreIDs,
@ -31,15 +36,29 @@ func TestDataSourceVirtualEnvironmentDatastoresSchema(t *testing.T) {
mkDataSourceVirtualEnvironmentDatastoresSpaceTotal,
mkDataSourceVirtualEnvironmentDatastoresSpaceUsed,
mkDataSourceVirtualEnvironmentDatastoresTypes,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentDatastores.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentDatastores.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentDatastoresActive,
mkDataSourceVirtualEnvironmentDatastoresContentTypes,
mkDataSourceVirtualEnvironmentDatastoresDatastoreIDs,
mkDataSourceVirtualEnvironmentDatastoresEnabled,
mkDataSourceVirtualEnvironmentDatastoresNodeName,
mkDataSourceVirtualEnvironmentDatastoresShared,
mkDataSourceVirtualEnvironmentDatastoresSpaceAvailable,
mkDataSourceVirtualEnvironmentDatastoresSpaceTotal,
mkDataSourceVirtualEnvironmentDatastoresSpaceUsed,
mkDataSourceVirtualEnvironmentDatastoresTypes,
}, []schema.ValueType{
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeString,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
})
}

12
data_source_virtual_environment_group.go
View File

@ -24,26 +24,22 @@ func dataSourceVirtualEnvironmentGroup() *schema.Resource {
mkDataSourceVirtualEnvironmentGroupACL: &schema.Schema{
Type: schema.TypeSet,
Description: "The access control list",
Optional: true,
DefaultFunc: func() (interface{}, error) {
return make([]interface{}, 0), nil
},
Computed: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
mkDataSourceVirtualEnvironmentGroupACLPath: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The path",
},
mkDataSourceVirtualEnvironmentGroupACLPropagate: {
Type: schema.TypeBool,
Optional: true,
Computed: true,
Description: "Whether to propagate to child paths",
Default: false,
},
mkDataSourceVirtualEnvironmentGroupACLRoleID: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The role id",
},
},

47
data_source_virtual_environment_group_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentGroupInstantiation tests whether the DataSourceVirtualEnvironmentGroup instance can be instantiated.
@ -21,18 +23,43 @@ func TestDataSourceVirtualEnvironmentGroupInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentGroupSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentGroup()
attributeKeys := []string{
testRequiredArguments(t, s, []string{
mkDataSourceVirtualEnvironmentGroupID,
})
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentGroupACL,
mkDataSourceVirtualEnvironmentGroupComment,
mkDataSourceVirtualEnvironmentGroupMembers,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentGroup.Schema: Missing attribute \"%s\"", v)
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentGroupACL,
mkDataSourceVirtualEnvironmentGroupID,
mkDataSourceVirtualEnvironmentGroupComment,
mkDataSourceVirtualEnvironmentGroupMembers,
}, []schema.ValueType{
schema.TypeSet,
schema.TypeString,
schema.TypeString,
schema.TypeSet,
})
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentGroup.Schema: Attribute \"%s\" is not computed", v)
}
}
aclSchema := testNestedSchemaExistence(t, s, mkDataSourceVirtualEnvironmentGroupACL)
testComputedAttributes(t, aclSchema, []string{
mkDataSourceVirtualEnvironmentGroupACLPath,
mkDataSourceVirtualEnvironmentGroupACLPropagate,
mkDataSourceVirtualEnvironmentGroupACLRoleID,
})
testSchemaValueTypes(t, aclSchema, []string{
mkDataSourceVirtualEnvironmentGroupACLPath,
mkDataSourceVirtualEnvironmentGroupACLPropagate,
mkDataSourceVirtualEnvironmentGroupACLRoleID,
}, []schema.ValueType{
schema.TypeString,
schema.TypeBool,
schema.TypeString,
})
}

21
data_source_virtual_environment_groups_test.go
View File

@ -5,6 +5,7 @@
package main
import (
"github.com/hashicorp/terraform/helper/schema"
"testing"
)
@ -21,18 +22,16 @@ func TestDataSourceVirtualEnvironmentGroupsInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentGroupsSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentGroups()
attributeKeys := []string{
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentGroupsComments,
mkDataSourceVirtualEnvironmentGroupsGroupIDs,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentGroups.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentGroups.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentGroupsComments,
mkDataSourceVirtualEnvironmentGroupsGroupIDs,
}, []schema.ValueType{
schema.TypeList,
schema.TypeList,
})
}

36
data_source_virtual_environment_nodes_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentNodesInstantiation tests whether the DataSourceVirtualEnvironmentNodes instance can be instantiated.
@ -21,7 +23,7 @@ func TestDataSourceVirtualEnvironmentNodesInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentNodesSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentNodes()
attributeKeys := []string{
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentNodesCPUCount,
mkDataSourceVirtualEnvironmentNodesCPUUtilization,
mkDataSourceVirtualEnvironmentNodesMemoryAvailable,
@ -31,15 +33,27 @@ func TestDataSourceVirtualEnvironmentNodesSchema(t *testing.T) {
mkDataSourceVirtualEnvironmentNodesSSLFingerprints,
mkDataSourceVirtualEnvironmentNodesSupportLevels,
mkDataSourceVirtualEnvironmentNodesUptime,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentNodes.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentNodes.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentNodesCPUCount,
mkDataSourceVirtualEnvironmentNodesCPUUtilization,
mkDataSourceVirtualEnvironmentNodesMemoryAvailable,
mkDataSourceVirtualEnvironmentNodesMemoryUsed,
mkDataSourceVirtualEnvironmentNodesNames,
mkDataSourceVirtualEnvironmentNodesOnline,
mkDataSourceVirtualEnvironmentNodesSSLFingerprints,
mkDataSourceVirtualEnvironmentNodesSupportLevels,
mkDataSourceVirtualEnvironmentNodesUptime,
}, []schema.ValueType{
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
})
}

55
data_source_virtual_environment_pool.go
View File

@ -11,6 +11,11 @@ import (
const (
mkDataSourceVirtualEnvironmentPoolComment = "comment"
mkDataSourceVirtualEnvironmentPoolMembers = "members"
mkDataSourceVirtualEnvironmentPoolMembersDatastoreID = "datastore_id"
mkDataSourceVirtualEnvironmentPoolMembersID = "id"
mkDataSourceVirtualEnvironmentPoolMembersNodeName = "node_name"
mkDataSourceVirtualEnvironmentPoolMembersType = "type"
mkDataSourceVirtualEnvironmentPoolMembersVMID = "vm_id"
mkDataSourceVirtualEnvironmentPoolPoolID = "pool_id"
)
@ -28,32 +33,30 @@ func dataSourceVirtualEnvironmentPool() *schema.Resource {
Computed: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
mkResourceVirtualEnvironmentPoolMembersID: {
mkDataSourceVirtualEnvironmentPoolMembersDatastoreID: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The datastore id",
},
mkDataSourceVirtualEnvironmentPoolMembersID: {
Type: schema.TypeString,
Computed: true,
Description: "The member id",
},
mkResourceVirtualEnvironmentPoolMembersNode: {
mkDataSourceVirtualEnvironmentPoolMembersNodeName: {
Type: schema.TypeString,
Required: true,
Description: "The node id",
Computed: true,
Description: "The node name",
},
mkResourceVirtualEnvironmentPoolMembersStorage: {
mkDataSourceVirtualEnvironmentPoolMembersType: {
Type: schema.TypeString,
Optional: true,
Description: "The storage id",
Default: "",
},
mkResourceVirtualEnvironmentPoolMembersType: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The member type",
},
mkResourceVirtualEnvironmentPoolMembersVirtualMachineID: {
mkDataSourceVirtualEnvironmentPoolMembersVMID: {
Type: schema.TypeInt,
Optional: true,
Computed: true,
Description: "The virtual machine id",
Default: 0,
},
},
},
@ -96,27 +99,27 @@ func dataSourceVirtualEnvironmentPoolRead(d *schema.ResourceData, m interface{})
for i, v := range pool.Members {
values := make(map[string]interface{})
values[mkResourceVirtualEnvironmentPoolMembersID] = v.ID
values[mkResourceVirtualEnvironmentPoolMembersNode] = v.Node
values[mkDataSourceVirtualEnvironmentPoolMembersID] = v.ID
values[mkDataSourceVirtualEnvironmentPoolMembersNodeName] = v.Node
if v.Storage != nil {
values[mkResourceVirtualEnvironmentPoolMembersStorage] = v.Storage
if v.DatastoreID != nil {
values[mkDataSourceVirtualEnvironmentPoolMembersDatastoreID] = v.DatastoreID
} else {
values[mkResourceVirtualEnvironmentPoolMembersStorage] = ""
values[mkDataSourceVirtualEnvironmentPoolMembersDatastoreID] = ""
}
values[mkResourceVirtualEnvironmentPoolMembersType] = v.Type
values[mkDataSourceVirtualEnvironmentPoolMembersType] = v.Type
if v.VirtualMachineID != nil {
values[mkResourceVirtualEnvironmentPoolMembersVirtualMachineID] = v.VirtualMachineID
if v.VMID != nil {
values[mkDataSourceVirtualEnvironmentPoolMembersVMID] = v.VMID
} else {
values[mkResourceVirtualEnvironmentPoolMembersVirtualMachineID] = 0
values[mkDataSourceVirtualEnvironmentPoolMembersVMID] = 0
}
members[i] = values
}
d.Set(mkResourceVirtualEnvironmentPoolMembers, members)
d.Set(mkDataSourceVirtualEnvironmentPoolMembers, members)
return nil
}

50
data_source_virtual_environment_pool_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentPoolInstantiation tests whether the DataSourceVirtualEnvironmentPool instance can be instantiated.
@ -21,18 +23,46 @@ func TestDataSourceVirtualEnvironmentPoolInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentPoolSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentPool()
attributeKeys := []string{
testRequiredArguments(t, s, []string{
mkDataSourceVirtualEnvironmentPoolPoolID,
})
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentPoolComment,
mkDataSourceVirtualEnvironmentPoolMembers,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentPool.Schema: Missing attribute \"%s\"", v)
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentPoolComment,
mkDataSourceVirtualEnvironmentPoolMembers,
mkDataSourceVirtualEnvironmentPoolPoolID,
}, []schema.ValueType{
schema.TypeString,
schema.TypeList,
schema.TypeString,
})
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentPool.Schema: Attribute \"%s\" is not computed", v)
}
}
membersSchema := testNestedSchemaExistence(t, s, mkDataSourceVirtualEnvironmentPoolMembers)
testComputedAttributes(t, membersSchema, []string{
mkDataSourceVirtualEnvironmentPoolMembersDatastoreID,
mkDataSourceVirtualEnvironmentPoolMembersID,
mkDataSourceVirtualEnvironmentPoolMembersNodeName,
mkDataSourceVirtualEnvironmentPoolMembersType,
mkDataSourceVirtualEnvironmentPoolMembersVMID,
})
testSchemaValueTypes(t, membersSchema, []string{
mkDataSourceVirtualEnvironmentPoolMembersDatastoreID,
mkDataSourceVirtualEnvironmentPoolMembersID,
mkDataSourceVirtualEnvironmentPoolMembersNodeName,
mkDataSourceVirtualEnvironmentPoolMembersType,
mkDataSourceVirtualEnvironmentPoolMembersVMID,
}, []schema.ValueType{
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeInt,
})
}

20
data_source_virtual_environment_pools_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentPoolsInstantiation tests whether the DataSourceVirtualEnvironmentPools instance can be instantiated.
@ -21,17 +23,13 @@ func TestDataSourceVirtualEnvironmentPoolsInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentPoolsSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentPools()
attributeKeys := []string{
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentPoolsPoolIDs,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentPools.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentPools.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentPoolsPoolIDs,
}, []schema.ValueType{
schema.TypeList,
})
}

26
data_source_virtual_environment_role_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentRoleInstantiation tests whether the DataSourceVirtualEnvironmentRole instance can be instantiated.
@ -21,17 +23,19 @@ func TestDataSourceVirtualEnvironmentRoleInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentRoleSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentRole()
attributeKeys := []string{
testRequiredArguments(t, s, []string{
mkDataSourceVirtualEnvironmentRoleID,
})
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentRolePrivileges,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentRole.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentRole.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentRoleID,
mkDataSourceVirtualEnvironmentRolePrivileges,
}, []schema.ValueType{
schema.TypeString,
schema.TypeSet,
})
}

23
data_source_virtual_environment_roles_test.go
View File

@ -5,6 +5,7 @@
package main
import (
"github.com/hashicorp/terraform/helper/schema"
"testing"
)
@ -21,19 +22,19 @@ func TestDataSourceVirtualEnvironmentRolesInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentRolesSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentRoles()
attributeKeys := []string{
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentRolesPrivileges,
mkDataSourceVirtualEnvironmentRolesRoleIDs,
mkDataSourceVirtualEnvironmentRolesSpecial,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentRoles.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentRoles.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentRolesPrivileges,
mkDataSourceVirtualEnvironmentRolesRoleIDs,
mkDataSourceVirtualEnvironmentRolesSpecial,
}, []schema.ValueType{
schema.TypeList,
schema.TypeList,
schema.TypeList,
})
}

12
data_source_virtual_environment_user.go
View File

@ -32,26 +32,22 @@ func dataSourceVirtualEnvironmentUser() *schema.Resource {
mkDataSourceVirtualEnvironmentUserACL: &schema.Schema{
Type: schema.TypeSet,
Description: "The access control list",
Optional: true,
DefaultFunc: func() (interface{}, error) {
return make([]interface{}, 0), nil
},
Computed: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
mkDataSourceVirtualEnvironmentUserACLPath: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The path",
},
mkDataSourceVirtualEnvironmentUserACLPropagate: {
Type: schema.TypeBool,
Optional: true,
Computed: true,
Description: "Whether to propagate to child paths",
Default: false,
},
mkDataSourceVirtualEnvironmentUserACLRoleID: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The role id",
},
},

57
data_source_virtual_environment_user_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentUserInstantiation tests whether the DataSourceVirtualEnvironmentUser instance can be instantiated.
@ -21,7 +23,12 @@ func TestDataSourceVirtualEnvironmentUserInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentUserSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentUser()
attributeKeys := []string{
testRequiredArguments(t, s, []string{
mkDataSourceVirtualEnvironmentUserUserID,
})
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentUserACL,
mkDataSourceVirtualEnvironmentUserComment,
mkDataSourceVirtualEnvironmentUserEmail,
mkDataSourceVirtualEnvironmentUserEnabled,
@ -30,15 +37,45 @@ func TestDataSourceVirtualEnvironmentUserSchema(t *testing.T) {
mkDataSourceVirtualEnvironmentUserGroups,
mkDataSourceVirtualEnvironmentUserKeys,
mkDataSourceVirtualEnvironmentUserLastName,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentUser.Schema: Missing attribute \"%s\"", v)
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentUserACL,
mkDataSourceVirtualEnvironmentUserComment,
mkDataSourceVirtualEnvironmentUserEmail,
mkDataSourceVirtualEnvironmentUserEnabled,
mkDataSourceVirtualEnvironmentUserExpirationDate,
mkDataSourceVirtualEnvironmentUserFirstName,
mkDataSourceVirtualEnvironmentUserGroups,
mkDataSourceVirtualEnvironmentUserKeys,
mkDataSourceVirtualEnvironmentUserLastName,
}, []schema.ValueType{
schema.TypeSet,
schema.TypeString,
schema.TypeString,
schema.TypeBool,
schema.TypeString,
schema.TypeString,
schema.TypeList,
schema.TypeString,
schema.TypeString,
})
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentUser.Schema: Attribute \"%s\" is not computed", v)
}
}
aclSchema := testNestedSchemaExistence(t, s, mkDataSourceVirtualEnvironmentGroupACL)
testComputedAttributes(t, aclSchema, []string{
mkDataSourceVirtualEnvironmentUserACLPath,
mkDataSourceVirtualEnvironmentUserACLPropagate,
mkDataSourceVirtualEnvironmentUserACLRoleID,
})
testSchemaValueTypes(t, aclSchema, []string{
mkDataSourceVirtualEnvironmentUserACLPath,
mkDataSourceVirtualEnvironmentUserACLPropagate,
mkDataSourceVirtualEnvironmentUserACLRoleID,
}, []schema.ValueType{
schema.TypeString,
schema.TypeBool,
schema.TypeString,
})
}

36
data_source_virtual_environment_users_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentUsersInstantiation tests whether the DataSourceVirtualEnvironmentUsers instance can be instantiated.
@ -21,7 +23,7 @@ func TestDataSourceVirtualEnvironmentUsersInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentUsersSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentUsers()
attributeKeys := []string{
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentUsersComments,
mkDataSourceVirtualEnvironmentUsersEmails,
mkDataSourceVirtualEnvironmentUsersEnabled,
@ -31,15 +33,27 @@ func TestDataSourceVirtualEnvironmentUsersSchema(t *testing.T) {
mkDataSourceVirtualEnvironmentUsersKeys,
mkDataSourceVirtualEnvironmentUsersLastNames,
mkDataSourceVirtualEnvironmentUsersUserIDs,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentUsers.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentUsers.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentUsersComments,
mkDataSourceVirtualEnvironmentUsersEmails,
mkDataSourceVirtualEnvironmentUsersEnabled,
mkDataSourceVirtualEnvironmentUsersExpirationDates,
mkDataSourceVirtualEnvironmentUsersFirstNames,
mkDataSourceVirtualEnvironmentUsersGroups,
mkDataSourceVirtualEnvironmentUsersKeys,
mkDataSourceVirtualEnvironmentUsersLastNames,
mkDataSourceVirtualEnvironmentUsersUserIDs,
}, []schema.ValueType{
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
schema.TypeList,
})
}

6
data_source_virtual_environment_version.go
View File

@ -9,7 +9,7 @@ import (
)
const (
mkDataSourceVirtualEnvironmentVersionKeyboard = "keyboard"
mkDataSourceVirtualEnvironmentVersionKeyboardLayout = "keyboard_layout"
mkDataSourceVirtualEnvironmentVersionRelease = "release"
mkDataSourceVirtualEnvironmentVersionRepositoryID = "repository_id"
mkDataSourceVirtualEnvironmentVersionVersion = "version"
@ -18,7 +18,7 @@ const (
func dataSourceVirtualEnvironmentVersion() *schema.Resource {
return &schema.Resource{
Schema: map[string]*schema.Schema{
mkDataSourceVirtualEnvironmentVersionKeyboard: &schema.Schema{
mkDataSourceVirtualEnvironmentVersionKeyboardLayout: &schema.Schema{
Type: schema.TypeString,
Description: "The keyboard layout",
Computed: true,
@ -63,7 +63,7 @@ func dataSourceVirtualEnvironmentVersionRead(d *schema.ResourceData, m interface
d.SetId("version")
d.Set(mkDataSourceVirtualEnvironmentVersionKeyboard, version.Keyboard)
d.Set(mkDataSourceVirtualEnvironmentVersionKeyboardLayout, version.Keyboard)
d.Set(mkDataSourceVirtualEnvironmentVersionRelease, version.Release)
d.Set(mkDataSourceVirtualEnvironmentVersionRepositoryID, version.RepositoryID)
d.Set(mkDataSourceVirtualEnvironmentVersionVersion, version.Version)

28
data_source_virtual_environment_version_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestDataSourceVirtualEnvironmentVersionInstantiation tests whether the DataSourceVirtualEnvironmentVersion instance can be instantiated.
@ -21,20 +23,22 @@ func TestDataSourceVirtualEnvironmentVersionInstantiation(t *testing.T) {
func TestDataSourceVirtualEnvironmentVersionSchema(t *testing.T) {
s := dataSourceVirtualEnvironmentVersion()
attributeKeys := []string{
mkDataSourceVirtualEnvironmentVersionKeyboard,
testComputedAttributes(t, s, []string{
mkDataSourceVirtualEnvironmentVersionKeyboardLayout,
mkDataSourceVirtualEnvironmentVersionRelease,
mkDataSourceVirtualEnvironmentVersionRepositoryID,
mkDataSourceVirtualEnvironmentVersionVersion,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in dataSourceVirtualEnvironmentVersion.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in dataSourceVirtualEnvironmentVersion.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkDataSourceVirtualEnvironmentVersionKeyboardLayout,
mkDataSourceVirtualEnvironmentVersionRelease,
mkDataSourceVirtualEnvironmentVersionRepositoryID,
mkDataSourceVirtualEnvironmentVersionVersion,
}, []schema.ValueType{
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeString,
})
}

2
example/data_source_virtual_environment_version.tf
View File

@ -2,7 +2,7 @@ data "proxmox_virtual_environment_version" "example" {}
output "data_proxmox_virtual_environment_version" {
value = "${map(
"keyboard", data.proxmox_virtual_environment_version.example.keyboard,
"keyboard_layout", data.proxmox_virtual_environment_version.example.keyboard_layout,
"release", data.proxmox_virtual_environment_version.example.release,
"repository_id", data.proxmox_virtual_environment_version.example.repository_id,
"version", data.proxmox_virtual_environment_version.example.version,

2
proxmox/virtual_environment_authentication.go
View File

@ -24,7 +24,7 @@ type VirtualEnvironmentAuthenticationResponseCapabilities struct {
Datacenter *CustomPrivileges `json:"dc,omitempty"`
Nodes *CustomPrivileges `json:"nodes,omitempty"`
Storage *CustomPrivileges `json:"storage,omitempty"`
VirtualMachines *CustomPrivileges `json:"vms,omitempty"`
VMs *CustomPrivileges `json:"vms,omitempty"`
}
// VirtualEnvironmentAuthenticationResponseData contains the data from an authentication response.

2
proxmox/virtual_environment_datastores.go
View File

@ -27,7 +27,7 @@ type VirtualEnvironmentDatastoreFileListResponseData struct {
FileSize int `json:"size"`
ParentVolumeID *string `json:"parent,omitempty"`
SpaceUsed *int `json:"used,omitempty"`
VirtualMachineID *int `json:"vmid,omitempty"`
VMID *int `json:"vmid,omitempty"`
VolumeID string `json:"volid"`
}

4
proxmox/virtual_environment_pools.go
View File

@ -32,9 +32,9 @@ type VirtualEnvironmentPoolGetResponseData struct {
type VirtualEnvironmentPoolGetResponseMembers struct {
ID string `json:"id"`
Node string `json:"node"`
Storage *string `json:"storage,omitempty"`
DatastoreID *string `json:"storage,omitempty"`
Type string `json:"type"`
VirtualMachineID *int `json:"vmid"`
VMID *int `json:"vmid"`
}
// VirtualEnvironmentPoolListResponseBody contains the body from an pool list response.

41
resource_virtual_environment_file_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestResourceVirtualEnvironmentFileInstantiation tests whether the ResourceVirtualEnvironmentFile instance can be instantiated.
@ -21,17 +23,34 @@ func TestResourceVirtualEnvironmentFileInstantiation(t *testing.T) {
func TestResourceVirtualEnvironmentFileSchema(t *testing.T) {
s := resourceVirtualEnvironmentFile()
attributeKeys := []string{
testRequiredArguments(t, s, []string{
mkResourceVirtualEnvironmentFileDatastoreID,
mkResourceVirtualEnvironmentFileNodeName,
mkResourceVirtualEnvironmentFileSource,
mkResourceVirtualEnvironmentFileTemplate,
})
testOptionalArguments(t, s, []string{
mkResourceVirtualEnvironmentFileOverrideFileName,
})
testComputedAttributes(t, s, []string{
mkResourceVirtualEnvironmentFileFileName,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in resourceVirtualEnvironmentFile.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in resourceVirtualEnvironmentFile.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkResourceVirtualEnvironmentFileDatastoreID,
mkResourceVirtualEnvironmentFileFileName,
mkResourceVirtualEnvironmentFileOverrideFileName,
mkResourceVirtualEnvironmentFileNodeName,
mkResourceVirtualEnvironmentFileSource,
mkResourceVirtualEnvironmentFileTemplate,
}, []schema.ValueType{
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeBool,
})
}

54
resource_virtual_environment_group_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestResourceVirtualEnvironmentGroupInstantiation tests whether the ResourceVirtualEnvironmentGroup instance can be instantiated.
@ -21,17 +23,49 @@ func TestResourceVirtualEnvironmentGroupInstantiation(t *testing.T) {
func TestResourceVirtualEnvironmentGroupSchema(t *testing.T) {
s := resourceVirtualEnvironmentGroup()
attributeKeys := []string{
testRequiredArguments(t, s, []string{
mkResourceVirtualEnvironmentGroupID,
})
testOptionalArguments(t, s, []string{
mkResourceVirtualEnvironmentGroupACL,
mkResourceVirtualEnvironmentGroupComment,
})
testComputedAttributes(t, s, []string{
mkResourceVirtualEnvironmentGroupMembers,
}
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in resourceVirtualEnvironmentGroup.Schema: Missing attribute \"%s\"", v)
}
testSchemaValueTypes(t, s, []string{
mkResourceVirtualEnvironmentGroupACL,
mkResourceVirtualEnvironmentGroupComment,
mkResourceVirtualEnvironmentGroupID,
mkResourceVirtualEnvironmentGroupMembers,
}, []schema.ValueType{
schema.TypeSet,
schema.TypeString,
schema.TypeString,
schema.TypeSet,
})
if s.Schema[v].Computed != true {
t.Fatalf("Error in resourceVirtualEnvironmentGroup.Schema: Attribute \"%s\" is not computed", v)
}
}
aclSchema := testNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentGroupACL)
testRequiredArguments(t, aclSchema, []string{
mkResourceVirtualEnvironmentGroupACLPath,
mkResourceVirtualEnvironmentGroupACLRoleID,
})
testOptionalArguments(t, aclSchema, []string{
mkResourceVirtualEnvironmentGroupACLPropagate,
})
testSchemaValueTypes(t, aclSchema, []string{
mkResourceVirtualEnvironmentGroupACLPath,
mkResourceVirtualEnvironmentGroupACLPropagate,
mkResourceVirtualEnvironmentGroupACLRoleID,
}, []schema.ValueType{
schema.TypeString,
schema.TypeBool,
schema.TypeString,
})
}

46
resource_virtual_environment_pool.go
View File

@ -14,11 +14,11 @@ import (
const (
mkResourceVirtualEnvironmentPoolComment = "comment"
mkResourceVirtualEnvironmentPoolMembers = "members"
mkResourceVirtualEnvironmentPoolMembersDatastoreID = "datastore_id"
mkResourceVirtualEnvironmentPoolMembersID = "id"
mkResourceVirtualEnvironmentPoolMembersNode = "node"
mkResourceVirtualEnvironmentPoolMembersStorage = "storage"
mkResourceVirtualEnvironmentPoolMembersNodeName = "node_name"
mkResourceVirtualEnvironmentPoolMembersType = "type"
mkResourceVirtualEnvironmentPoolMembersVirtualMachineID = "virtual_machine_id"
mkResourceVirtualEnvironmentPoolMembersVMID = "vm_id"
mkResourceVirtualEnvironmentPoolPoolID = "pool_id"
)
@ -37,32 +37,30 @@ func resourceVirtualEnvironmentPool() *schema.Resource {
Computed: true,
Elem: &schema.Resource{
Schema: map[string]*schema.Schema{
mkResourceVirtualEnvironmentPoolMembersDatastoreID: {
Type: schema.TypeString,
Computed: true,
Description: "The datastore id",
},
mkResourceVirtualEnvironmentPoolMembersID: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The member id",
},
mkResourceVirtualEnvironmentPoolMembersNode: {
mkResourceVirtualEnvironmentPoolMembersNodeName: {
Type: schema.TypeString,
Required: true,
Description: "The node id",
},
mkResourceVirtualEnvironmentPoolMembersStorage: {
Type: schema.TypeString,
Optional: true,
Description: "The storage id",
Default: "",
Computed: true,
Description: "The node name",
},
mkResourceVirtualEnvironmentPoolMembersType: {
Type: schema.TypeString,
Required: true,
Computed: true,
Description: "The member type",
},
mkResourceVirtualEnvironmentPoolMembersVirtualMachineID: {
mkResourceVirtualEnvironmentPoolMembersVMID: {
Type: schema.TypeInt,
Optional: true,
Computed: true,
Description: "The virtual machine id",
Default: 0,
},
},
},
@ -143,20 +141,20 @@ func resourceVirtualEnvironmentPoolRead(d *schema.ResourceData, m interface{}) e
values := make(map[string]interface{})
values[mkResourceVirtualEnvironmentPoolMembersID] = v.ID
values[mkResourceVirtualEnvironmentPoolMembersNode] = v.Node
values[mkResourceVirtualEnvironmentPoolMembersNodeName] = v.Node
if v.Storage != nil {
values[mkResourceVirtualEnvironmentPoolMembersStorage] = v.Storage
if v.DatastoreID != nil {
values[mkResourceVirtualEnvironmentPoolMembersDatastoreID] = v.DatastoreID
} else {
values[mkResourceVirtualEnvironmentPoolMembersStorage] = ""
values[mkResourceVirtualEnvironmentPoolMembersDatastoreID] = ""
}
values[mkResourceVirtualEnvironmentPoolMembersType] = v.Type
if v.VirtualMachineID != nil {
values[mkResourceVirtualEnvironmentPoolMembersVirtualMachineID] = v.VirtualMachineID
if v.VMID != nil {
values[mkResourceVirtualEnvironmentPoolMembersVMID] = v.VMID
} else {
values[mkResourceVirtualEnvironmentPoolMembersVirtualMachineID] = 0
values[mkResourceVirtualEnvironmentPoolMembersVMID] = 0
}
members[i] = values

44
resource_virtual_environment_pool_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestResourceVirtualEnvironmentPoolInstantiation tests whether the ResourceVirtualEnvironmentPool instance can be instantiated.
@ -21,15 +23,39 @@ func TestResourceVirtualEnvironmentPoolInstantiation(t *testing.T) {
func TestResourceVirtualEnvironmentPoolSchema(t *testing.T) {
s := resourceVirtualEnvironmentPool()
attributeKeys := []string{}
testRequiredArguments(t, s, []string{
mkResourceVirtualEnvironmentPoolPoolID,
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in resourceVirtualEnvironmentPool.Schema: Missing attribute \"%s\"", v)
}
testOptionalArguments(t, s, []string{
mkResourceVirtualEnvironmentPoolComment,
})
if s.Schema[v].Computed != true {
t.Fatalf("Error in resourceVirtualEnvironmentPool.Schema: Attribute \"%s\" is not computed", v)
}
}
testComputedAttributes(t, s, []string{
mkResourceVirtualEnvironmentPoolMembers,
})
membersSchema := testNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentPoolMembers)
testComputedAttributes(t, membersSchema, []string{
mkResourceVirtualEnvironmentPoolMembersDatastoreID,
mkResourceVirtualEnvironmentPoolMembersID,
mkResourceVirtualEnvironmentPoolMembersNodeName,
mkResourceVirtualEnvironmentPoolMembersType,
mkResourceVirtualEnvironmentPoolMembersVMID,
})
testSchemaValueTypes(t, membersSchema, []string{
mkResourceVirtualEnvironmentPoolMembersDatastoreID,
mkResourceVirtualEnvironmentPoolMembersID,
mkResourceVirtualEnvironmentPoolMembersNodeName,
mkResourceVirtualEnvironmentPoolMembersType,
mkResourceVirtualEnvironmentPoolMembersVMID,
}, []schema.ValueType{
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeInt,
})
}

23
resource_virtual_environment_role_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestResourceVirtualEnvironmentRoleInstantiation tests whether the ResourceVirtualEnvironmentRole instance can be instantiated.
@ -21,15 +23,16 @@ func TestResourceVirtualEnvironmentRoleInstantiation(t *testing.T) {
func TestResourceVirtualEnvironmentRoleSchema(t *testing.T) {
s := resourceVirtualEnvironmentRole()
attributeKeys := []string{}
testRequiredArguments(t, s, []string{
mkResourceVirtualEnvironmentRolePrivileges,
mkResourceVirtualEnvironmentRoleRoleID,
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in resourceVirtualEnvironmentRole.Schema: Missing attribute \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in resourceVirtualEnvironmentRole.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkResourceVirtualEnvironmentRolePrivileges,
mkResourceVirtualEnvironmentRoleRoleID,
}, []schema.ValueType{
schema.TypeSet,
schema.TypeString,
})
}

72
resource_virtual_environment_user_test.go
View File

@ -6,6 +6,8 @@ package main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
// TestResourceVirtualEnvironmentUserInstantiation tests whether the ResourceVirtualEnvironmentUser instance can be instantiated.
@ -21,15 +23,67 @@ func TestResourceVirtualEnvironmentUserInstantiation(t *testing.T) {
func TestResourceVirtualEnvironmentUserSchema(t *testing.T) {
s := resourceVirtualEnvironmentUser()
attributeKeys := []string{}
testRequiredArguments(t, s, []string{
mkResourceVirtualEnvironmentUserPassword,
mkResourceVirtualEnvironmentUserUserID,
})
for _, v := range attributeKeys {
if s.Schema[v] == nil {
t.Fatalf("Error in resourceVirtualEnvironmentUser.Schema: Missing attribute \"%s\"", v)
}
testOptionalArguments(t, s, []string{
mkResourceVirtualEnvironmentUserACL,
mkResourceVirtualEnvironmentUserComment,
mkResourceVirtualEnvironmentUserEmail,
mkResourceVirtualEnvironmentUserEnabled,
mkResourceVirtualEnvironmentUserExpirationDate,
mkResourceVirtualEnvironmentUserFirstName,
mkResourceVirtualEnvironmentUserGroups,
mkResourceVirtualEnvironmentUserKeys,
mkResourceVirtualEnvironmentUserLastName,
})
if s.Schema[v].Computed != true {
t.Fatalf("Error in resourceVirtualEnvironmentUser.Schema: Attribute \"%s\" is not computed", v)
}
}
testSchemaValueTypes(t, s, []string{
mkResourceVirtualEnvironmentUserACL,
mkResourceVirtualEnvironmentUserComment,
mkResourceVirtualEnvironmentUserEmail,
mkResourceVirtualEnvironmentUserEnabled,
mkResourceVirtualEnvironmentUserExpirationDate,
mkResourceVirtualEnvironmentUserFirstName,
mkResourceVirtualEnvironmentUserGroups,
mkResourceVirtualEnvironmentUserKeys,
mkResourceVirtualEnvironmentUserLastName,
mkResourceVirtualEnvironmentUserPassword,
mkResourceVirtualEnvironmentUserUserID,
}, []schema.ValueType{
schema.TypeSet,
schema.TypeString,
schema.TypeString,
schema.TypeBool,
schema.TypeString,
schema.TypeString,
schema.TypeSet,
schema.TypeString,
schema.TypeString,
schema.TypeString,
schema.TypeString,
})
aclSchema := testNestedSchemaExistence(t, s, mkResourceVirtualEnvironmentUserACL)
testRequiredArguments(t, aclSchema, []string{
mkResourceVirtualEnvironmentUserACLPath,
mkResourceVirtualEnvironmentUserACLRoleID,
})
testOptionalArguments(t, aclSchema, []string{
mkResourceVirtualEnvironmentUserACLPropagate,
})
testSchemaValueTypes(t, aclSchema, []string{
mkResourceVirtualEnvironmentUserACLPath,
mkResourceVirtualEnvironmentUserACLPropagate,
mkResourceVirtualEnvironmentUserACLRoleID,
}, []schema.ValueType{
schema.TypeString,
schema.TypeBool,
schema.TypeString,
})
}

71
utils.go Normal file
View File

@ -0,0 +1,71 @@
/* 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 main
import (
"testing"
"github.com/hashicorp/terraform/helper/schema"
)
func testComputedAttributes(t *testing.T, s *schema.Resource, keys []string) {
for _, v := range keys {
if s.Schema[v] == nil {
t.Fatalf("Error in Schema: Missing definition for \"%s\"", v)
}
if s.Schema[v].Computed != true {
t.Fatalf("Error in Schema: Attribute \"%s\" is not computed", v)
}
}
}
func testNestedSchemaExistence(t *testing.T, s *schema.Resource, key string) *schema.Resource {
schema, ok := s.Schema[key].Elem.(*schema.Resource)
if !ok {
t.Fatalf("Error in Schema: Missing nested schema for \"%s\"", key)
return nil
}
return schema
}
func testOptionalArguments(t *testing.T, s *schema.Resource, keys []string) {
for _, v := range keys {
if s.Schema[v] == nil {
t.Fatalf("Error in Schema: Missing definition for \"%s\"", v)
}
if s.Schema[v].Optional != true {
t.Fatalf("Error in Schema: Argument \"%s\" is not optional", v)
}
}
}
func testRequiredArguments(t *testing.T, s *schema.Resource, keys []string) {
for _, v := range keys {
if s.Schema[v] == nil {
t.Fatalf("Error in Schema: Missing definition for \"%s\"", v)
}
if s.Schema[v].Required != true {
t.Fatalf("Error in Schema: Argument \"%s\" is not required", v)
}
}
}
func testSchemaValueTypes(t *testing.T, s *schema.Resource, keys []string, types []schema.ValueType) {
for i, v := range keys {
if s.Schema[v] == nil {
t.Fatalf("Error in Schema: Missing definition for \"%s\"", v)
}
if s.Schema[v].Type != types[i] {
t.Fatalf("Error in Schema: Argument \"%s\" is not of type \"%v\"", v, types[i])
}
}
}