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/power_test.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")
}
}