droboticflow/internal/api/project_deletion_request_test.go

110 lines
3.5 KiB
Go

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)
}
}