execenv_test.go

package execenv_test

import (
	"errors"
	"os"
	"os/exec"
	"strings"
	"testing"

	"github.com/sudosylabs/execenv"
	"github.com/sudosylabs/execenv/memory"
)

func TestLdflagsOverwriteStamp(t *testing.T) {
	t.Parallel()
	dir := t.TempDir()
	bin := dir + "/execenvctl"
	ld := "-X github.com/sudosylabs/execenv.Release=1.2.3 -X github.com/sudosylabs/execenv.Build=9 -X github.com/sudosylabs/execenv.Tag=v1.2.3"
	cmd := exec.Command("go", "build", "-ldflags", ld, "-o", bin, "./cmd/execenvctl")
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("build: %v\n%s", err, out)
	}
	out, err := exec.Command(bin, "--version").CombinedOutput()
	if err != nil {
		t.Fatalf("--version: %v\n%s", err, out)
	}
	got := string(out)
	for _, want := range []string{"version=1.2.3", "build=9", "tag=v1.2.3"} {
		if !strings.Contains(got, want) {
			t.Fatalf("--version = %q, missing %q", got, want)
		}
	}
}

func TestRootPackageStdlibOnly(t *testing.T) {
	t.Parallel()
	cmd := exec.Command("go", "list", "-f", "{{ join .Imports \"\\n\" }}", ".")
	out, err := cmd.Output()
	if err != nil {
		t.Fatal(err)
	}
	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
		if line == "" {
			continue
		}
		if strings.Contains(line, ".") {
			t.Fatalf("root package imports %q; want standard library only", line)
		}
	}
}

func TestPublicSurfaceOmitsHypervisorNames(t *testing.T) {
	t.Parallel()
	banned := []string{"Firecracker", "firecracker", "jailer", "Jailer", "KVM", "kvm", "vsock"}
	roots := []string{"doc.go", "execenv.go", "errors.go", "id.go", "isolated.go", "tree.go", "build.go"}
	for _, name := range roots {
		body, err := os.ReadFile(name)
		if err != nil {
			t.Fatal(err)
		}
		text := string(body)
		for _, word := range banned {
			if strings.Contains(text, word) {
				t.Fatalf("%s contains %q", name, word)
			}
		}
	}
}

func TestValidateSpec(t *testing.T) {
	t.Parallel()
	err := execenv.ValidateSpec(execenv.Spec{ID: "grant-1", Image: "default"})
	if err != nil {
		t.Fatalf("ValidateSpec() error = %v", err)
	}
	err = execenv.ValidateSpec(execenv.Spec{ID: "bad id", Image: "default"})
	if !errors.Is(err, execenv.ErrInvalid) {
		t.Fatalf("ValidateSpec() error = %v, want ErrInvalid", err)
	}
}

func TestRequireIsolatedRejectsMemory(t *testing.T) {
	t.Parallel()
	host, err := memory.New(memory.Config{Images: []execenv.Image{"default"}})
	if err != nil {
		t.Fatal(err)
	}
	if host.Capabilities().Isolated {
		t.Fatal("memory Capabilities.Isolated = true")
	}
	if err := execenv.RequireIsolated(host); !errors.Is(err, execenv.ErrUnavailable) {
		t.Fatalf("RequireIsolated() error = %v, want ErrUnavailable", err)
	}
}

func TestOpErrorPreservesSentinel(t *testing.T) {
	t.Parallel()
	err := execenv.Error("ensure", execenv.ErrCapacity)
	if !errors.Is(err, execenv.ErrCapacity) {
		t.Fatalf("Error() = %v, want ErrCapacity", err)
	}
	if err.Error() == "ping" {
		t.Fatal("error text unexpectedly contains payload")
	}
}

func TestUnusableHost(t *testing.T) {
	t.Parallel()
	host, err := memory.New(memory.Config{
		Images:   []execenv.Image{"default"},
		Unusable: true,
	})
	if err != nil {
		t.Fatal(err)
	}
	report, err := host.Ready(t.Context())
	if err != nil {
		t.Fatal(err)
	}
	if report.Usable {
		t.Fatal("Ready() Usable = true")
	}
	_, err = host.Ensure(t.Context(), execenv.Spec{ID: "grant-1", Image: "default"})
	if !errors.Is(err, execenv.ErrUnavailable) {
		t.Fatalf("Ensure() error = %v, want ErrUnavailable", err)
	}
}