[AV-66756] Code Health - Extract API error handling

examples/allowlist/create_allowlist.tf

@@ -2,6 +2,10 @@ output "new_allowlist" {
   value = capella_allowlist.new_allowlist
 }
 
+output "allowlist_id" {
+  value = capella_allowlist.new_allowlist.id
+}
+
 resource "capella_allowlist" "new_allowlist" {
   organization_id = var.organization_id
   project_id      = var.project_id

examples/apikey/create_apikey.tf

@@ -3,6 +3,10 @@ output "new_apikey" {
   sensitive = true
 }
 
+output "apikey_id" {
+  value = capella_apikey.new_apikey.id
+}
+
 resource "capella_apikey" "new_apikey" {
   organization_id    = var.organization_id
   name               = var.apikey.name

examples/appservice/create_app_service.tf

@@ -2,6 +2,10 @@ output "new_app_service" {
     value = capella_app_service.new_app_service
 }
 
+output "appservice_id" {
+  value = capella_app_service.new_app_service.id
+}
+
 resource "capella_app_service" "new_app_service" {
   organization_id = var.organization_id
   project_id      = var.project_id
@@ -14,4 +18,4 @@ resource "capella_app_service" "new_app_service" {
       ram = var.app_service.compute.ram
   }
   version         = var.app_service.version
-}
+}

examples/bucket/create_bucket.tf

@@ -2,6 +2,10 @@ output "new_bucket" {
   value = capella_bucket.new_bucket
 }
 
+output "bucket_id" {
+  value = capella_bucket.new_bucket.id
+}
+
 resource "capella_bucket" "new_bucket" {
   name                       = var.bucket.name
   organization_id            = var.organization_id
@@ -16,4 +20,4 @@ resource "capella_bucket" "new_bucket" {
   flush                      = var.bucket.flush
   time_to_live_in_seconds    = var.bucket.time_to_live_in_seconds
   eviction_policy            = var.bucket.eviction_policy
-}
+}

examples/cluster/create_cluster.tf

@@ -2,6 +2,10 @@ output "new_cluster" {
   value = capella_cluster.new_cluster
 }
 
+output "cluster_id" {
+  value = capella_cluster.new_cluster.id
+}
+
 resource "capella_cluster" "new_cluster" {
   organization_id = var.organization_id
   project_id      = var.project_id

examples/database_credential/create_database_credential.tf

@@ -3,6 +3,10 @@ output "new_database_credential" {
   sensitive = true
 }
 
+output "database_credential_id" {
+  value = capella_database_credential.new_database_credential.id
+}
+
 resource "capella_database_credential" "new_database_credential" {
   name            = var.database_credential_name
   organization_id = var.organization_id

examples/project/create_project.tf

@@ -2,6 +2,10 @@ output "new_project" {
   value = capella_project.new_project
 }
 
+output "project_id" {
+  value = capella_project.new_project.id
+}
+
 resource "capella_project" "new_project" {
   organization_id = var.organization_id
   name            = var.project_name

examples/user/create_user.tf

@@ -2,6 +2,10 @@ output "new_user" {
   value = capella_user.new_user
 }
 
+output "user_id" {
+  value = capella_user.new_user.id
+}
+
 resource "capella_user" "new_user" {
   organization_id = var.organization_id
 

internal/api/client.go

@@ -62,7 +62,7 @@ func (c *Client) Execute(
 
 	req, err := http.NewRequest(endpointCfg.Method, endpointCfg.Url, bytes.NewReader(requestBody))
 	if err != nil {
-		return nil, fmt.Errorf("%s: %v", errors.ErrConstructingRequest, err)
+		return nil, fmt.Errorf("%s: %w", errors.ErrConstructingRequest, err)
 	}
 
 	req.Header.Set("Authorization", "Bearer "+authToken)
@@ -72,7 +72,7 @@ func (c *Client) Execute(
 
 	apiRes, err := c.Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("%s: %v", errors.ErrExecutingRequest, err)
+		return nil, fmt.Errorf("%s: %w", errors.ErrExecutingRequest, err)
 	}
 	defer apiRes.Body.Close()
 
@@ -88,7 +88,7 @@ func (c *Client) Execute(
 				"unexpected code: %d, expected: %d, body: %s",
 				apiRes.StatusCode, endpointCfg.SuccessStatus, responseBody)
 		}
-		return nil, apiError
+		return nil, &apiError
 	}
 
 	return &Response{

internal/api/error.go

@@ -2,7 +2,9 @@ package api
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
+	"net/http"
 )
 
 // Error tracks the error structure received from Capella V4 APIs
@@ -19,14 +21,48 @@ type Error struct {
 	Message string `json:"message"`
 }
 
-func (e Error) Error() string {
-	return fmt.Sprintf("%s", e.Message)
+func (e *Error) Error() string {
+	return fmt.Sprintf(`{"code":%d,"hint":"%s","httpStatusCode":%d,"message":"%s"}`,
+		e.Code, e.Hint, e.HttpStatusCode, e.Message,
+	)
 }
 
 func (e Error) CompleteError() string {
 	jsonData, err := json.Marshal(e)
 	if err != nil {
-		return e.Message
+		return fmt.Sprintf(`{"code":%d,"hint":"%s","httpStatusCode":%d,"message":"%s"}`,
+			e.Code, e.Hint, e.HttpStatusCode, e.Message,
+		)
 	}
 	return string(jsonData)
 }
+
+// ParseError is used to check if an error is of type
+// api.Error error and return it as a string.
+func ParseError(err error) string {
+	var apiError *Error
+	switch {
+	case errors.As(err, &apiError):
+		return apiError.CompleteError()
+	default:
+		return err.Error()
+	}
+}
+
+// CheckResourceNotFoundError is used to check if an error is of
+// type api.Error and whether the error is resource not found.
+//
+// Note: If the error is other than not found, the error string
+// will be returned along with a bool value of false.
+func CheckResourceNotFoundError(err error) (bool, string) {
+	var apiError *Error
+	switch {
+	case errors.As(err, &apiError):
+		if apiError.HttpStatusCode != http.StatusNotFound {
+			return false, apiError.CompleteError()
+		}
+		return true, apiError.CompleteError()
+	default:
+		return false, err.Error()
+	}
+}

internal/api/error_test.go

@@ -0,0 +1,112 @@
+package api
+
+import (
+	"fmt"
+	"net/http"
+	internalerrors "terraform-provider-capella/internal/errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_ParseError(t *testing.T) {
+	var (
+		errMessage = "Error received from Capella V4 Api"
+		apiError   = Error{Message: errMessage}
+	)
+
+	type test struct {
+		name      string
+		err       error
+		expOutput interface{}
+	}
+
+	tests := []test{
+		{
+			name:      "Error received from Capella V4 Api",
+			err:       &Error{Message: errMessage},
+			expOutput: Error{Message: errMessage}.CompleteError(),
+		},
+		{
+			name:      "Wrapped error received from Capella V4 Api",
+			err:       fmt.Errorf("received error: %w", &apiError),
+			expOutput: Error{Message: errMessage}.CompleteError(),
+		},
+		{
+			name:      "Error other than received from Capella V4 Api",
+			err:       internalerrors.ErrAllowListIdCannotBeEmpty,
+			expOutput: internalerrors.ErrAllowListIdCannotBeEmpty.Error(),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			errString := ParseError(test.err)
+
+			assert.Equal(t, test.expOutput, errString)
+		})
+	}
+}
+
+func Test_CheckResourceNotFound(t *testing.T) {
+	var (
+		errMessage = "example error message"
+		err500     = Error{
+			HttpStatusCode: http.StatusInternalServerError,
+			Message:        errMessage,
+		}
+		err404 = Error{
+			HttpStatusCode: http.StatusNotFound,
+			Message:        errMessage,
+		}
+	)
+
+	type test struct {
+		name      string
+		err       error
+		expOutput interface{}
+		expBool   bool
+	}
+
+	tests := []test{
+		{
+			name:      "Error received from Capella V4 Api",
+			err:       &err500,
+			expOutput: err500.CompleteError(),
+			expBool:   false,
+		},
+		{
+			name:      "Error received from Capella V4 Api - Resource Not Found",
+			err:       &err404,
+			expOutput: err404.CompleteError(),
+			expBool:   true,
+		},
+		{
+			name:      "Wrapped 500 error received from Capella V4 Api",
+			err:       fmt.Errorf("received error: %w", &err500),
+			expOutput: err500.CompleteError(),
+			expBool:   false,
+		},
+		{
+			name:      "Wrapped 404 error received from Capella V4 Api",
+			err:       fmt.Errorf("received error: %w", &err404),
+			expOutput: err404.CompleteError(),
+			expBool:   true,
+		},
+		{
+			name:      "Error other than received from Capella V4 Api",
+			err:       internalerrors.ErrAllowListIdCannotBeEmpty,
+			expOutput: internalerrors.ErrAllowListIdCannotBeEmpty.Error(),
+			expBool:   false,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			resourceNotFound, errString := CheckResourceNotFoundError(test.err)
+
+			assert.Equal(t, test.expOutput, errString)
+			assert.Equal(t, test.expBool, resourceNotFound)
+		})
+	}
+}

internal/api/pagination.go

@@ -1,6 +1,8 @@
 package api
 
 import (
+	"terraform-provider-capella/internal/errors"
+
 	"context"
 	"encoding/json"
 	"fmt"
@@ -92,13 +94,13 @@ func GetPaginated[DataSchema ~[]T, T any](
 			nil,
 		)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("%s: %w", errors.ErrExecutingRequest, err)
 		}
 
 		var decoded overlay
 		err = json.Unmarshal(response.Body, &decoded)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("%s: %w", errors.ErrUnmarshallingResponse, err)
 		}
 
 		responses = append(responses, decoded.Data...)

internal/datasources/allowlists.go

@@ -11,7 +11,6 @@ import (
 	"github.com/hashicorp/terraform-plugin-framework/datasource"
 	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
 	"github.com/hashicorp/terraform-plugin-framework/types"
-	"github.com/hashicorp/terraform-plugin-log/tflog"
 )
 
 // Ensure the implementation satisfies the expected interfaces.
@@ -87,23 +86,10 @@ func (d *AllowLists) Read(ctx context.Context, req datasource.ReadRequest, resp
 	)
 
 	allowLists, err := d.listAllowLists(ctx, organizationId, projectId, clusterId)
-	switch err := err.(type) {
-	case nil:
-	case api.Error:
-		if err.HttpStatusCode != http.StatusNotFound {
-			resp.Diagnostics.AddError(
-				"Error Reading Capella AllowLists",
-				"Could not read allow lists in cluster "+state.ClusterId.String()+": "+err.CompleteError(),
-			)
-			return
-		}
-		tflog.Info(ctx, "resource doesn't exist in remote server removing resource from state file")
-		resp.State.RemoveResource(ctx)
-		return
-	default:
+	if err != nil {
 		resp.Diagnostics.AddError(
-			"Error Reading AllowLists",
-			"Could not read allow lists in cluster "+state.ClusterId.String()+": "+err.Error(),
+			"Error Reading Capella AllowLists",
+			"Could not read allow lists in cluster "+state.ClusterId.String()+": "+api.ParseError(err),
 		)
 		return
 	}
@@ -112,7 +98,7 @@ func (d *AllowLists) Read(ctx context.Context, req datasource.ReadRequest, resp
 	if err != nil {
 		resp.Diagnostics.AddError(
 			"Error reading allowlist",
-			"Could not create allowlist, unexpected error: "+err.Error(),
+			"Could not read allowlist, unexpected error: "+err.Error(),
 		)
 		return
 	}

internal/datasources/apikeys.go

@@ -90,18 +90,10 @@ func (d *ApiKeys) Read(ctx context.Context, req datasource.ReadRequest, resp *da
 	cfg := api.EndpointCfg{Url: url, Method: http.MethodGet, SuccessStatus: http.StatusOK}
 
 	response, err := api.GetPaginated[[]api.GetApiKeyResponse](ctx, d.Client, d.Token, cfg, api.SortByName)
-	switch err := err.(type) {
-	case nil:
-	case api.Error:
-		resp.Diagnostics.AddError(
-			"Error Reading Capella ApiKeys",
-			"Could not read api keys in organization "+organizationId+": "+err.CompleteError(),
-		)
-		return
-	default:
+	if err != nil {
 		resp.Diagnostics.AddError(
 			"Error Reading Capella ApiKeys",
-			"Could not read api keys in organization "+organizationId+": "+err.Error(),
+			"Could not read api keys in organization "+organizationId+": "+api.ParseError(err),
 		)
 		return
 	}