add changes based on upstream import support

Author: anGie44

internal/generic/diagnostic.go

@@ -20,6 +20,13 @@ func DesiredStateErrorDiag(source string, err error) diag.Diagnostic {
 	)
 }
 
+func ResourceAttributeNotSetDiag(err error) diag.Diagnostic {
+	return diag.NewErrorDiagnostic(
+		"Terraform Resource Attribute Not Set",
+		fmt.Sprintf("Terraform resource attribute not set in State. This is typically an error with the Terraform provider implementation. Original Error: %s", err.Error()),
+	)
+}
+
 func ResourceIdentifierNotFoundDiag(err error) diag.Diagnostic {
 	return diag.NewErrorDiagnostic(
 		"Terraform Resource Identifier Not Found",

internal/generic/resource.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"reflect"
 	"strings"
 	"time"
 
@@ -724,24 +723,19 @@ func (r *resource) ImportState(ctx context.Context, request tfsdk.ImportResource
 
 	tflog.Debug(ctx, "Request.ID", "value", hclog.Fmt("%v", request.ID))
 
-	translator := toStruct{Schema: r.resourceType.tfSchema}
-	typ, err := translator.FromSchemaAttributes(ctx)
-	if err != nil {
-		response.Diagnostics.AddError(
-			"Import Of Terraform State Unsuccessful",
-			fmt.Sprintf("Unable to create a Terraform State value from a tfsdk.Schema for import. This is typically an error with the Terraform provider implementation. Original Error: %s", err.Error()),
-		)
-
-		return
-	}
+	state := &response.State
 
-	state := reflect.New(typ)
+	for name, attr := range state.Schema.Attributes {
+		err := r.setEmptyAttribute(ctx, attr, name, state)
 
-	state.Elem().FieldByName("Id").SetString(request.ID)
+		if err != nil {
+			response.Diagnostics = append(response.Diagnostics, ResourceAttributeNotSetDiag(err))
 
-	diags := response.State.Set(ctx, state.Elem().Interface())
+			return
+		}
+	}
 
-	response.Diagnostics.Append(diags...)
+	tfsdk.ResourceImportStatePassthroughID(ctx, idAttributePath, request, response)
 
 	tflog.Trace(ctx, "Resource.ImportState exit", "cfTypeName", r.resourceType.cfTypeName, "tfTypeName", r.resourceType.tfTypeName)
 }
@@ -788,6 +782,39 @@ func (r *resource) setId(ctx context.Context, val string, state *tfsdk.State) er
 	return nil
 }
 
+func (r *resource) setEmptyAttribute(ctx context.Context, attr tfsdk.Attribute, name string, state *tfsdk.State) error {
+	path := tftypes.NewAttributePath().WithAttributeName(name)
+
+	var diags diag.Diagnostics
+
+	if t := attr.Type; t != nil {
+		if t.TerraformType(ctx).Is(tftypes.String) {
+			diags = state.SetAttribute(ctx, path, "")
+		} else if t.TerraformType(ctx).Is(tftypes.Number) {
+			diags = state.SetAttribute(ctx, path, float64(0))
+		} else if t.TerraformType(ctx).Is(tftypes.Bool) {
+			diags = state.SetAttribute(ctx, path, false)
+		} else if t.TerraformType(ctx).Is(tftypes.Set{}) || t.TerraformType(ctx).Is(tftypes.List{}) || t.TerraformType(ctx).Is(tftypes.Tuple{}) {
+			diags = state.SetAttribute(ctx, path, []interface{}{})
+		} else if t.TerraformType(ctx).Is(tftypes.Map{}) || t.TerraformType(ctx).Is(tftypes.Object{}) {
+			diags = state.SetAttribute(ctx, path, map[string]interface{}{})
+		}
+	} else if attr.Attributes != nil { // attribute is a not a "tftype" e.g. providertypes.SetNestedAttributes
+		diags = state.SetAttribute(ctx, path, []interface{}{})
+	} else {
+		diags.Append(diag.NewErrorDiagnostic(
+			"Unknown Terraform Type for Attribute",
+			fmt.Sprintf("unknown terraform type for attribute (%s): %T", name, t),
+		))
+	}
+
+	if diags.HasError() {
+		return tfresource.DiagsError(diags)
+	}
+
+	return nil
+}
+
 // patchDocument returns a JSON Patch document describing the difference between `old` and `new`.
 func patchDocument(old, new string) (string, error) {
 	patch, err := jsonpatch.CreatePatch([]byte(old), []byte(new))

internal/generic/state_test.go

@@ -59,26 +59,6 @@ var testSimpleSchemaWithList = tfsdk.Schema{
 	},
 }
 
-var testSimpleSchemaWithUnsupportedType = tfsdk.Schema{
-	Attributes: map[string]tfsdk.Attribute{
-		"arn": {
-			Computed: true,
-		},
-		"identifier": {
-			Type:     types.StringType,
-			Computed: true,
-		},
-		"name": {
-			Type:     types.StringType,
-			Required: true,
-		},
-		"number": {
-			Type:     types.NumberType,
-			Optional: true,
-		},
-	},
-}
-
 var simpleCfToTfNameMap = map[string]string{
 	"Arn":        "arn",
 	"Identifier": "identifier",

internal/generic/translate.go

@@ -5,12 +5,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"math/big"
-	"reflect"
 
 	"github.com/hashicorp/terraform-plugin-framework/tfsdk"
 	"github.com/hashicorp/terraform-plugin-go/tftypes"
 	tflog "github.com/hashicorp/terraform-plugin-log"
-	"github.com/hashicorp/terraform-provider-awscc/internal/naming"
 )
 
 // Translates a Terraform Value to Cloud Control DesiredState.
@@ -271,44 +269,3 @@ func (t toTerraform) valueFromRaw(ctx context.Context, schema *tfsdk.Schema, pat
 		return tftypes.Value{}, fmt.Errorf("unsupported raw type: %T", v)
 	}
 }
-
-type toStruct struct {
-	Schema tfsdk.Schema
-}
-
-// FromSchemaAttributes returns a reflect.Type representing the
-// specified (resource) schema's attributes.
-func (s toStruct) FromSchemaAttributes(ctx context.Context) (reflect.Type, error) {
-	var fields []reflect.StructField
-
-	for k, v := range s.Schema.Attributes {
-		name := naming.TerraformAttributeToPascalCase(k)
-
-		field := reflect.StructField{
-			Name: name,
-			Tag:  reflect.StructTag(fmt.Sprintf(`tfsdk:"%s"`, k)),
-		}
-
-		if v.Type != nil {
-			if v.Type.TerraformType(ctx).Is(tftypes.String) {
-				field.Type = reflect.TypeOf("")
-			} else if v.Type.TerraformType(ctx).Is(tftypes.Number) {
-				field.Type = reflect.TypeOf(float64(0))
-			} else if v.Type.TerraformType(ctx).Is(tftypes.Bool) {
-				field.Type = reflect.TypeOf(false)
-			} else if v.Type.TerraformType(ctx).Is(tftypes.Set{}) || v.Type.TerraformType(ctx).Is(tftypes.List{}) || v.Type.TerraformType(ctx).Is(tftypes.Tuple{}) {
-				field.Type = reflect.TypeOf([]interface{}{})
-			} else if v.Type.TerraformType(ctx).Is(tftypes.Map{}) || v.Type.TerraformType(ctx).Is(tftypes.Object{}) {
-				field.Type = reflect.TypeOf(map[string]interface{}{})
-			}
-		} else if v.Attributes != nil { // attribute is a not a "tftype" e.g. providertypes.SetNestedAttributes
-			field.Type = reflect.TypeOf([]interface{}{})
-		} else {
-			return nil, fmt.Errorf("unknown type for attribute: %T", v)
-		}
-
-		fields = append(fields, field)
-	}
-
-	return reflect.StructOf(fields), nil
-}

internal/generic/translate_test.go

@@ -2,7 +2,6 @@ package generic
 
 import (
 	"context"
-	"reflect"
 	"testing"
 
 	"github.com/google/go-cmp/cmp"
@@ -393,169 +392,3 @@ func TestTranslateToTerraform(t *testing.T) {
 		})
 	}
 }
-
-func TestTranslateToStruct(t *testing.T) {
-	testCases := []struct {
-		TestName      string
-		Schema        tfsdk.Schema
-		ExpectedType  reflect.Type
-		ExpectedError bool
-	}{
-		{
-			TestName:      "simple struct with unsupported attribute",
-			Schema:        testSimpleSchemaWithUnsupportedType,
-			ExpectedError: true,
-		},
-		{
-			TestName: "simple Struct",
-			Schema:   testSimpleSchema,
-			ExpectedType: reflect.StructOf([]reflect.StructField{
-				{
-					Name: "Arn",
-					Tag:  `tfsdk:"arn"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "Identifier",
-					Tag:  `tfsdk:"identifier"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "Name",
-					Tag:  `tfsdk:"name"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "Number",
-					Tag:  `tfsdk:"number"`,
-					Type: reflect.TypeOf(0.0),
-				},
-			}),
-		},
-		{
-			TestName: "simple struct with list",
-			Schema:   testSimpleSchemaWithList,
-			ExpectedType: reflect.StructOf([]reflect.StructField{
-				{
-					Name: "Arn",
-					Tag:  `tfsdk:"arn"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "Identifier",
-					Tag:  `tfsdk:"identifier"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "Name",
-					Tag:  `tfsdk:"name"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "Number",
-					Tag:  `tfsdk:"number"`,
-					Type: reflect.TypeOf(0.0),
-				},
-				{
-					Name: "Ports",
-					Tag:  `tfsdk:"ports"`,
-					Type: reflect.TypeOf([]interface{}{}),
-				},
-			}),
-		},
-		{
-			TestName: "complex struct",
-			Schema:   testComplexSchema,
-			ExpectedType: reflect.StructOf([]reflect.StructField{
-				{
-					Name: "Name",
-					Tag:  `tfsdk:"name"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "MachineType",
-					Tag:  `tfsdk:"machine_type"`,
-					Type: reflect.TypeOf(""),
-				},
-				{
-					Name: "Ports",
-					Tag:  `tfsdk:"ports"`,
-					Type: reflect.TypeOf([]interface{}{}),
-				},
-				{
-					Name: "Tags",
-					Tag:  `tfsdk:"tags"`,
-					Type: reflect.TypeOf([]interface{}{}),
-				},
-				{
-					Name: "Disks",
-					Tag:  `tfsdk:"disks"`,
-					Type: reflect.TypeOf([]interface{}{}),
-				},
-				{
-					Name: "BootDisk",
-					Tag:  `tfsdk:"boot_disk"`,
-					Type: reflect.TypeOf([]interface{}{}),
-				},
-				{
-					Name: "ScratchDisk",
-					Tag:  `tfsdk:"scratch_disk"`,
-					Type: reflect.TypeOf(map[string]interface{}{}),
-				},
-				{
-					Name: "VideoPorts",
-					Tag:  `tfsdk:"video_ports"`,
-					Type: reflect.TypeOf([]interface{}{}),
-				},
-				{
-					Name: "Identifier",
-					Tag:  `tfsdk:"identifier"`,
-					Type: reflect.TypeOf(""),
-				},
-			}),
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.TestName, func(t *testing.T) {
-			translator := toStruct{Schema: testCase.Schema}
-			got, err := translator.FromSchemaAttributes(context.TODO())
-
-			if err == nil && testCase.ExpectedError {
-				t.Fatalf("expected error")
-			}
-
-			if err != nil && !testCase.ExpectedError {
-				t.Fatalf("unexpected error: %s", err)
-			}
-
-			if err == nil {
-				if !typesEqual(testCase.ExpectedType, got) {
-					t.Errorf("expected: %v, got: %v", testCase.ExpectedType, got)
-				}
-			}
-		})
-	}
-}
-
-func typesEqual(expected, got reflect.Type) bool {
-	if got.NumField() != expected.NumField() {
-		return false
-	}
-
-	for i := 0; i < expected.NumField(); i++ {
-		expectedField := expected.Field(i)
-
-		gotField, ok := got.FieldByName(expectedField.Name)
-
-		if !ok {
-			return false
-		}
-
-		if gotField.Name != expectedField.Name || gotField.Tag != expectedField.Tag || gotField.Type != expectedField.Type {
-			return false
-		}
-	}
-
-	return true
-}

internal/naming/naming.go

@@ -106,16 +106,6 @@ func Pluralize(name string) string {
 	return pluralName
 }
 
-// TerraformAttributeToPascalCase converts a Terraform Attribute name to PascalCase where applicable.
-// For example `global_replication_group_description` -> `GlobalReplicationGroupDescription`.
-func TerraformAttributeToPascalCase(name string) string {
-	if !strings.Contains(name, "_") {
-		return strings.Title(name)
-	}
-	n := strings.Replace(name, "_", " ", -1)
-	return strings.Replace(strings.Title(n), " ", "", -1)
-}
-
 // PluralizeWithCustomNameSuffix converts a name to its plural form similar to Pluralize,
 // with the exception that a suffix can be passed in as an argument to be used
 // only for names that are considered "custom" i.e. return true for isCustomName.