chore: remove dead code

Author: ajbeattie

pkg/deploymentrecord/client.go

@@ -258,50 +258,6 @@ func (c *Client) PostOne(ctx context.Context, record *Record) error {
 	}
 }
 
-// PostCluster sends a full cluster state of records to GitHub deployment
-// records cluster API.
-func (c *Client) PostCluster(ctx context.Context, records []*Record, cluster string) ([]byte, error) {
-	if len(records) == 0 {
-		slog.Debug("Records is empty, skipping")
-		return nil, nil
-	}
-
-	clusterURL := fmt.Sprintf("%s/orgs/%s/artifacts/metadata/deployment-record/cluster/%s", c.baseURL, c.org, url.PathEscape(cluster))
-
-	body, err := buildClusterRequestBody(records)
-	if err != nil {
-		return nil, fmt.Errorf("failed to marshal records: %w", err)
-	}
-
-	respBody, statusCode, lastErr := c.doWithRetry(ctx, http.MethodPost, clusterURL, body)
-
-	var clientErr *ClientError
-	switch {
-	case errors.As(lastErr, &clientErr):
-		dtmetrics.PostDeploymentRecordClientError.Inc()
-		slog.Warn("client error, aborting",
-			"status_code", statusCode,
-			"url", clusterURL,
-			"resp_msg", string(respBody),
-		)
-		return nil, fmt.Errorf("client error: %w", lastErr)
-	case statusCode >= 200 && statusCode < 300:
-		dtmetrics.PostDeploymentRecordOk.Inc()
-		return respBody, nil
-	case statusCode == 404:
-		dtmetrics.PostDeploymentRecordUnknownArtifact.Inc()
-		return nil, &ClusterNoRepositoriesError{err: errors.New("no repositories found")}
-	default:
-		dtmetrics.PostDeploymentRecordHardFail.Inc()
-		slog.Error("all retries exhausted",
-			"count", c.retries,
-			"error", lastErr,
-			"cluster", cluster,
-		)
-		return nil, fmt.Errorf("all retries exhausted: %w", lastErr)
-	}
-}
-
 // CreateClusterJob submits the full cluster state as an async job.
 // Returns the job response (including job ID) and any authorization errors
 // for rejected deployments.

pkg/deploymentrecord/client_test.go

@@ -729,170 +729,6 @@ func TestPostOneRespectsRetryAfterAcrossGoroutines(t *testing.T) {
 	wg.Wait()
 }
 
-func TestPostCluster(t *testing.T) {
-	tests := []struct {
-		name                string
-		records             []*Record
-		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: []*Record{},
-			handler: func(_ http.ResponseWriter, _ *http.Request) {
-				t.Fatal("server should not be called with empty records")
-			},
-		},
-		{
-			name:    "success on 207 returns body",
-			records: []*Record{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: []*Record{testRecord()},
-			handler: func(w http.ResponseWriter, _ *http.Request) {
-				w.WriteHeader(http.StatusNotFound)
-			},
-			wantErr:             true,
-			errType:             &ClusterNoRepositoriesError{},
-			wantUnknownArtifact: 1,
-		},
-		{
-			name:    "400 returns client error",
-			records: []*Record{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: []*Record{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(), []*Record{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)
-	}
-}
-
 func TestCreateClusterJob(t *testing.T) {
 	tests := []struct {
 		name                string