add tests for PostCluster

Signed-off-by: Eric Pickard <piceri@github.com>

Author: piceri

pkg/deploymentrecord/client_test.go

@@ -728,3 +728,167 @@ func TestPostOneRespectsRetryAfterAcrossGoroutines(t *testing.T) {
 	}
 	wg.Wait()
 }
+
+func TestPostCluster(t *testing.T) {
+	tests := []struct {
+		name                string
+		records             []*DeploymentRecord
+		handler             http.HandlerFunc
+		wantErr             bool
+		errType             any
+		errContain          string
+		wantBody            bool
+		wantOk              float64
+		wantUnknownArtifact float64
+		wantSoftFail        float64
+		wantHardFail        float64
+		wantClientError     float64
+	}{
+		{
+			name:    "empty records returns nil",
+			records: []*DeploymentRecord{},
+			handler: func(_ http.ResponseWriter, _ *http.Request) {
+				t.Fatal("server should not be called with empty records")
+			},
+		},
+		{
+			name:    "success on 207 returns body",
+			records: []*DeploymentRecord{testRecord()},
+			handler: func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusMultiStatus)
+				_, _ = w.Write([]byte(`{"total_count":1,"deployment_records":[],"errors":[]}`))
+			},
+			wantBody: true,
+			wantOk:   1,
+		},
+		{
+			name:    "404 returns ClusterNoRepositoriesError",
+			records: []*DeploymentRecord{testRecord()},
+			handler: func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusNotFound)
+			},
+			wantErr:             true,
+			errType:             &ClusterNoRepositoriesError{},
+			wantUnknownArtifact: 1,
+		},
+		{
+			name:    "400 returns client error",
+			records: []*DeploymentRecord{testRecord()},
+			handler: func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusBadRequest)
+				_, _ = w.Write([]byte("bad request"))
+			},
+			wantErr:         true,
+			errContain:      "client error",
+			wantClientError: 1,
+		},
+		{
+			name:    "500 retries exhausted returns error",
+			records: []*DeploymentRecord{testRecord()},
+			handler: func(w http.ResponseWriter, _ *http.Request) {
+				w.WriteHeader(http.StatusInternalServerError)
+			},
+			wantErr:      true,
+			errContain:   "all retries exhausted",
+			wantSoftFail: 1,
+			wantHardFail: 1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			srv := httptest.NewServer(tt.handler)
+			t.Cleanup(srv.Close)
+
+			client, err := NewClient(srv.URL, "test-org", WithRetries(0))
+			if err != nil {
+				t.Fatalf("failed to create client: %v", err)
+			}
+
+			counters := allCounters()
+			snapshots := make([]float64, len(counters))
+			for i, c := range counters {
+				snapshots[i] = testutil.ToFloat64(c)
+			}
+
+			ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+			t.Cleanup(cancel)
+
+			respBody, err := client.PostCluster(ctx, tt.records, "test-cluster")
+
+			if tt.wantErr {
+				if err == nil {
+					t.Fatal("expected error, got nil")
+				}
+				if tt.errType != nil {
+					switch tt.errType.(type) {
+					case *ClusterNoRepositoriesError:
+						var e *ClusterNoRepositoriesError
+						if !errors.As(err, &e) {
+							t.Errorf("expected ClusterNoRepositoriesError, got %T: %v", err, err)
+						}
+					default:
+						t.Fatalf("unexpected error type in test: %T", tt.errType)
+					}
+				}
+				if tt.errContain != "" && !strings.Contains(err.Error(), tt.errContain) {
+					t.Errorf("error %q should contain %q", err.Error(), tt.errContain)
+				}
+			} else if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+
+			if tt.wantBody && respBody == nil {
+				t.Error("expected non-nil response body")
+			}
+
+			wantDeltas := []float64{
+				tt.wantOk,
+				tt.wantUnknownArtifact,
+				0, // rate limited
+				tt.wantSoftFail,
+				tt.wantHardFail,
+				tt.wantClientError,
+			}
+			names := []string{
+				"PostDeploymentRecordOk",
+				"PostDeploymentRecordUnknownArtifact",
+				"PostDeploymentRecordRateLimited",
+				"PostDeploymentRecordSoftFail",
+				"PostDeploymentRecordHardFail",
+				"PostDeploymentRecordClientError",
+			}
+			for i, c := range counters {
+				got := testutil.ToFloat64(c) - snapshots[i]
+				if got != wantDeltas[i] {
+					t.Errorf("%s delta = %v, want %v", names[i], got, wantDeltas[i])
+				}
+			}
+		})
+	}
+}
+
+func TestPostCluster_URLEscapesCluster(t *testing.T) {
+	var rawPath string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		rawPath = r.URL.RawPath
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte(`{"total_count":0,"deployment_records":[]}`))
+	}))
+	t.Cleanup(srv.Close)
+
+	client, err := NewClient(srv.URL, "test-org", WithRetries(0))
+	if err != nil {
+		t.Fatalf("failed to create client: %v", err)
+	}
+
+	_, err = client.PostCluster(context.Background(), []*DeploymentRecord{testRecord()}, "cluster/with spaces")
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	wantSuffix := "/cluster/cluster%2Fwith%20spaces"
+	if !strings.HasSuffix(rawPath, wantSuffix) {
+		t.Errorf("raw path %q should end with %q", rawPath, wantSuffix)
+	}
+}