You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/agent/internal/hypervisor/delete_test.go

186 lines
6.1 KiB
Go

package hypervisor
import (
"context"
"errors"
"fmt"
"strings"
"sync"
"testing"
)
func TestFakeDeleteDomainRequiresInactiveAndProvesAbsence(t *testing.T) {
backend := NewFakeBackend(DefaultCapabilitySnapshot())
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
UUID: testUUID,
XML: testDomainXML(testUUID),
}); err != nil {
t.Fatal(err)
}
preflight, err := backend.InspectDomainForDeletion(context.Background(), testUUID)
if err != nil {
t.Fatal(err)
}
if !preflight.Present || preflight.Active || preflight.State != StateShutoff || preflight.XMLHash == "" {
t.Fatalf("preflight = %+v", preflight)
}
result, err := backend.DeleteDomain(context.Background(), strings.ToUpper(testUUID))
if err != nil {
t.Fatalf("DeleteDomain() error = %v", err)
}
if result.UUID != testUUID || !result.Existed || !result.Removed || result.AlreadyAbsent ||
result.StorageRemoved || result.NetworkChanged || result.XMLHash != preflight.XMLHash {
t.Fatalf("delete result = %+v", result)
}
after, err := backend.InspectDomainForDeletion(context.Background(), testUUID)
if err != nil {
t.Fatal(err)
}
if after.Present || after.UUID != testUUID {
t.Fatalf("post-delete observation = %+v", after)
}
if _, err := backend.ReadDomainXML(context.Background(), testUUID); !errors.Is(err, ErrDomainNotFound) {
t.Fatalf("ReadDomainXML() after delete = %v, want ErrDomainNotFound", err)
}
// A repeated request is an idempotent, already-absent observation; it does
// not resurrect or touch any unrelated host resource.
repeated, err := backend.DeleteDomain(context.Background(), testUUID)
if err != nil {
t.Fatalf("repeated DeleteDomain() error = %v", err)
}
if !repeated.AlreadyAbsent || !repeated.Removed || repeated.Existed {
t.Fatalf("repeated delete result = %+v", repeated)
}
}
func TestFakeDeleteDomainRejectsActiveWithoutRemovingDefinition(t *testing.T) {
backend := NewFakeBackend(DefaultCapabilitySnapshot())
if _, err := backend.DefineDomain(context.Background(), DefineRequest{UUID: testUUID, XML: testDomainXML(testUUID)}); err != nil {
t.Fatal(err)
}
if _, err := backend.PowerDomain(context.Background(), testUUID, PowerActionStart); err != nil {
t.Fatal(err)
}
result, err := backend.DeleteDomain(context.Background(), testUUID)
if !errors.Is(err, ErrDomainActive) {
t.Fatalf("DeleteDomain() error = %v, want ErrDomainActive", err)
}
if result.Removed || !result.Existed || result.StateBefore != StateRunning {
t.Fatalf("active delete result = %+v", result)
}
observation, err := backend.InspectDomainForDeletion(context.Background(), testUUID)
if err != nil || !observation.Present || !observation.Active {
t.Fatalf("active definition after rejected delete = %+v, err=%v", observation, err)
}
}
type deleteRecordingRunner struct {
mu sync.Mutex
commands [][]string
present bool
state []byte
readbackErr error
undefineErr error
returnNotFound bool
}
func (r *deleteRecordingRunner) Run(_ context.Context, args ...string) ([]byte, error) {
r.mu.Lock()
defer r.mu.Unlock()
r.commands = append(r.commands, append([]string(nil), args...))
if len(args) < 3 {
return nil, fmt.Errorf("missing virsh command")
}
switch args[2] {
case "dumpxml":
if !r.present || r.returnNotFound {
if !r.present && r.readbackErr != nil {
return nil, r.readbackErr
}
return nil, ErrDomainNotFound
}
return []byte(`<domain><uuid>` + testUUID + `</uuid><os><type>hvm</type></os></domain>`), nil
case "domstate":
if !r.present {
return nil, ErrDomainNotFound
}
return append([]byte(nil), r.state...), nil
case "undefine":
if r.undefineErr != nil {
return nil, r.undefineErr
}
r.present = false
return []byte("undefined"), nil
default:
return nil, fmt.Errorf("unexpected command %q", args[2])
}
}
func TestVirshDeleteDomainUsesCanonicalUndefineAndAbsenceReadback(t *testing.T) {
runner := &deleteRecordingRunner{present: true, state: []byte("shut off\n")}
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
if err != nil {
t.Fatal(err)
}
result, err := backend.DeleteDomain(context.Background(), strings.ToUpper(testUUID))
if err != nil {
t.Fatalf("DeleteDomain() error = %v", err)
}
if !result.Existed || !result.Removed || result.StorageRemoved || result.NetworkChanged {
t.Fatalf("result = %+v", result)
}
runner.mu.Lock()
commands := append([][]string(nil), runner.commands...)
runner.mu.Unlock()
want := [][]string{
{"-c", "qemu:///system", "dumpxml", "--inactive", testUUID},
{"-c", "qemu:///system", "domstate", "--domain", testUUID},
{"-c", "qemu:///system", "undefine", "--domain", testUUID},
{"-c", "qemu:///system", "dumpxml", "--inactive", testUUID},
}
if len(commands) != len(want) {
t.Fatalf("commands = %+v, want %+v", commands, want)
}
for i := range want {
if strings.Join(commands[i], "\x00") != strings.Join(want[i], "\x00") {
t.Fatalf("command[%d] = %+v, want %+v", i, commands[i], want[i])
}
}
}
func TestVirshDeleteDomainLeavesUncertainWhenAbsenceReadbackFails(t *testing.T) {
runner := &deleteRecordingRunner{
present: true,
state: []byte("shut off\n"),
readbackErr: errors.New("transport lost"),
}
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
if err != nil {
t.Fatal(err)
}
result, err := backend.DeleteDomain(context.Background(), testUUID)
if !errors.Is(err, ErrDeleteReadbackMismatch) {
t.Fatalf("DeleteDomain() error = %v, want ErrDeleteReadbackMismatch", err)
}
if result.Removed {
t.Fatalf("ambiguous delete was reported removed: %+v", result)
}
}
func TestVirshMissingDiagnosticClassifierIsNarrow(t *testing.T) {
if !virshReportsMissingDomain([]byte("error: Domain not found: no domain with matching uuid '" + testUUID + "'")) {
t.Fatal("canonical UUID absence diagnostic was not recognized")
}
for _, diagnostic := range []string{
"error: domain not found while contacting storage",
"error: no domain with matching name 'vm'",
"transport failed: domain not found",
} {
if virshReportsMissingDomain([]byte(diagnostic)) {
t.Fatalf("unrelated diagnostic was classified as UUID absence: %q", diagnostic)
}
}
}