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.
186 lines
6.1 KiB
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)
|
|
}
|
|
}
|
|
}
|