package api import ( "context" "fmt" "io" "net/http" "net/http/httptest" "strings" "testing" "droboticflow/internal/domain" "droboticflow/internal/store" ) type deletionReadTracker struct { io.Reader read bool } func (b *deletionReadTracker) Read(p []byte) (int, error) { b.read = true; return b.Reader.Read(p) } func (*deletionReadTracker) Close() error { return nil } type deletionReadOrderStore struct { store.Store body *deletionReadTracker t *testing.T } func (s deletionReadOrderStore) GetProjectDeletion(context.Context, string) (*domain.ProjectDeletionTask, error) { if !s.body.read { s.t.Fatal("database work ran before reading confirmation body") } return nil, fmt.Errorf("stop before executing any deletion") } func TestProjectDeletionReadsBodyBeforeDatabaseWork(t *testing.T) { body := &deletionReadTracker{Reader: strings.NewReader(`{"confirmationName":"sl","reason":"test","digest":"x","stopRunning":true}`)} request := httptest.NewRequest(http.MethodDelete, "/api/projects/test", nil) request.Body = body recorder := httptest.NewRecorder() s := &server{store: deletionReadOrderStore{body: body, t: t}} s.startProjectDeletion(recorder, request, "test", "task") if recorder.Code != 500 { t.Fatal(recorder.Code, recorder.Body.String()) } } type deletionTimeoutBody struct{} func (deletionTimeoutBody) Read([]byte) (int, error) { return 0, deletionReadTimeout{} } func (deletionTimeoutBody) Close() error { return nil } type deletionReadTimeout struct{} func (deletionReadTimeout) Error() string { return "read deadline exceeded" } func (deletionReadTimeout) Timeout() bool { return true } func (deletionReadTimeout) Temporary() bool { return true } func TestProjectDeletionBodyErrorsAreSpecific(t *testing.T) { for _, tc := range []struct { name string body io.ReadCloser status int code string }{ {"timeout", deletionTimeoutBody{}, 408, "deletion_body_timeout"}, {"empty", io.NopCloser(strings.NewReader("")), 400, "empty_deletion_body"}, {"malformed", io.NopCloser(strings.NewReader("{")), 400, "invalid_deletion_body"}, {"multiple", io.NopCloser(strings.NewReader("{} {}")), 400, "invalid_deletion_body"}, {"large", io.NopCloser(strings.NewReader(`{"reason":"` + strings.Repeat("x", 65536) + `"}`)), 413, "deletion_body_too_large"}, } { t.Run(tc.name, func(t *testing.T) { r := httptest.NewRequest("DELETE", "/", nil) r.Body = tc.body w := httptest.NewRecorder() var input projectDeletionInput if decodeProjectDeletionInput(w, r, &input) || w.Code != tc.status || !strings.Contains(w.Body.String(), tc.code) { t.Fatal(w.Code, w.Body.String()) } }) } } type deletionCountStore struct { store.Store captureQueries int } func (s *deletionCountStore) ListCaptureRecords(ctx context.Context, org, w string, limit int) ([]domain.CaptureRecord, error) { s.captureQueries++ return s.Store.ListCaptureRecords(ctx, org, w, limit) } func TestProjectDeletionLoadsCaptureReferencesOnce(t *testing.T) { db := &deletionCountStore{Store: store.NewMemoryStore()} s := &server{store: db} plan := domain.ProjectDeletionPlan{OrganizationID: "org", ProjectID: "project"} for i := 0; i < 1634; i++ { id := fmt.Sprintf("run-%d", i) plan.Targets = append(plan.Targets, domain.ProjectDeletionTarget{Kind: "bos", RunID: id, Bucket: "b", Prefix: "system/runs/" + id}) } if e := s.validateDeletionReferences(context.Background(), plan); e != nil { t.Fatal(e) } if db.captureQueries != 1 { t.Fatalf("1634 targets made %d Capture queries", db.captureQueries) } }