612 lines
14 KiB
Go
612 lines
14 KiB
Go
package utils
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
|
|
"github.com/hashicorp/terraform-plugin-framework/diag"
|
|
"github.com/hashicorp/terraform-plugin-go/tftypes"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/hashicorp/terraform-plugin-framework/attr"
|
|
"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
|
|
"github.com/hashicorp/terraform-plugin-framework/path"
|
|
"github.com/hashicorp/terraform-plugin-framework/resource"
|
|
"github.com/hashicorp/terraform-plugin-framework/tfsdk"
|
|
"github.com/hashicorp/terraform-plugin-framework/types"
|
|
"github.com/hashicorp/terraform-plugin-framework/types/basetypes"
|
|
"github.com/stackitcloud/stackit-sdk-go/core/utils"
|
|
)
|
|
|
|
func TestReconcileStrLists(t *testing.T) {
|
|
tests := []struct {
|
|
description string
|
|
list1 []string
|
|
list2 []string
|
|
expected []string
|
|
}{
|
|
{
|
|
"empty lists",
|
|
[]string{},
|
|
[]string{},
|
|
[]string{},
|
|
},
|
|
{
|
|
"list1 empty",
|
|
[]string{},
|
|
[]string{"a", "b", "c"},
|
|
[]string{"a", "b", "c"},
|
|
},
|
|
{
|
|
"list2 empty",
|
|
[]string{"a", "b", "c"},
|
|
[]string{},
|
|
[]string{},
|
|
},
|
|
{
|
|
"no common elements",
|
|
[]string{"a", "b", "c"},
|
|
[]string{"d", "e", "f"},
|
|
[]string{"d", "e", "f"},
|
|
},
|
|
{
|
|
"common elements",
|
|
[]string{"d", "a", "c"},
|
|
[]string{"b", "c", "d", "e"},
|
|
[]string{"d", "c", "b", "e"},
|
|
},
|
|
{
|
|
"common elements with empty string",
|
|
[]string{"d", "", "c"},
|
|
[]string{"", "c", "d"},
|
|
[]string{"d", "", "c"},
|
|
},
|
|
{
|
|
"common elements with duplicates",
|
|
[]string{"a", "b", "c", "c"},
|
|
[]string{"b", "c", "d", "e"},
|
|
[]string{"b", "c", "c", "d", "e"},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.description, func(t *testing.T) {
|
|
output := ReconcileStringSlices(tt.list1, tt.list2)
|
|
diff := cmp.Diff(output, tt.expected)
|
|
if diff != "" {
|
|
t.Fatalf("Data does not match: %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestListValuetoStrSlice(t *testing.T) {
|
|
tests := []struct {
|
|
description string
|
|
input basetypes.ListValue
|
|
expected []string
|
|
isValid bool
|
|
}{
|
|
{
|
|
description: "empty list",
|
|
input: types.ListValueMust(types.StringType, []attr.Value{}),
|
|
expected: []string{},
|
|
isValid: true,
|
|
},
|
|
{
|
|
description: "values ok",
|
|
input: types.ListValueMust(types.StringType, []attr.Value{
|
|
types.StringValue("a"),
|
|
types.StringValue("b"),
|
|
types.StringValue("c"),
|
|
}),
|
|
expected: []string{"a", "b", "c"},
|
|
isValid: true,
|
|
},
|
|
{
|
|
description: "different type",
|
|
input: types.ListValueMust(types.Int64Type, []attr.Value{
|
|
types.Int64Value(12),
|
|
}),
|
|
isValid: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.description, func(t *testing.T) {
|
|
output, err := ListValuetoStringSlice(tt.input)
|
|
if err != nil {
|
|
if !tt.isValid {
|
|
return
|
|
}
|
|
t.Fatalf("Should not have failed: %v", err)
|
|
}
|
|
if !tt.isValid {
|
|
t.Fatalf("Should have failed")
|
|
}
|
|
diff := cmp.Diff(output, tt.expected)
|
|
if diff != "" {
|
|
t.Fatalf("Data does not match: %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConvertPointerSliceToStringSlice(t *testing.T) {
|
|
tests := []struct {
|
|
description string
|
|
input []*string
|
|
expected []string
|
|
}{
|
|
{
|
|
description: "nil slice",
|
|
input: nil,
|
|
expected: []string{},
|
|
},
|
|
{
|
|
description: "empty slice",
|
|
input: []*string{},
|
|
expected: []string{},
|
|
},
|
|
{
|
|
description: "slice with valid pointers",
|
|
input: []*string{utils.Ptr("apple"), utils.Ptr("banana"), utils.Ptr("cherry")},
|
|
expected: []string{"apple", "banana", "cherry"},
|
|
},
|
|
{
|
|
description: "slice with some nil pointers",
|
|
input: []*string{utils.Ptr("apple"), nil, utils.Ptr("cherry"), nil},
|
|
expected: []string{"apple", "cherry"},
|
|
},
|
|
{
|
|
description: "slice with all nil pointers",
|
|
input: []*string{nil, nil, nil},
|
|
expected: []string{},
|
|
},
|
|
{
|
|
description: "slice with a pointer to an empty string",
|
|
input: []*string{utils.Ptr("apple"), utils.Ptr(""), utils.Ptr("cherry")},
|
|
expected: []string{"apple", "", "cherry"},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.description, func(t *testing.T) {
|
|
output := ConvertPointerSliceToStringSlice(tt.input)
|
|
diff := cmp.Diff(output, tt.expected)
|
|
if diff != "" {
|
|
t.Fatalf("Data does not match: %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSimplifyBackupSchedule(t *testing.T) {
|
|
tests := []struct {
|
|
description string
|
|
input string
|
|
expected string
|
|
}{
|
|
{
|
|
"simple schedule",
|
|
"0 0 * * *",
|
|
"0 0 * * *",
|
|
},
|
|
{
|
|
"schedule with leading zeros",
|
|
"00 00 * * *",
|
|
"0 0 * * *",
|
|
},
|
|
{
|
|
"schedule with leading zeros 2",
|
|
"00 001 * * *",
|
|
"0 1 * * *",
|
|
},
|
|
{
|
|
"schedule with leading zeros 3",
|
|
"00 0010 * * *",
|
|
"0 10 * * *",
|
|
},
|
|
{
|
|
"simple schedule with slash",
|
|
"0 0/6 * * *",
|
|
"0 0/6 * * *",
|
|
},
|
|
{
|
|
"schedule with leading zeros and slash",
|
|
"00 00/6 * * *",
|
|
"0 0/6 * * *",
|
|
},
|
|
{
|
|
"schedule with leading zeros and slash 2",
|
|
"00 001/06 * * *",
|
|
"0 1/6 * * *",
|
|
},
|
|
{
|
|
"simple schedule with comma",
|
|
"0 10,15 * * *",
|
|
"0 10,15 * * *",
|
|
},
|
|
{
|
|
"schedule with leading zeros and comma",
|
|
"0 010,0015 * * *",
|
|
"0 10,15 * * *",
|
|
},
|
|
{
|
|
"simple schedule with comma and slash",
|
|
"0 0-11/10 * * *",
|
|
"0 0-11/10 * * *",
|
|
},
|
|
{
|
|
"schedule with leading zeros, comma, and slash",
|
|
"00 000-011/010 * * *",
|
|
"0 0-11/10 * * *",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.description, func(t *testing.T) {
|
|
output := SimplifyBackupSchedule(tt.input)
|
|
if output != tt.expected {
|
|
t.Fatalf("Data does not match: %s", output)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsLegacyProjectRole(t *testing.T) {
|
|
tests := []struct {
|
|
description string
|
|
role string
|
|
expected bool
|
|
}{
|
|
{
|
|
"non legacy role",
|
|
"owner",
|
|
false,
|
|
},
|
|
{
|
|
"leagcy role",
|
|
"project.owner",
|
|
true,
|
|
},
|
|
{
|
|
"leagcy role 2",
|
|
"project.admin",
|
|
true,
|
|
},
|
|
{
|
|
"leagcy role 3",
|
|
"project.member",
|
|
true,
|
|
},
|
|
{
|
|
"leagcy role 4",
|
|
"project.auditor",
|
|
true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.description, func(t *testing.T) {
|
|
output := IsLegacyProjectRole(tt.role)
|
|
if output != tt.expected {
|
|
t.Fatalf("Data does not match: %v", output)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFormatPossibleValues(t *testing.T) {
|
|
gotPrefix := "Possible values are:"
|
|
|
|
type args struct {
|
|
values []string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want string
|
|
}{
|
|
{
|
|
name: "single string value",
|
|
args: args{
|
|
values: []string{"foo"},
|
|
},
|
|
want: fmt.Sprintf("%s `foo`.", gotPrefix),
|
|
},
|
|
{
|
|
name: "multiple string value",
|
|
args: args{
|
|
values: []string{"foo", "bar", "trololol"},
|
|
},
|
|
want: fmt.Sprintf("%s `foo`, `bar`, `trololol`.", gotPrefix),
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := FormatPossibleValues(tt.args.values...); got != tt.want {
|
|
t.Errorf("FormatPossibleValues() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsUndefined(t *testing.T) {
|
|
type args struct {
|
|
val value
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want bool
|
|
}{
|
|
{
|
|
name: "undefined value",
|
|
args: args{
|
|
val: types.StringNull(),
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
name: "unknown value",
|
|
args: args{
|
|
val: types.StringUnknown(),
|
|
},
|
|
want: true,
|
|
},
|
|
{
|
|
name: "string value",
|
|
args: args{
|
|
val: types.StringValue(""),
|
|
},
|
|
want: false,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := IsUndefined(tt.args.val); got != tt.want {
|
|
t.Errorf("IsUndefined() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBuildInternalTerraformId(t *testing.T) {
|
|
type args struct {
|
|
idParts []string
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want types.String
|
|
}{
|
|
{
|
|
name: "no id parts",
|
|
args: args{
|
|
idParts: []string{},
|
|
},
|
|
want: types.StringValue(""),
|
|
},
|
|
{
|
|
name: "multiple id parts",
|
|
args: args{
|
|
idParts: []string{"abc", "foo", "bar", "xyz"},
|
|
},
|
|
want: types.StringValue("abc,foo,bar,xyz"),
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := BuildInternalTerraformId(tt.args.idParts...); !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf("BuildInternalTerraformId() = %v, want %v", got, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckListRemoval(t *testing.T) {
|
|
type model struct {
|
|
AllowedAddresses types.List `tfsdk:"allowed_addresses"`
|
|
}
|
|
tests := []struct {
|
|
description string
|
|
configModelList types.List
|
|
planModelList types.List
|
|
path path.Path
|
|
listType attr.Type
|
|
createEmptyList bool
|
|
expectedAdjustedResp bool
|
|
}{
|
|
{
|
|
"config and plan are the same - no change",
|
|
types.ListValueMust(types.StringType, []attr.Value{
|
|
types.StringValue("value1"),
|
|
}),
|
|
types.ListValueMust(types.StringType, []attr.Value{
|
|
types.StringValue("value1"),
|
|
}),
|
|
path.Root("allowed_addresses"),
|
|
types.StringType,
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"list was removed from config",
|
|
types.ListNull(types.StringType),
|
|
types.ListValueMust(types.StringType, []attr.Value{
|
|
types.StringValue("value1"),
|
|
}),
|
|
path.Root("allowed_addresses"),
|
|
types.StringType,
|
|
false,
|
|
true,
|
|
},
|
|
{
|
|
"list was added to config",
|
|
types.ListValueMust(types.StringType, []attr.Value{
|
|
types.StringValue("value1"),
|
|
}),
|
|
types.ListNull(types.StringType),
|
|
path.Root("allowed_addresses"),
|
|
types.StringType,
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"no list provided at all",
|
|
types.ListNull(types.StringType),
|
|
types.ListNull(types.StringType),
|
|
path.Root("allowed_addresses"),
|
|
types.StringType,
|
|
false,
|
|
false,
|
|
},
|
|
{
|
|
"create empty list test - list was removed from config",
|
|
types.ListNull(types.StringType),
|
|
types.ListValueMust(types.StringType, []attr.Value{
|
|
types.StringValue("value1"),
|
|
}),
|
|
path.Root("allowed_addresses"),
|
|
types.StringType,
|
|
true,
|
|
true,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.description, func(t *testing.T) {
|
|
// create resp
|
|
plan := tfsdk.Plan{
|
|
Schema: schema.Schema{
|
|
Attributes: map[string]schema.Attribute{
|
|
"allowed_addresses": schema.ListAttribute{
|
|
ElementType: basetypes.StringType{},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
// set input planModelList to plan
|
|
if diags := plan.Set(context.Background(), model{tt.planModelList}); diags.HasError() {
|
|
t.Fatalf("cannot create test model: %v", diags)
|
|
}
|
|
resp := resource.ModifyPlanResponse{
|
|
Plan: plan,
|
|
}
|
|
|
|
CheckListRemoval(context.Background(), tt.configModelList, tt.planModelList, tt.path, tt.listType, tt.createEmptyList, &resp)
|
|
// check targetList
|
|
var respList types.List
|
|
resp.Plan.GetAttribute(context.Background(), tt.path, &respList)
|
|
|
|
if tt.createEmptyList {
|
|
emptyList, _ := types.ListValueFrom(context.Background(), tt.listType, []string{})
|
|
diffEmptyList := cmp.Diff(emptyList, respList)
|
|
if diffEmptyList != "" {
|
|
t.Fatalf("an empty list should have been created but was not: %s", diffEmptyList)
|
|
}
|
|
}
|
|
|
|
// compare planModelList and resp list
|
|
diff := cmp.Diff(tt.planModelList, respList)
|
|
if tt.expectedAdjustedResp {
|
|
if diff == "" {
|
|
t.Fatalf("plan should be adjusted but was not")
|
|
}
|
|
} else {
|
|
if diff != "" {
|
|
t.Fatalf("plan should not be adjusted but diff is: %s", diff)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSetAndLogStateFields(t *testing.T) {
|
|
testSchema := schema.Schema{
|
|
Attributes: map[string]schema.Attribute{
|
|
"project_id": schema.StringAttribute{},
|
|
"instance_id": schema.StringAttribute{},
|
|
},
|
|
}
|
|
|
|
type args struct {
|
|
diags *diag.Diagnostics
|
|
state *tfsdk.State
|
|
values map[string]interface{}
|
|
}
|
|
type want struct {
|
|
hasError bool
|
|
state *tfsdk.State
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
args args
|
|
want want
|
|
}{
|
|
{
|
|
name: "empty map",
|
|
args: args{
|
|
diags: &diag.Diagnostics{},
|
|
state: &tfsdk.State{},
|
|
values: map[string]interface{}{},
|
|
},
|
|
want: want{
|
|
hasError: false,
|
|
state: &tfsdk.State{},
|
|
},
|
|
},
|
|
{
|
|
name: "base",
|
|
args: args{
|
|
diags: &diag.Diagnostics{},
|
|
state: func() *tfsdk.State {
|
|
ctx := context.Background()
|
|
state := tfsdk.State{
|
|
Raw: tftypes.NewValue(testSchema.Type().TerraformType(ctx), map[string]tftypes.Value{
|
|
"project_id": tftypes.NewValue(tftypes.String, "9b15d120-86f8-45f5-81d8-a554f09c7582"),
|
|
"instance_id": tftypes.NewValue(tftypes.String, nil),
|
|
}),
|
|
Schema: testSchema,
|
|
}
|
|
return &state
|
|
}(),
|
|
values: map[string]interface{}{
|
|
"project_id": "a414f971-3f7a-4e9a-8671-51a8acb7bcc8",
|
|
"instance_id": "97073250-8cad-46c3-8424-6258ac0b3731",
|
|
},
|
|
},
|
|
want: want{
|
|
hasError: false,
|
|
state: func() *tfsdk.State {
|
|
ctx := context.Background()
|
|
state := tfsdk.State{
|
|
Raw: tftypes.NewValue(testSchema.Type().TerraformType(ctx), map[string]tftypes.Value{
|
|
"project_id": tftypes.NewValue(tftypes.String, nil),
|
|
"instance_id": tftypes.NewValue(tftypes.String, nil),
|
|
}),
|
|
Schema: testSchema,
|
|
}
|
|
state.SetAttribute(ctx, path.Root("project_id"), "a414f971-3f7a-4e9a-8671-51a8acb7bcc8")
|
|
state.SetAttribute(ctx, path.Root("instance_id"), "97073250-8cad-46c3-8424-6258ac0b3731")
|
|
return &state
|
|
}(),
|
|
},
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
SetAndLogStateFields(ctx, tt.args.diags, tt.args.state, tt.args.values)
|
|
|
|
if tt.args.diags.HasError() != tt.want.hasError {
|
|
t.Errorf("TestSetAndLogStateFields() error count = %v, hasErr %v", tt.args.diags.ErrorsCount(), tt.want.hasError)
|
|
}
|
|
|
|
diff := cmp.Diff(tt.args.state, tt.want.state)
|
|
if diff != "" {
|
|
t.Fatalf("Data does not match: %s", diff)
|
|
}
|
|
})
|
|
}
|
|
}
|