banger/internal/daemon/kernels_test.go

package daemon

import (
	"context"
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"banger/internal/api"
	"banger/internal/kernelcat"
	"banger/internal/paths"
	"banger/internal/rpc"
)

func seedKernelEntry(t *testing.T, kernelsDir, name string) {
	t.Helper()
	entry := kernelcat.Entry{
		Name:          name,
		Distro:        "void",
		Arch:          "x86_64",
		KernelVersion: "6.12.0",
		Source:        "test",
	}
	if err := kernelcat.WriteLocal(kernelsDir, entry); err != nil {
		t.Fatalf("seed WriteLocal: %v", err)
	}
	if err := os.WriteFile(filepath.Join(kernelsDir, name, "vmlinux"), []byte("kernel-bytes"), 0o644); err != nil {
		t.Fatalf("seed vmlinux: %v", err)
	}
}

func TestKernelListReturnsSeededEntries(t *testing.T) {
	kernelsDir := t.TempDir()
	seedKernelEntry(t, kernelsDir, "void-6.12")
	seedKernelEntry(t, kernelsDir, "alpine-3.23")

	d := &Daemon{layout: paths.Layout{KernelsDir: kernelsDir}}
	result, err := d.KernelList(context.Background())
	if err != nil {
		t.Fatalf("KernelList: %v", err)
	}
	if len(result.Entries) != 2 {
		t.Fatalf("entries = %d, want 2", len(result.Entries))
	}
	// sorted alphabetically by kernelcat
	if result.Entries[0].Name != "alpine-3.23" || result.Entries[1].Name != "void-6.12" {
		t.Fatalf("entries order = %+v", result.Entries)
	}
	if result.Entries[0].KernelPath == "" || !strings.HasSuffix(result.Entries[0].KernelPath, "vmlinux") {
		t.Fatalf("KernelPath not populated: %+v", result.Entries[0])
	}
}

func TestKernelShowAndDeleteThroughDispatch(t *testing.T) {
	kernelsDir := t.TempDir()
	seedKernelEntry(t, kernelsDir, "void-6.12")

	d := &Daemon{layout: paths.Layout{KernelsDir: kernelsDir}}

	showParams, _ := json.Marshal(api.KernelRefParams{Name: "void-6.12"})
	resp := d.dispatch(context.Background(), rpc.Request{Version: rpc.Version, Method: "kernel.show", Params: showParams})
	if !resp.OK {
		t.Fatalf("kernel.show dispatch failed: %+v", resp)
	}
	var show api.KernelShowResult
	if err := json.Unmarshal(resp.Result, &show); err != nil {
		t.Fatalf("unmarshal show: %v", err)
	}
	if show.Entry.Name != "void-6.12" || show.Entry.Distro != "void" {
		t.Fatalf("show.Entry = %+v", show.Entry)
	}

	delParams, _ := json.Marshal(api.KernelRefParams{Name: "void-6.12"})
	del := d.dispatch(context.Background(), rpc.Request{Version: rpc.Version, Method: "kernel.delete", Params: delParams})
	if !del.OK {
		t.Fatalf("kernel.delete dispatch failed: %+v", del)
	}

	if _, err := kernelcat.ReadLocal(kernelsDir, "void-6.12"); !os.IsNotExist(err) {
		t.Fatalf("entry still present after delete: err=%v", err)
	}
}

func TestKernelShowMissingEntry(t *testing.T) {
	d := &Daemon{layout: paths.Layout{KernelsDir: t.TempDir()}}
	_, err := d.KernelShow(context.Background(), "nope")
	if err == nil || !strings.Contains(err.Error(), "not found") {
		t.Fatalf("KernelShow missing: err=%v", err)
	}
}

func TestKernelDeleteRejectsInvalidName(t *testing.T) {
	d := &Daemon{layout: paths.Layout{KernelsDir: t.TempDir()}}
	if err := d.KernelDelete(context.Background(), "../escape"); err == nil {
		t.Fatalf("KernelDelete should reject traversal")
	}
}

func TestRegisterImageResolvesKernelRef(t *testing.T) {
	kernelsDir := t.TempDir()
	seedKernelEntry(t, kernelsDir, "void-6.12")

	rootfs := filepath.Join(t.TempDir(), "rootfs.ext4")
	if err := os.WriteFile(rootfs, []byte("rootfs"), 0o644); err != nil {
		t.Fatalf("write rootfs: %v", err)
	}

	d := &Daemon{
		layout: paths.Layout{KernelsDir: kernelsDir},
		store:  openDaemonStore(t),
	}

	image, err := d.RegisterImage(context.Background(), api.ImageRegisterParams{
		Name:       "testbox",
		RootfsPath: rootfs,
		KernelRef:  "void-6.12",
	})
	if err != nil {
		t.Fatalf("RegisterImage: %v", err)
	}
	want := filepath.Join(kernelsDir, "void-6.12", "vmlinux")
	if image.KernelPath != want {
		t.Fatalf("image.KernelPath = %q, want %q", image.KernelPath, want)
	}
}

func TestRegisterImageRejectsKernelRefAndPath(t *testing.T) {
	kernelsDir := t.TempDir()
	seedKernelEntry(t, kernelsDir, "void-6.12")
	rootfs := filepath.Join(t.TempDir(), "rootfs.ext4")
	if err := os.WriteFile(rootfs, []byte("rootfs"), 0o644); err != nil {
		t.Fatal(err)
	}

	d := &Daemon{
		layout: paths.Layout{KernelsDir: kernelsDir},
		store:  openDaemonStore(t),
	}
	_, err := d.RegisterImage(context.Background(), api.ImageRegisterParams{
		Name:       "testbox",
		RootfsPath: rootfs,
		KernelRef:  "void-6.12",
		KernelPath: "/some/other/vmlinux",
	})
	if err == nil || !strings.Contains(err.Error(), "mutually exclusive") {
		t.Fatalf("RegisterImage kernel-ref+kernel: err=%v, want mutually-exclusive error", err)
	}
}

func TestRegisterImageMissingKernelRef(t *testing.T) {
	rootfs := filepath.Join(t.TempDir(), "rootfs.ext4")
	if err := os.WriteFile(rootfs, []byte("rootfs"), 0o644); err != nil {
		t.Fatal(err)
	}
	d := &Daemon{
		layout: paths.Layout{KernelsDir: t.TempDir()},
		store:  openDaemonStore(t),
	}
	_, err := d.RegisterImage(context.Background(), api.ImageRegisterParams{
		Name:       "testbox",
		RootfsPath: rootfs,
		KernelRef:  "never-imported",
	})
	if err == nil || !strings.Contains(err.Error(), "not found in catalog") {
		t.Fatalf("RegisterImage missing kernel-ref: err=%v", err)
	}
}