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.
291 lines
10 KiB
Go
291 lines
10 KiB
Go
package hypervisor
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
func TestParsePowerAction(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
want PowerAction
|
|
err bool
|
|
}{
|
|
{name: "start", input: "start", want: PowerActionStart},
|
|
{name: "shutdown", input: "shutdown", want: PowerActionShutdown},
|
|
{name: "destroy", input: "destroy", want: PowerActionDestroy},
|
|
{name: "reboot", input: "reboot", want: PowerActionReboot},
|
|
{name: "suspend", input: "suspend", want: PowerActionSuspend},
|
|
{name: "resume", input: "resume", want: PowerActionResume},
|
|
{name: "unsupported poweroff", input: "poweroff", err: true},
|
|
{name: "uppercase is not canonical", input: "START", err: true},
|
|
{name: "surrounding whitespace is not canonical", input: " start ", err: true},
|
|
{name: "empty", input: "", err: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := ParsePowerAction(tt.input)
|
|
if tt.err {
|
|
if !errors.Is(err, ErrInvalidPowerAction) {
|
|
t.Fatalf("ParsePowerAction(%q) error = %v, want ErrInvalidPowerAction", tt.input, err)
|
|
}
|
|
return
|
|
}
|
|
if err != nil || got != tt.want {
|
|
t.Fatalf("ParsePowerAction(%q) = %q, err=%v, want %q", tt.input, got, err, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParseDomainPowerState(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input string
|
|
want DomainPowerState
|
|
err bool
|
|
}{
|
|
{name: "running", input: "running\n", want: StateRunning},
|
|
{name: "blocked", input: "blocked", want: StateBlocked},
|
|
{name: "paused", input: "paused", want: StatePaused},
|
|
{name: "shutdown", input: "in shutdown\r\n", want: StateShutdown},
|
|
{name: "shut off", input: "shut off\n", want: StateShutoff},
|
|
{name: "shutoff alias", input: "shutoff", want: StateShutoff},
|
|
{name: "crashed", input: "crashed", want: StateCrashed},
|
|
{name: "pm suspended", input: "pmsuspended", want: StatePMSuspended},
|
|
{name: "no state", input: "no state", want: StateNoState},
|
|
{name: "multiple lines are ambiguous", input: "running\nbooted\n", err: true},
|
|
{name: "unknown", input: "mystery", err: true},
|
|
{name: "empty", input: " \n", err: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := ParseDomainPowerState([]byte(tt.input))
|
|
if tt.err {
|
|
if !errors.Is(err, ErrInvalidPowerState) {
|
|
t.Fatalf("ParseDomainPowerState(%q) error = %v, want ErrInvalidPowerState", tt.input, err)
|
|
}
|
|
return
|
|
}
|
|
if err != nil || got != tt.want {
|
|
t.Fatalf("ParseDomainPowerState(%q) = %q, err=%v, want %q", tt.input, got, err, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendPowerTransitionsAndActionWhitelist(t *testing.T) {
|
|
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
|
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: testDomainXML(testUUID),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
action PowerAction
|
|
want DomainPowerState
|
|
wantErr error
|
|
}{
|
|
{name: "start", action: PowerActionStart, want: StateRunning},
|
|
{name: "suspend", action: PowerActionSuspend, want: StatePaused},
|
|
{name: "resume", action: PowerActionResume, want: StateRunning},
|
|
{name: "shutdown", action: PowerActionShutdown, want: StateShutdown, wantErr: ErrPowerReadbackMismatch},
|
|
{name: "destroy", action: PowerActionDestroy, want: StateShutoff},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result, err := backend.PowerDomain(context.Background(), testUUID, tt.action)
|
|
if tt.wantErr != nil {
|
|
if !errors.Is(err, tt.wantErr) || result.State != tt.want {
|
|
t.Fatalf("PowerDomain() = %+v, err=%v; want state=%s and errors.Is(%v)", result, err, tt.want, tt.wantErr)
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("PowerDomain() error = %v", err)
|
|
}
|
|
if result.UUID != testUUID || result.Action != tt.action || result.State != tt.want {
|
|
t.Fatalf("PowerDomain() = %+v, want uuid=%s action=%s state=%s", result, testUUID, tt.action, tt.want)
|
|
}
|
|
})
|
|
}
|
|
if _, err := backend.PowerDomain(context.Background(), testUUID, PowerAction("poweroff")); !errors.Is(err, ErrInvalidPowerAction) {
|
|
t.Fatalf("unsupported action error = %v, want ErrInvalidPowerAction", err)
|
|
}
|
|
if _, err := backend.PowerDomain(context.Background(), "missing-domain", PowerActionStart); !errors.Is(err, ErrInvalidUUID) {
|
|
t.Fatalf("invalid UUID error = %v, want ErrInvalidUUID", err)
|
|
}
|
|
}
|
|
|
|
func TestShutdownDoesNotTreatTransitionalStateAsPoweredOff(t *testing.T) {
|
|
if PowerActionSatisfied(PowerActionShutdown, StateShutdown) {
|
|
t.Fatal("transitional shutdown state was treated as terminal success")
|
|
}
|
|
if PowerActionReconcileSatisfied(PowerActionShutdown, StateShutdown) {
|
|
t.Fatal("reconcile confirmed transitional shutdown state")
|
|
}
|
|
if !PowerActionSatisfied(PowerActionShutdown, StateShutoff) {
|
|
t.Fatal("terminal shutoff state was not accepted")
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendRejectsInvalidTransitionAndMissingDomain(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, PowerActionResume); !errors.Is(err, ErrPowerActionRejected) {
|
|
t.Fatalf("resume from shutoff error = %v, want ErrPowerActionRejected", err)
|
|
}
|
|
if _, err := backend.PowerDomain(context.Background(), "00000000-0000-4000-8000-000000000099", PowerActionStart); !errors.Is(err, ErrDomainNotFound) {
|
|
t.Fatalf("missing domain error = %v, want ErrDomainNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendReadDomainPowerStateIsReadOnly(t *testing.T) {
|
|
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
|
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: testDomainXML(testUUID),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
state, err := backend.ReadDomainPowerState(context.Background(), testUUID)
|
|
if err != nil {
|
|
t.Fatalf("ReadDomainPowerState() error = %v", err)
|
|
}
|
|
if state != StateShutoff {
|
|
t.Fatalf("initial state = %q, want shutoff", state)
|
|
}
|
|
if _, err := backend.ReadDomainPowerState(context.Background(), testUUID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
// A read must not alter the state or invoke a lifecycle transition.
|
|
state, err = backend.ReadDomainPowerState(context.Background(), testUUID)
|
|
if err != nil || state != StateShutoff {
|
|
t.Fatalf("read-only state = %q, err=%v, want shutoff", state, err)
|
|
}
|
|
if _, err := backend.ReadDomainPowerState(context.Background(), "00000000-0000-4000-8000-000000000099"); !errors.Is(err, ErrDomainNotFound) {
|
|
t.Fatalf("missing domain error = %v, want ErrDomainNotFound", err)
|
|
}
|
|
}
|
|
|
|
type powerRecordingRunner struct {
|
|
mu sync.Mutex
|
|
commands [][]string
|
|
stateOutput []byte
|
|
stateErr error
|
|
actionErr error
|
|
}
|
|
|
|
func (r *powerRecordingRunner) Run(_ context.Context, args ...string) ([]byte, error) {
|
|
r.mu.Lock()
|
|
r.commands = append(r.commands, append([]string(nil), args...))
|
|
r.mu.Unlock()
|
|
if len(args) < 3 {
|
|
return nil, fmt.Errorf("missing virsh command")
|
|
}
|
|
switch args[2] {
|
|
case "domstate":
|
|
return append([]byte(nil), r.stateOutput...), r.stateErr
|
|
case "start", "shutdown", "destroy", "reboot", "suspend", "resume":
|
|
return nil, r.actionErr
|
|
default:
|
|
return nil, fmt.Errorf("unexpected command %q", args[2])
|
|
}
|
|
}
|
|
|
|
func TestVirshPowerUsesFixedArgumentsAndReadback(t *testing.T) {
|
|
runner := &powerRecordingRunner{stateOutput: []byte("running\n")}
|
|
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := backend.PowerDomain(context.Background(), testUUID, PowerActionStart)
|
|
if err != nil {
|
|
t.Fatalf("PowerDomain() error = %v", err)
|
|
}
|
|
if result.UUID != testUUID || result.Action != PowerActionStart || result.State != StateRunning || !result.Active {
|
|
t.Fatalf("PowerDomain() = %+v", result)
|
|
}
|
|
runner.mu.Lock()
|
|
commands := append([][]string(nil), runner.commands...)
|
|
runner.mu.Unlock()
|
|
if len(commands) != 2 {
|
|
t.Fatalf("commands = %+v, want action plus state readback", commands)
|
|
}
|
|
want := [][]string{
|
|
{"-c", "qemu:///system", "start", "--domain", testUUID},
|
|
{"-c", "qemu:///system", "domstate", "--domain", testUUID},
|
|
}
|
|
for index := range want {
|
|
if strings.Join(commands[index], "\x00") != strings.Join(want[index], "\x00") {
|
|
t.Fatalf("command[%d] = %q, want %q", index, commands[index], want[index])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVirshReadDomainPowerStateUsesFixedArguments(t *testing.T) {
|
|
runner := &powerRecordingRunner{stateOutput: []byte("paused\n")}
|
|
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
state, err := backend.ReadDomainPowerState(context.Background(), testUUID)
|
|
if err != nil || state != StatePaused {
|
|
t.Fatalf("ReadDomainPowerState() = %q, err=%v, want paused", state, err)
|
|
}
|
|
runner.mu.Lock()
|
|
commands := append([][]string(nil), runner.commands...)
|
|
runner.mu.Unlock()
|
|
want := [][]string{{"-c", "qemu:///system", "domstate", "--domain", testUUID}}
|
|
if len(commands) != len(want) || strings.Join(commands[0], "\x00") != strings.Join(want[0], "\x00") {
|
|
t.Fatalf("commands = %+v, want %+v", commands, want)
|
|
}
|
|
}
|
|
|
|
func TestVirshPowerRejectsStateReadbackMismatch(t *testing.T) {
|
|
runner := &powerRecordingRunner{stateOutput: []byte("paused\n")}
|
|
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := backend.PowerDomain(context.Background(), testUUID, PowerActionStart)
|
|
if !errors.Is(err, ErrPowerReadbackMismatch) {
|
|
t.Fatalf("error = %v, want ErrPowerReadbackMismatch", err)
|
|
}
|
|
if result.State != StatePaused {
|
|
t.Fatalf("result state = %q, want paused readback", result.State)
|
|
}
|
|
}
|
|
|
|
func TestVirshPowerAcceptsIdempotentStateAfterCommandError(t *testing.T) {
|
|
runner := &powerRecordingRunner{stateOutput: []byte("running\n"), actionErr: errors.New("already running")}
|
|
backend, err := NewVirshBackendWithRunner("qemu:///system", runner)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := backend.PowerDomain(context.Background(), testUUID, PowerActionStart)
|
|
if err != nil {
|
|
t.Fatalf("idempotent start error = %v", err)
|
|
}
|
|
if result.State != StateRunning {
|
|
t.Fatalf("result state = %q, want running", result.State)
|
|
}
|
|
|
|
runner.actionErr = errors.New("transport failure")
|
|
if _, err := backend.PowerDomain(context.Background(), testUUID, PowerActionReboot); err == nil {
|
|
t.Fatal("reboot command failure was incorrectly treated as idempotent")
|
|
}
|
|
}
|