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.
296 lines
9.5 KiB
Go
296 lines
9.5 KiB
Go
package hypervisor
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
const testUUID = "00000000-0000-4000-8000-000000000001"
|
|
|
|
func testDomainXML(uuid string) []byte {
|
|
return []byte(fmt.Sprintf(`<domain type="kvm"><name>test-vm</name><uuid>%s</uuid><os><type>hvm</type></os><devices/></domain>`, uuid))
|
|
}
|
|
|
|
func TestCanonicalUUID(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
in string
|
|
want string
|
|
err bool
|
|
}{
|
|
{name: "lowercase", in: testUUID, want: testUUID},
|
|
{name: "uppercase is canonicalized", in: strings.ToUpper(testUUID), want: testUUID},
|
|
{name: "trimmed", in: " " + testUUID + "\n", want: testUUID},
|
|
{name: "bad length", in: "00000000-0000-4000-8000-00000000000", err: true},
|
|
{name: "bad separator", in: "000000000000-4000-8000-000000000001", err: true},
|
|
{name: "bad hex", in: "00000000-0000-4000-8000-00000000000g", err: true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
got, err := CanonicalUUID(tt.in)
|
|
if tt.err {
|
|
if !errors.Is(err, ErrInvalidUUID) {
|
|
t.Fatalf("CanonicalUUID() error = %v, want ErrInvalidUUID", err)
|
|
}
|
|
return
|
|
}
|
|
if err != nil || got != tt.want {
|
|
t.Fatalf("CanonicalUUID() = %q, err=%v, want %q", got, err, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCheckEFIQ35NoSecureBoot(t *testing.T) {
|
|
base := DefaultCapabilitySnapshot()
|
|
if err := CheckEFIQ35NoSecureBoot(base); err != nil {
|
|
t.Fatalf("default capability policy rejected: %v", err)
|
|
}
|
|
for name, mutate := range map[string]func(*CapabilitySnapshot){
|
|
"efi": func(value *CapabilitySnapshot) { value.UEFI = false },
|
|
"q35": func(value *CapabilitySnapshot) { value.Q35 = false },
|
|
"secure boot": func(value *CapabilitySnapshot) { value.SecureBootDisabled = false },
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
value := base
|
|
mutate(&value)
|
|
if err := CheckEFIQ35NoSecureBoot(value); !errors.Is(err, ErrCapabilityPolicy) {
|
|
t.Fatalf("CheckEFIQ35NoSecureBoot() error = %v, want ErrCapabilityPolicy", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendSelectsFreshNonSecureLoader(t *testing.T) {
|
|
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
|
path, err := backend.PreferredNonSecureLoaderPath(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("PreferredNonSecureLoaderPath() error = %v", err)
|
|
}
|
|
if path != fakeLoaderPath {
|
|
t.Fatalf("loader path = %q, want %q", path, fakeLoaderPath)
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if _, err := backend.PreferredNonSecureLoaderPath(ctx); !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("canceled loader selection error = %v, want context.Canceled", err)
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendDefineAndReadback(t *testing.T) {
|
|
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
|
defined, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: testDomainXML(testUUID),
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("DefineDomain() error = %v", err)
|
|
}
|
|
if defined.UUID != testUUID || defined.Revision != 1 || len(defined.XML) == 0 {
|
|
t.Fatalf("unexpected definition: %+v", defined)
|
|
}
|
|
if err := domainPolicyFromDefinition(defined.XML); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
readback, err := ReadbackDomain(context.Background(), backend, strings.ToUpper(testUUID))
|
|
if err != nil {
|
|
t.Fatalf("ReadbackDomain() error = %v", err)
|
|
}
|
|
if readback.UUID != testUUID || string(readback.XML) != string(defined.XML) {
|
|
t.Fatalf("readback changed definition: got=%+v defined=%+v", readback, defined)
|
|
}
|
|
|
|
// Returned bytes are copies. Mutating them must not alter the backend's
|
|
// read-back state.
|
|
defined.XML[0] = 'X'
|
|
again, err := backend.ReadDomainXML(context.Background(), testUUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !strings.HasPrefix(string(again), "<domain") {
|
|
t.Fatalf("backend XML was aliased through returned bytes: %q", again[:minInt(len(again), 20)])
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendRejectsUUIDMismatchAndConflictingRedefinition(t *testing.T) {
|
|
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
|
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: testDomainXML("00000000-0000-4000-8000-000000000002"),
|
|
}); !errors.Is(err, ErrUUIDMismatch) {
|
|
t.Fatalf("UUID mismatch error = %v, want ErrUUIDMismatch", err)
|
|
}
|
|
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: testDomainXML(testUUID),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
changed := strings.Replace(string(testDomainXML(testUUID)), "test-vm", "other-vm", 1)
|
|
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: []byte(changed),
|
|
}); !errors.Is(err, ErrDomainConflict) {
|
|
t.Fatalf("conflicting redefine error = %v, want ErrDomainConflict", err)
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendDoesNotDefineWhenPlatformPolicyIsUnavailable(t *testing.T) {
|
|
caps := DefaultCapabilitySnapshot()
|
|
caps.SecureBootDisabled = false
|
|
backend := NewFakeBackend(caps)
|
|
if _, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: testDomainXML(testUUID),
|
|
}); !errors.Is(err, ErrCapabilityPolicy) {
|
|
t.Fatalf("DefineDomain() error = %v, want ErrCapabilityPolicy", err)
|
|
}
|
|
if _, err := backend.ReadDomainXML(context.Background(), testUUID); !errors.Is(err, ErrDomainNotFound) {
|
|
t.Fatalf("failed define left a domain behind: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendConcurrentIdempotentDefine(t *testing.T) {
|
|
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
|
const workers = 32
|
|
results := make(chan Definition, workers)
|
|
errs := make(chan error, workers)
|
|
var wait sync.WaitGroup
|
|
wait.Add(workers)
|
|
for i := 0; i < workers; i++ {
|
|
go func() {
|
|
defer wait.Done()
|
|
definition, err := backend.DefineDomain(context.Background(), DefineRequest{
|
|
UUID: testUUID,
|
|
XML: testDomainXML(testUUID),
|
|
})
|
|
if err != nil {
|
|
errs <- err
|
|
return
|
|
}
|
|
results <- definition
|
|
}()
|
|
}
|
|
wait.Wait()
|
|
close(results)
|
|
close(errs)
|
|
for err := range errs {
|
|
t.Fatalf("concurrent define failed: %v", err)
|
|
}
|
|
for definition := range results {
|
|
if definition.UUID != testUUID || definition.Revision != 1 {
|
|
t.Fatalf("concurrent define returned inconsistent definition: %+v", definition)
|
|
}
|
|
}
|
|
readback, err := ReadbackDomain(context.Background(), backend, testUUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if readback.UUID != testUUID {
|
|
t.Fatalf("readback UUID = %q, want %q", readback.UUID, testUUID)
|
|
}
|
|
}
|
|
|
|
func TestFakeBackendContextCancellationAndMissingDomain(t *testing.T) {
|
|
backend := NewFakeBackend(DefaultCapabilitySnapshot())
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
cancel()
|
|
if _, err := backend.Probe(ctx); !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("Probe() error = %v, want context.Canceled", err)
|
|
}
|
|
if _, err := backend.ReadDomainXML(context.Background(), testUUID); !errors.Is(err, ErrDomainNotFound) {
|
|
t.Fatalf("ReadDomainXML() error = %v, want ErrDomainNotFound", err)
|
|
}
|
|
}
|
|
|
|
func TestReadbackDomainRejectsBackendPolicyDrift(t *testing.T) {
|
|
backend := &staticXMLBackend{xml: []byte(fmt.Sprintf(`<domain><uuid>%s</uuid><os><type arch="x86_64" machine="q35">hvm</type><firmware><feature name="secure-boot" enabled="yes"/></firmware></os></domain>`, testUUID))}
|
|
if _, err := ReadbackDomain(context.Background(), backend, testUUID); !errors.Is(err, ErrReadbackMismatch) {
|
|
t.Fatalf("ReadbackDomain() error = %v, want ErrReadbackMismatch", err)
|
|
}
|
|
}
|
|
|
|
type staticXMLBackend struct {
|
|
xml []byte
|
|
}
|
|
|
|
func (s *staticXMLBackend) Probe(context.Context) (ProbeResult, error) {
|
|
return ProbeResult{Capabilities: DefaultCapabilitySnapshot()}, nil
|
|
}
|
|
|
|
func (s *staticXMLBackend) Capabilities(context.Context) (CapabilitySnapshot, error) {
|
|
return DefaultCapabilitySnapshot(), nil
|
|
}
|
|
|
|
func (s *staticXMLBackend) DefineDomain(context.Context, DefineRequest) (Definition, error) {
|
|
return Definition{}, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *staticXMLBackend) ReadDomainXML(context.Context, string) ([]byte, error) {
|
|
return append([]byte(nil), s.xml...), nil
|
|
}
|
|
|
|
func (s *staticXMLBackend) PowerDomain(context.Context, string, PowerAction) (PowerResult, error) {
|
|
return PowerResult{}, errors.New("not implemented")
|
|
}
|
|
|
|
func (s *staticXMLBackend) ReadDomainPowerState(context.Context, string) (DomainPowerState, error) {
|
|
return StateShutoff, nil
|
|
}
|
|
|
|
func (s *staticXMLBackend) InspectDomainForDeletion(ctx context.Context, uuid string) (DomainDeletionObservation, error) {
|
|
data, err := s.ReadDomainXML(ctx, uuid)
|
|
if err != nil {
|
|
return DomainDeletionObservation{}, err
|
|
}
|
|
canonical, err := CanonicalUUID(uuid)
|
|
if err != nil {
|
|
return DomainDeletionObservation{}, err
|
|
}
|
|
observed, err := domainUUID(data)
|
|
if err != nil || observed != canonical {
|
|
return DomainDeletionObservation{}, ErrReadbackMismatch
|
|
}
|
|
return DomainDeletionObservation{
|
|
UUID: canonical,
|
|
Present: true,
|
|
State: StateShutoff,
|
|
XMLHash: hashDomainXML(data),
|
|
ObservedAt: time.Now().UTC(),
|
|
}, nil
|
|
}
|
|
|
|
func (s *staticXMLBackend) DeleteDomain(context.Context, string) (DomainDeleteResult, error) {
|
|
return DomainDeleteResult{}, errors.New("not implemented")
|
|
}
|
|
|
|
func domainPolicyFromDefinition(data []byte) error {
|
|
// This helper intentionally uses the same exported policy validator that a
|
|
// real binding must call after libvirt XMLDesc read-back.
|
|
if err := validateDomainXML(data); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validateDomainXML(data []byte) error {
|
|
// Keep the test package independent from unexported implementation details.
|
|
if !strings.Contains(string(data), `name="secure-boot" enabled="no"`) {
|
|
return fmt.Errorf("normalized definition does not disable Secure Boot: %s", data)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func minInt(a, b int) int {
|
|
if a < b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|