package api import ( "bytes" "context" "encoding/json" "errors" "net/http" "net/http/httptest" "testing" "g.luoli.live/root/virt/agent/internal/capability" "g.luoli.live/root/virt/agent/internal/config" "g.luoli.live/root/virt/agent/internal/hypervisor" "g.luoli.live/root/virt/agent/internal/operation" ) const deleteTestUUID = "00000000-0000-4000-8000-000000000401" func newDeleteTestServer(t *testing.T, backend hypervisor.Backend) (*Server, *operation.Store) { t.Helper() store := operation.NewMemory() c := config.Defaults() c.AgentID = "host-delete-test" s, err := New(Options{ Config: c, Store: store, Capabilities: capability.BackendProvider{Backend: backend, AgentID: c.AgentID, ProtocolVersion: c.ProtocolVersion}, Backend: backend, HostBackendReady: true, }) if err != nil { t.Fatal(err) } return s, store } func defineDeleteTestDomain(t *testing.T, backend *hypervisor.FakeBackend) { t.Helper() if _, err := backend.DefineDomain(context.Background(), hypervisor.DefineRequest{ UUID: deleteTestUUID, XML: []byte(`` + deleteTestUUID + `hvm`), }); err != nil { t.Fatal(err) } } func deleteOperationBody(id, key string) []byte { return []byte(`{"operation_id":"` + id + `","idempotency_key":"` + key + `","kind":"domain_delete","target":"` + deleteTestUUID + `","payload":{"uuid":"` + deleteTestUUID + `"}}`) } func TestDomainDeleteUndefinesOnlyInactiveDefinitionAndJournalsReadback(t *testing.T) { backend := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot()) defineDeleteTestDomain(t, backend) s, store := newDeleteTestServer(t, backend) operationID := "00000000-0000-4000-8000-000000000402" recorder := httptest.NewRecorder() s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader( deleteOperationBody(operationID, "delete-operation-0402"), ))) if recorder.Code != http.StatusOK { t.Fatalf("status=%d body=%s", recorder.Code, recorder.Body.String()) } var record operation.Record if err := json.Unmarshal(recorder.Body.Bytes(), &record); err != nil { t.Fatal(err) } if record.Status != operation.StatusSucceeded || record.CommitBoundary != "domain_delete_readback_confirmed" { t.Fatalf("record=%+v", record) } var result hypervisor.DomainDeleteResult if err := json.Unmarshal(record.Result, &result); err != nil { t.Fatalf("decode result: %v raw=%s", err, record.Result) } if result.UUID != deleteTestUUID || !result.Existed || !result.Removed || result.AlreadyAbsent || result.StorageRemoved || result.NetworkChanged || result.XMLHash == "" { t.Fatalf("result=%+v", result) } observation, err := backend.InspectDomainForDeletion(context.Background(), deleteTestUUID) if err != nil { t.Fatal(err) } if observation.Present { t.Fatalf("definition remains after successful delete: %+v", observation) } if _, err := store.Get(operationID); err != nil { t.Fatal(err) } } func TestDomainDeleteRejectsActiveDomainBeforeUndefine(t *testing.T) { backend := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot()) defineDeleteTestDomain(t, backend) if _, err := backend.PowerDomain(context.Background(), deleteTestUUID, hypervisor.PowerActionStart); err != nil { t.Fatal(err) } s, store := newDeleteTestServer(t, backend) operationID := "00000000-0000-4000-8000-000000000403" recorder := httptest.NewRecorder() s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader( deleteOperationBody(operationID, "delete-operation-0403"), ))) if recorder.Code != http.StatusUnprocessableEntity { t.Fatalf("status=%d body=%s; want 422", recorder.Code, recorder.Body.String()) } record, err := store.Get(operationID) if err != nil { t.Fatal(err) } if record.Status != operation.StatusFailed || record.ErrorCode != "domain_delete_active" { t.Fatalf("record=%+v", record) } observation, err := backend.InspectDomainForDeletion(context.Background(), deleteTestUUID) if err != nil || !observation.Present || !observation.Active { t.Fatalf("domain changed after active rejection: %+v err=%v", observation, err) } } type deleteCountingBackend struct { *hypervisor.FakeBackend deleteCalls int inspectCalls int } func (b *deleteCountingBackend) DeleteDomain(ctx context.Context, uuid string) (hypervisor.DomainDeleteResult, error) { b.deleteCalls++ return b.FakeBackend.DeleteDomain(ctx, uuid) } func (b *deleteCountingBackend) InspectDomainForDeletion(ctx context.Context, uuid string) (hypervisor.DomainDeletionObservation, error) { b.inspectCalls++ return b.FakeBackend.InspectDomainForDeletion(ctx, uuid) } func TestDomainDeleteReconcileReadsAbsenceWithoutReplayingUndefine(t *testing.T) { base := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot()) defineDeleteTestDomain(t, base) backend := &deleteCountingBackend{FakeBackend: base} store := operation.NewMemory() const operationID = "00000000-0000-4000-8000-000000000404" payload := []byte(`{"uuid":"` + deleteTestUUID + `"}`) journalUncertain(t, store, operationID, "delete-reconcile-0404", "domain_delete", deleteTestUUID, payload) s, _ := newDeleteTestServerWithStore(t, backend, store) first := httptest.NewRecorder() s.Handler().ServeHTTP(first, httptest.NewRequest(http.MethodPost, "/v1/operations/"+operationID+"/reconcile", nil)) if first.Code != http.StatusConflict { t.Fatalf("first reconcile status=%d body=%s; want 409", first.Code, first.Body.String()) } if backend.deleteCalls != 0 || backend.inspectCalls != 1 { t.Fatalf("first reconcile calls delete=%d inspect=%d; undefine must not replay", backend.deleteCalls, backend.inspectCalls) } if _, err := base.DeleteDomain(context.Background(), deleteTestUUID); err != nil { t.Fatal(err) } second := httptest.NewRecorder() s.Handler().ServeHTTP(second, httptest.NewRequest(http.MethodPost, "/v1/operations/"+operationID+"/reconcile", nil)) if second.Code != http.StatusOK { t.Fatalf("second reconcile status=%d body=%s", second.Code, second.Body.String()) } record, err := store.Get(operationID) if err != nil { t.Fatal(err) } if record.Status != operation.StatusSucceeded || record.CommitBoundary != "domain_delete_readback_confirmed" { t.Fatalf("record=%+v", record) } if backend.deleteCalls != 0 || backend.inspectCalls != 2 { t.Fatalf("second reconcile calls delete=%d inspect=%d; want read-only reconcile", backend.deleteCalls, backend.inspectCalls) } } func newDeleteTestServerWithStore(t *testing.T, backend hypervisor.Backend, store *operation.Store) (*Server, *operation.Store) { t.Helper() c := config.Defaults() c.AgentID = "host-delete-reconcile" s, err := New(Options{ Config: c, Store: store, Capabilities: capability.BackendProvider{Backend: backend, AgentID: c.AgentID, ProtocolVersion: c.ProtocolVersion}, Backend: backend, HostBackendReady: true, }) if err != nil { t.Fatal(err) } return s, store } func TestDomainDeleteRejectsExtraPayloadBeforeJournal(t *testing.T) { backend := hypervisor.NewFakeBackend(hypervisor.DefaultCapabilitySnapshot()) s, store := newDeleteTestServer(t, backend) operationID := "00000000-0000-4000-8000-000000000405" body := []byte(`{"operation_id":"` + operationID + `","idempotency_key":"delete-operation-0405","kind":"domain_delete","target":"` + deleteTestUUID + `","payload":{"uuid":"` + deleteTestUUID + `","delete_disks":true}}`) recorder := httptest.NewRecorder() s.Handler().ServeHTTP(recorder, httptest.NewRequest(http.MethodPost, "/v1/operations", bytes.NewReader(body))) if recorder.Code != http.StatusBadRequest { t.Fatalf("status=%d body=%s; want 400", recorder.Code, recorder.Body.String()) } if _, err := store.Get(operationID); !errors.Is(err, operation.ErrNotFound) { t.Fatalf("invalid delete entered journal: %v", err) } }