Refactor

Author: bbasata

internal/proto6server/server_listresource.go

@@ -17,6 +17,7 @@ type ResourceSchemaNotFoundError struct {
 func (e *ResourceSchemaNotFoundError) Error() string {
 	return "resource schema not found for type: " + e.TypeName
 }
+
 func (e *ResourceSchemaNotFoundError) Is(err error) bool {
 	compatibleErr, ok := err.(*ResourceSchemaNotFoundError)
 	if !ok {
@@ -50,6 +51,7 @@ type ListResourceSchemaNotFoundError struct {
 func (e *ListResourceSchemaNotFoundError) Error() string {
 	return "list resource schema not found for type: " + e.TypeName
 }
+
 func (e *ListResourceSchemaNotFoundError) Is(err error) bool {
 	compatibleErr, ok := err.(*ListResourceSchemaNotFoundError)
 	if !ok {
@@ -78,39 +80,31 @@ func (e *ListResourceConfigError) Is(err error) bool {
 }
 
 func (s *Server) ListResource(ctx context.Context, proto6Req *tfprotov6.ListResourceRequest) (*tfprotov6.ListResourceServerStream, error) {
+	// proto6Stream := &tfprotov6.ListResourceServerStream{Results: tfprotov6.NoListResults}
+	proto6Stream := &tfprotov6.ListResourceServerStream{Results: func(func(tfprotov6.ListResourceResult) bool) {}}
+
 	listResource, err := s.FrameworkServer.ListResourceOrError(ctx, proto6Req.TypeName)
 	if err != nil {
-		proto6Stream := &tfprotov6.ListResourceServerStream{}
-		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
-
 		return proto6Stream, err
 	}
 
 	resourceSchema, diags := s.FrameworkServer.ResourceSchema(ctx, proto6Req.TypeName)
 	if diags.HasError() {
-		proto6Stream := &tfprotov6.ListResourceServerStream{}
-		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
 		return proto6Stream, &ResourceSchemaNotFoundError{TypeName: proto6Req.TypeName}
 	}
 
 	identitySchema, diags := s.FrameworkServer.ResourceIdentitySchema(ctx, proto6Req.TypeName)
 	if diags.HasError() {
-		proto6Stream := &tfprotov6.ListResourceServerStream{}
-		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
-		return proto6Stream, &ResourceIdentitySchemaNotFoundError{TypeName: proto6Req.TypeName} // TODO: return a diagnostic instead of an error?
+		return proto6Stream, &ResourceIdentitySchemaNotFoundError{TypeName: proto6Req.TypeName}
 	}
 
 	listResourceSchema, diags := s.FrameworkServer.ListResourceSchema(ctx, proto6Req.TypeName)
 	if diags.HasError() {
-		proto6Stream := &tfprotov6.ListResourceServerStream{}
-		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
 		return proto6Stream, &ListResourceSchemaNotFoundError{TypeName: proto6Req.TypeName}
 	}
 
 	config, diags := fromproto6.Config(ctx, proto6Req.Config, listResourceSchema)
 	if diags.HasError() {
-		proto6Stream := &tfprotov6.ListResourceServerStream{}
-		proto6Stream.Results = func(func(tfprotov6.ListResourceResult) bool) {}
 		return proto6Stream, &ListResourceConfigError{TypeName: proto6Req.TypeName, Diagnostics: diags}
 	}
 
@@ -128,7 +122,6 @@ func (s *Server) ListResource(ctx context.Context, proto6Req *tfprotov6.ListReso
 		return nil, err
 	}
 
-	proto6Stream := &tfprotov6.ListResourceServerStream{}
 	proto6Stream.Results = func(push func(tfprotov6.ListResourceResult) bool) {
 		for result := range stream.Results {
 			var proto6Result tfprotov6.ListResourceResult

internal/proto6server/server_listresource_test.go

@@ -23,39 +23,42 @@ import (
 func TestServerListResource(t *testing.T) {
 	t.Parallel()
 
-	type ThingResource struct {
-		Name string `tfsdk:"name"`
+	type ThingResourceIdentity struct {
+		Id string `tfsdk:"id"`
 	}
 
-	type ThingResourceIdentity struct {
+	type ThingResource struct {
+		// TODO: how do we feel about this?
+		ThingResourceIdentity
 		Name string `tfsdk:"name"`
 	}
 
 	resources := map[string]ThingResource{}
-	resourceIdentities := map[string]ThingResourceIdentity{}
 	expectedResources := map[string]*tfprotov6.DynamicValue{}
 	expectedResourceIdentities := map[string]*tfprotov6.ResourceIdentityData{}
 
 	examples := []string{"bookbag", "bookshelf", "bookworm", "plateau", "platinum", "platypus"}
 	for _, example := range examples {
-		resources[example] = ThingResource{Name: example}
-		resourceIdentities[example] = ThingResourceIdentity{Name: example}
+		id := "id-" + example
+		resources[example] = ThingResource{Name: example, ThingResourceIdentity: ThingResourceIdentity{Id: id}}
 
 		expectedResources[example] = testNewDynamicValue(t, tftypes.Object{
 			AttributeTypes: map[string]tftypes.Type{
+				"id":   tftypes.String,
 				"name": tftypes.String,
 			},
 		}, map[string]tftypes.Value{
+			"id":   tftypes.NewValue(tftypes.String, id),
 			"name": tftypes.NewValue(tftypes.String, example),
 		})
 
 		expectedResourceIdentities[example] = &tfprotov6.ResourceIdentityData{
 			IdentityData: testNewDynamicValue(t, tftypes.Object{
 				AttributeTypes: map[string]tftypes.Type{
-					"name": tftypes.String,
+					"id": tftypes.String,
 				},
 			}, map[string]tftypes.Value{
-				"name": tftypes.NewValue(tftypes.String, example),
+				"id": tftypes.NewValue(tftypes.String, id),
 			}),
 		}
 	}
@@ -100,25 +103,12 @@ func TestServerListResource(t *testing.T) {
 						continue
 					}
 
-					result := list.ListResult{}
-					identity, diags := req.ToIdentity(ctx, resourceIdentities[name])
-					if diags.HasError() {
-						result.Diagnostics = diags
-						results = append(results, result)
-						continue
-					}
-
-					resource, diags := req.ToResource(ctx, resources[name])
-					if diags.HasError() {
-						result.Diagnostics = diags
-						results = append(results, result)
-						continue
-					}
+					result := req.ToResult(
+						ctx,
+						resources[name].ThingResourceIdentity,
+						resources[name],
+						name)
 
-					result.DisplayName = name
-					result.Identity = identity
-					result.Resource = resource // maybe only include if request says so
-					result.Diagnostics = diags
 					results = append(results, result)
 				}
 				resp.Results = slices.Values(results)
@@ -134,7 +124,7 @@ func TestServerListResource(t *testing.T) {
 			IdentitySchemaMethod: func(ctx context.Context, req resource.IdentitySchemaRequest, resp *resource.IdentitySchemaResponse) {
 				resp.IdentitySchema = identityschema.Schema{
 					Attributes: map[string]identityschema.Attribute{
-						"name": identityschema.StringAttribute{},
+						"id": identityschema.StringAttribute{},
 					},
 				}
 			},
@@ -145,6 +135,7 @@ func TestServerListResource(t *testing.T) {
 				SchemaMethod: func(ctx context.Context, req resource.SchemaRequest, resp *resource.SchemaResponse) {
 					resp.Schema = resourceschema.Schema{
 						Attributes: map[string]resourceschema.Attribute{
+							"id":   resourceschema.StringAttribute{},
 							"name": resourceschema.StringAttribute{},
 						},
 					}

list/list_resource.go

@@ -131,6 +131,31 @@ func (r ListRequest) ToIdentity(ctx context.Context, val any) (*tfsdk.ResourceId
 	return identity, diags
 }
 
+func (r ListRequest) ToResult(ctx context.Context, identityVal any, resourceVal any, displayName string) ListResult {
+	diags := diag.Diagnostics{}
+	identity, d := r.ToIdentity(ctx, identityVal)
+	diags.Append(d...)
+	if diags.HasError() {
+		return ListResult{Diagnostics: diags}
+	}
+
+	var resource *tfsdk.Resource
+	if r.IncludeResource {
+		resource, d = r.ToResource(ctx, resourceVal)
+		diags.Append(d...)
+		if diags.HasError() {
+			return ListResult{Diagnostics: diags}
+		}
+	}
+
+	return ListResult{
+		DisplayName: displayName,
+		Resource:    resource,
+		Identity:    identity,
+		Diagnostics: diags,
+	}
+}
+
 // ListResultsStream represents a streaming response to a ListRequest.  An
 // instance of this struct is supplied as an argument to the provider's
 // ListResource function. The provider should set a Results iterator function