Type walker

Author: t0yv0

pkg/tfshim/walk/walk.go

@@ -27,6 +27,7 @@ import (
 
 	shim "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfshim"
 	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfshim/schema"
+	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/valueshim"
 )
 
 // Represents locations in a tfshim.Schema value as a sequence of steps to locate it.
@@ -174,6 +175,32 @@ func LookupSchemaMapPath(path SchemaPath, schemaMap shim.SchemaMap) (shim.Schema
 	return LookupSchemaPath(path, wrapSchemaMap(schemaMap))
 }
 
+// Finds a nested Type at a given path.
+func LookupType(path SchemaPath, ty valueshim.Type) (valueshim.Type, error) {
+	current := ty
+	for i, step := range path {
+		var subPath SchemaPath = path[0:i]
+		switch step := step.(type) {
+		case GetAttrStep:
+			attr, ok := current.AttributeType(step.Name)
+			if !ok {
+				return nil, fmt.Errorf("LookupType mismatch: no attribute %q at path %v",
+					step.Name, subPath)
+			}
+			current = attr
+		case ElementStep:
+			el, ok := current.ElementType()
+			if !ok {
+				return nil, fmt.Errorf("LookupType mismatch: no element type at path %v", subPath)
+			}
+			current = el
+		default:
+			contract.Failf("unexpected SchemaPathStep case")
+		}
+	}
+	return current, nil
+}
+
 // Represents elements of a SchemaPath.
 //
 // This interface is closed, the only the implementations given in the current package are allowed.

pkg/tfshim/walk/walk_test.go

@@ -18,11 +18,13 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/hashicorp/terraform-plugin-go/tftypes"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfshim"
 	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfshim/schema"
+	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/valueshim"
 )
 
 var strSchema = (&schema.Schema{
@@ -168,3 +170,104 @@ func TestEncodeDecodeSchemaPath(t *testing.T) {
 		})
 	}
 }
+
+func TestLookupType(t *testing.T) {
+	t.Parallel()
+
+	type testCase struct {
+		p            SchemaPath
+		toplevelType valueshim.Type
+		expectedType valueshim.Type
+		isErr        bool
+	}
+
+	testCases := []testCase{
+		{
+			p: NewSchemaPath(),
+			toplevelType: valueshim.FromTType(tftypes.Object{
+				AttributeTypes: map[string]tftypes.Type{
+					"x": tftypes.String,
+				},
+			}),
+			expectedType: valueshim.FromTType(tftypes.Object{
+				AttributeTypes: map[string]tftypes.Type{
+					"x": tftypes.String,
+				},
+			}),
+		},
+		{
+			p: NewSchemaPath().GetAttr("x"),
+			toplevelType: valueshim.FromTType(tftypes.Object{
+				AttributeTypes: map[string]tftypes.Type{
+					"x": tftypes.String,
+				},
+			}),
+			expectedType: valueshim.FromTType(tftypes.String),
+		},
+		{
+			p: NewSchemaPath().GetAttr("y"),
+			toplevelType: valueshim.FromTType(tftypes.Object{
+				AttributeTypes: map[string]tftypes.Type{
+					"x": tftypes.String,
+				},
+			}),
+			isErr: true,
+		},
+		{
+			p: NewSchemaPath().GetAttr("x").GetAttr("y"),
+			toplevelType: valueshim.FromTType(tftypes.Object{
+				AttributeTypes: map[string]tftypes.Type{
+					"x": tftypes.Object{
+						AttributeTypes: map[string]tftypes.Type{
+							"y": tftypes.String,
+						},
+					},
+				},
+			}),
+			expectedType: valueshim.FromTType(tftypes.String),
+		},
+		{
+			p: NewSchemaPath().Element(),
+			toplevelType: valueshim.FromTType(tftypes.Object{
+				AttributeTypes: map[string]tftypes.Type{
+					"x": tftypes.String,
+				},
+			}),
+			isErr: true,
+		},
+		{
+			p: NewSchemaPath().Element(),
+			toplevelType: valueshim.FromTType(tftypes.Map{
+				ElementType: tftypes.String,
+			}),
+			expectedType: valueshim.FromTType(tftypes.String),
+		},
+		{
+			p: NewSchemaPath().Element(),
+			toplevelType: valueshim.FromTType(tftypes.Set{
+				ElementType: tftypes.String,
+			}),
+			expectedType: valueshim.FromTType(tftypes.String),
+		},
+		{
+			p: NewSchemaPath().Element(),
+			toplevelType: valueshim.FromTType(tftypes.List{
+				ElementType: tftypes.String,
+			}),
+			expectedType: valueshim.FromTType(tftypes.String),
+		},
+	}
+
+	for i, tc := range testCases {
+		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
+			actualType, err := LookupType(tc.p, tc.toplevelType)
+			if tc.isErr {
+				require.NotNil(t, err)
+				t.Logf("ERROR: %v", err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, tc.expectedType, actualType)
+			}
+		})
+	}
+}