probable fixes

Author: simplyluke

internal/provider/resourceconfiguration/json_semantic_equals.go

@@ -99,4 +99,3 @@ func jsonContains(container, subset interface{}) bool {
 func JSONSemanticEquals() planmodifier.String {
 	return jsonSemanticEqualsPlanModifier{}
 }
-

internal/provider/resourceconfiguration/resource.go

@@ -217,10 +217,10 @@ func (r *resourceConfigurationResource) Read(ctx context.Context, req resource.R
 	// even though the API returns one. We need to make a raw HTTP call and parse it manually.
 	// The actual API response format is identical for GET, POST, and PATCH operations.
 
-	// Get the API client configuration to make a raw HTTP request
+	// Get the API client configuration to make a raw HTTP request.
 	cfg := r.client.GetConfig()
 
-	// Construct the full URL using the host and scheme from the configuration
+	// Construct the full URL using the host and scheme from the configuration.
 	url := fmt.Sprintf("%s://%s/api/v2/resource_configurations/%s", cfg.Scheme, cfg.Host, configID)
 	httpReq, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
@@ -231,13 +231,13 @@ func (r *resourceConfigurationResource) Read(ctx context.Context, req resource.R
 		return
 	}
 
-	// Add authentication and other headers
+	// Add authentication and other headers.
 	for key, value := range cfg.DefaultHeader {
 		httpReq.Header.Set(key, value)
 	}
 	httpReq.Header.Set("Accept", "application/json")
 
-	// Execute the request using the client's HTTP client
+	// Execute the request using the client's HTTP client.
 	httpResponse, err := cfg.HTTPClient.Do(httpReq)
 	if err != nil {
 		resp.Diagnostics.AddError(
@@ -246,7 +246,7 @@ func (r *resourceConfigurationResource) Read(ctx context.Context, req resource.R
 		)
 		return
 	}
-	defer httpResponse.Body.Close()
+	defer func() { _ = httpResponse.Body.Close() }()
 
 	// Handle 404
 	if httpResponse.StatusCode == 404 {
@@ -274,7 +274,7 @@ func (r *resourceConfigurationResource) Read(ctx context.Context, req resource.R
 		return
 	}
 
-	// Parse the response using the correct Post200Response type (which has .Data wrapper)
+	// Parse the response using the correct Post200Response type (which has .Data wrapper).
 	var configuration api.ResourceConfigurationsPost200Response
 	if err := json.Unmarshal(bodyBytes, &configuration); err != nil {
 		resp.Diagnostics.AddError(
@@ -377,10 +377,10 @@ func (r *resourceConfigurationResource) Update(ctx context.Context, req resource
 	plan.CreatedAt = types.StringValue(updateResponse.Data.CreatedAt)
 	plan.UpdatedAt = types.StringValue(updateResponse.Data.UpdatedAt)
 
-	// Note: We don't update options from the API response because:
-	// 1. The API adds default values that weren't in the plan
-	// 2. This would cause Terraform to see inconsistent values for sensitive attributes
-	// Instead, we keep the planned value which is what the user specified
+	// Note: We don't update options from the API response because:.
+	// 1. The API adds default values that weren't in the plan.
+	// 2. This would cause Terraform to see inconsistent values for sensitive attributes.
+	// Instead, we keep the planned value which is what the user specified.
 
 	diags = resp.State.Set(ctx, plan)
 	resp.Diagnostics.Append(diags...)

internal/provider/resourceconfiguration/resource_schema_test.go

@@ -1,41 +1,33 @@
-package resourceconfiguration_test
+package resourceconfiguration
 
 import (
+	"context"
 	"testing"
 
-	"github.com/hashicorp/terraform-plugin-framework/providerserver"
-	"github.com/hashicorp/terraform-plugin-go/tfprotov6"
-	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
-	"github.com/hashicorp/terraform-plugin-testing/knownvalue"
-	"github.com/hashicorp/terraform-plugin-testing/statecheck"
-	"github.com/hashicorp/terraform-plugin-testing/tfjsonpath"
-
-	"github.com/tryretool/terraform-provider-retool/internal/provider"
+	// The fwresource import alias is so there is no collision
+	// with the more typical acceptance testing import:
+	// "github.com/hashicorp/terraform-plugin-testing/helper/resource".
+	fwresource "github.com/hashicorp/terraform-plugin-framework/resource"
 )
 
-// TestAccResourceConfigurationResourceSchema tests the resource schema for the resource configuration resource.
-func TestAccResourceConfigurationResourceSchema(t *testing.T) {
-	resource.Test(t, resource.TestCase{
-		ProtoV6ProviderFactories: map[string]func() (tfprotov6.ProviderServer, error){
-			"retool": providerserver.NewProtocol6WithError(provider.New("test")()),
-		},
-		Steps: []resource.TestStep{
-			{
-				Config: `
-					resource "retool_resource_configuration" "test" {
-						resource_id    = "00000000-0000-0000-0000-000000000000"
-						environment_id = "00000000-0000-0000-0000-000000000000"
-						options        = jsonencode({
-							base_url = "https://api.example.com"
-						})
-					}
-				`,
-				ConfigStateChecks: []statecheck.StateCheck{
-					statecheck.ExpectKnownValue("retool_resource_configuration.test", tfjsonpath.New("resource_id"), knownvalue.StringExact("00000000-0000-0000-0000-000000000000")),
-					statecheck.ExpectKnownValue("retool_resource_configuration.test", tfjsonpath.New("environment_id"), knownvalue.StringExact("00000000-0000-0000-0000-000000000000")),
-				},
-			},
-		},
-	})
-}
+func TestResourceConfigurationResourceSchema(t *testing.T) {
+	t.Parallel()
+
+	ctx := context.Background()
+	schemaRequest := fwresource.SchemaRequest{}
+	schemaResponse := &fwresource.SchemaResponse{}
+
+	// Instantiate the resource.Resource and call its Schema method.
+	NewResource().Schema(ctx, schemaRequest, schemaResponse)
 
+	if schemaResponse.Diagnostics.HasError() {
+		t.Fatalf("Schema method diagnostics: %+v", schemaResponse.Diagnostics)
+	}
+
+	// Validate the schema.
+	diagnostics := schemaResponse.Schema.ValidateImplementation(ctx)
+
+	if diagnostics.HasError() {
+		t.Fatalf("Schema validation diagnostics: %+v", diagnostics)
+	}
+}

internal/provider/resourceconfiguration/resource_test.go

@@ -136,4 +136,3 @@ func init() {
 		},
 	})
 }
-