chore(load-balancer): Add nil pointer checks and tests for the output…

internal/cmd/load-balancer/describe/describe.go

@@ -99,6 +99,9 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *loadbalance
 }
 
 func outputResult(p *print.Printer, outputFormat string, loadBalancer *loadbalancer.LoadBalancer) error {
+	if loadBalancer == nil {
+		return fmt.Errorf("loadbalancer response is empty")
+	}
 	switch outputFormat {
 	case print.JSONOutputFormat:
 		details, err := json.MarshalIndent(loadBalancer, "", "  ")

internal/cmd/load-balancer/describe/describe_test.go

@@ -4,12 +4,11 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
-	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
-
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
 	"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer"
 )
 
@@ -206,3 +205,37 @@ func TestBuildRequest(t *testing.T) {
 		})
 	}
 }
+
+func TestOutputResult(t *testing.T) {
+	type args struct {
+		outputFormat string
+		loadBalancer *loadbalancer.LoadBalancer
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name:    "empty",
+			args:    args{},
+			wantErr: true,
+		},
+		{
+			name: "only loadbalancer as argument",
+			args: args{
+				loadBalancer: &loadbalancer.LoadBalancer{},
+			},
+			wantErr: false,
+		},
+	}
+	p := print.NewPrinter()
+	p.Cmd = NewCmd(p)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := outputResult(p, tt.args.outputFormat, tt.args.loadBalancer); (err != nil) != tt.wantErr {
+				t.Errorf("outputResult() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

internal/cmd/load-balancer/generate-payload/generate_payload.go

@@ -213,13 +213,16 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *loadbalance
 }
 
 func outputCreateResult(p *print.Printer, filePath *string, payload *loadbalancer.CreateLoadBalancerPayload) error {
+	if payload == nil {
+		return fmt.Errorf("loadbalancer payload is empty")
+	}
 	payloadBytes, err := json.MarshalIndent(*payload, "", "  ")
 	if err != nil {
 		return fmt.Errorf("marshal create load balancer payload: %w", err)
 	}
 
 	if filePath != nil {
-		err = fileutils.WriteToFile(*filePath, string(payloadBytes))
+		err = fileutils.WriteToFile(utils.PtrString(filePath), string(payloadBytes))
 		if err != nil {
 			return fmt.Errorf("write create load balancer payload to the file: %w", err)
 		}
@@ -231,13 +234,16 @@ func outputCreateResult(p *print.Printer, filePath *string, payload *loadbalance
 }
 
 func outputUpdateResult(p *print.Printer, filePath *string, payload *loadbalancer.UpdateLoadBalancerPayload) error {
+	if payload == nil {
+		return fmt.Errorf("loadbalancer payload is empty")
+	}
 	payloadBytes, err := json.MarshalIndent(*payload, "", "  ")
 	if err != nil {
 		return fmt.Errorf("marshal update load balancer payload: %w", err)
 	}
 
 	if filePath != nil {
-		err = fileutils.WriteToFile(*filePath, string(payloadBytes))
+		err = fileutils.WriteToFile(utils.PtrString(filePath), string(payloadBytes))
 		if err != nil {
 			return fmt.Errorf("write update load balancer payload to the file: %w", err)
 		}

internal/cmd/load-balancer/generate-payload/generate_payload_test.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
-	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
-	"github.com/stackitcloud/stackit-cli/internal/pkg/utils"
-
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
-
+	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/utils"
 	"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer"
 )
 
@@ -310,3 +308,71 @@ func TestModifyListeners(t *testing.T) {
 		})
 	}
 }
+
+func TestOutputCreateResult(t *testing.T) {
+	type args struct {
+		filePath *string
+		payload  *loadbalancer.CreateLoadBalancerPayload
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name:    "empty",
+			args:    args{},
+			wantErr: true,
+		},
+		{
+			name: "only loadbalancer payload as argument",
+			args: args{
+				payload: &loadbalancer.CreateLoadBalancerPayload{},
+			},
+			wantErr: false,
+		},
+	}
+	p := print.NewPrinter()
+	p.Cmd = NewCmd(p)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := outputCreateResult(p, tt.args.filePath, tt.args.payload); (err != nil) != tt.wantErr {
+				t.Errorf("outputCreateResult() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestOutputUpdateResult(t *testing.T) {
+	type args struct {
+		filePath *string
+		payload  *loadbalancer.UpdateLoadBalancerPayload
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name:    "empty",
+			args:    args{},
+			wantErr: true,
+		},
+		{
+			name: "only loadbalancer payload as argument",
+			args: args{
+				payload: &loadbalancer.UpdateLoadBalancerPayload{},
+			},
+			wantErr: false,
+		},
+	}
+	p := print.NewPrinter()
+	p.Cmd = NewCmd(p)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := outputUpdateResult(p, tt.args.filePath, tt.args.payload); (err != nil) != tt.wantErr {
+				t.Errorf("outputUpdateResult() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

internal/cmd/load-balancer/list/list.go

@@ -159,8 +159,8 @@ func outputResult(p *print.Printer, outputFormat string, loadBalancers []loadbal
 				utils.PtrString(l.Name),
 				utils.PtrString(l.Status),
 				externalAdress,
-				len(*l.Listeners),
-				len(*l.TargetPools),
+				len(utils.PtrString(l.Listeners)),
+				len(utils.PtrString(l.TargetPools)),
 			)
 		}
 		err := table.Display(p)

internal/cmd/load-balancer/list/list_test.go

@@ -4,13 +4,12 @@ import (
 	"context"
 	"testing"
 
-	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
-	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
-	"github.com/stackitcloud/stackit-cli/internal/pkg/utils"
-
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
+	"github.com/stackitcloud/stackit-cli/internal/pkg/utils"
 	"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer"
 )
 
@@ -183,3 +182,37 @@ func TestBuildRequest(t *testing.T) {
 		})
 	}
 }
+
+func TestOutputResult(t *testing.T) {
+	type args struct {
+		outputFormat  string
+		loadBalancers []loadbalancer.LoadBalancer
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name:    "empty",
+			args:    args{},
+			wantErr: false,
+		},
+		{
+			name: "empty loadbalancer in loadbalancers slice",
+			args: args{
+				loadBalancers: []loadbalancer.LoadBalancer{{}},
+			},
+			wantErr: false,
+		},
+	}
+	p := print.NewPrinter()
+	p.Cmd = NewCmd(p)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := outputResult(p, tt.args.outputFormat, tt.args.loadBalancers); (err != nil) != tt.wantErr {
+				t.Errorf("outputResult() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

internal/cmd/load-balancer/observability-credentials/add/add.go

@@ -91,7 +91,7 @@ func NewCmd(p *print.Printer) *cobra.Command {
 				return fmt.Errorf("add Load Balancer observability credentials: %w", err)
 			}
 
-			return outputResult(p, model, projectLabel, resp)
+			return outputResult(p, model.OutputFormat, projectLabel, resp)
 		},
 	}
 	configureFlags(cmd)
@@ -144,12 +144,12 @@ func buildRequest(ctx context.Context, model *inputModel, apiClient *loadbalance
 	return req
 }
 
-func outputResult(p *print.Printer, model *inputModel, projectLabel string, resp *loadbalancer.CreateCredentialsResponse) error {
-	if resp.Credential == nil {
+func outputResult(p *print.Printer, outputFormat, projectLabel string, resp *loadbalancer.CreateCredentialsResponse) error {
+	if resp == nil || resp.Credential == nil {
 		return fmt.Errorf("nil observability credentials response")
 	}
 
-	switch model.OutputFormat {
+	switch outputFormat {
 	case print.JSONOutputFormat:
 		details, err := json.MarshalIndent(resp, "", "  ")
 		if err != nil {

internal/cmd/load-balancer/observability-credentials/add/add_test.go

@@ -4,14 +4,13 @@ import (
 	"context"
 	"testing"
 
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/google/uuid"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/globalflags"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/print"
 	"github.com/stackitcloud/stackit-cli/internal/pkg/utils"
 	"github.com/stackitcloud/stackit-sdk-go/services/loadbalancer"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-	"github.com/google/uuid"
 )
 
 var projectIdFlag = globalflags.ProjectIdFlag
@@ -193,3 +192,45 @@ func TestBuildRequest(t *testing.T) {
 		})
 	}
 }
+
+func TestOutputResult(t *testing.T) {
+	type args struct {
+		outputFormat string
+		projectLabel string
+		resp         *loadbalancer.CreateCredentialsResponse
+	}
+	tests := []struct {
+		name    string
+		args    args
+		wantErr bool
+	}{
+		{
+			name:    "empty",
+			args:    args{},
+			wantErr: true,
+		},
+		{
+			name: "credentials response with empty Credential",
+			args: args{
+				resp: &loadbalancer.CreateCredentialsResponse{},
+			},
+			wantErr: true,
+		},
+		{
+			name: "only credentials response as argument",
+			args: args{
+				resp: &loadbalancer.CreateCredentialsResponse{Credential: &loadbalancer.CredentialsResponse{}},
+			},
+			wantErr: false,
+		},
+	}
+	p := print.NewPrinter()
+	p.Cmd = NewCmd(p)
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if err := outputResult(p, tt.args.outputFormat, tt.args.projectLabel, tt.args.resp); (err != nil) != tt.wantErr {
+				t.Errorf("outputResult() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}

internal/cmd/load-balancer/observability-credentials/describe/describe.go

@@ -115,8 +115,7 @@ func outputResult(p *print.Printer, outputFormat string, credentials *loadbalanc
 		return nil
 	default:
 		if credentials == nil || credentials.Credential == nil {
-			p.Info("No credentials found")
-			return nil
+			return fmt.Errorf("credentials response is empty")
 		}
 
 		table := tables.NewTable()