package daemon

import (
	"sort"
	"testing"
)

// TestRPCHandlersMatchDocumentedMethods pins the surface of the RPC
// table: adding or removing a method should be an explicit, reviewable
// change. If the keyset drifts and this test isn't updated alongside,
// that's a red flag — either the documented list is stale, or a
// method sneaked in without being discussed.
//
// The expected list is the single source of truth for "methods
// banger speaks." Any production code consulting it (CLI completions,
// docs generator) can grep this test.
func TestRPCHandlersMatchDocumentedMethods(t *testing.T) {
	expected := []string{
		"image.delete",
		"image.list",
		"image.promote",
		"image.pull",
		"image.register",
		"image.show",

		"kernel.catalog",
		"kernel.delete",
		"kernel.import",
		"kernel.list",
		"kernel.pull",
		"kernel.show",

		"ping",
		"shutdown",

		"vm.create",
		"vm.create.begin",
		"vm.create.cancel",
		"vm.create.status",
		"vm.delete",
		"vm.health",
		"vm.kill",
		"vm.list",
		"vm.logs",
		"vm.ping",
		"vm.ports",
		"vm.restart",
		"vm.set",
		"vm.show",
		"vm.ssh",
		"vm.start",
		"vm.stats",
		"vm.stop",

		"vm.workspace.export",
		"vm.workspace.prepare",
	}

	got := make([]string, 0, len(rpcHandlers))
	for name := range rpcHandlers {
		got = append(got, name)
	}
	sort.Strings(got)
	sort.Strings(expected)

	if len(got) != len(expected) {
		t.Fatalf("method count: got %d, want %d\n  got:  %v\n  want: %v", len(got), len(expected), got, expected)
	}
	for i := range expected {
		if got[i] != expected[i] {
			t.Fatalf("method[%d]: got %q, want %q\n  full got:  %v\n  full want: %v", i, got[i], expected[i], got, expected)
		}
	}
}

// TestRPCHandlersAllNonNil catches a silly-but-possible footgun:
// registering a method with a nil function literal.
func TestRPCHandlersAllNonNil(t *testing.T) {
	for name, h := range rpcHandlers {
		if h == nil {
			t.Errorf("rpcHandlers[%q] = nil", name)
		}
	}
}