mc-gateway/plugin/api/api_test.go

package api

import (
	"net"
	"sync"
	"testing"
)

func TestAbstractPluginDefaults(t *testing.T) {
	var plugin AbstractPlugin

	if err := plugin.Init(nil); err != nil {
		t.Fatalf("Init() error = %v", err)
	}
	if err := plugin.Destroy(); err != nil {
		t.Fatalf("Destroy() error = %v", err)
	}
	if err := plugin.ReloadConfig(struct{}{}); err != nil {
		t.Fatalf("ReloadConfig() error = %v", err)
	}
	if cfg := plugin.NewConfigObj(); cfg == nil {
		t.Fatal("NewConfigObj() returned nil")
	}
}

func TestHookTypesAndHandlers(t *testing.T) {
	if got := HookUpstream.Key(); got != "upstream" {
		t.Fatalf("HookUpstream.Key() = %q, want upstream", got)
	}
	if got := HookUpstream.AsAny().Key(); got != HookUpstream.Key() {
		t.Fatalf("AsAny().Key() = %q, want %q", got, HookUpstream.Key())
	}

	acceptor := func(net.Conn, string) bool { return true }
	handler := func(net.Conn, string) (net.Conn, error) { return nil, nil }
	hookHandler := HookHandler[
		func(net.Conn, string) bool,
		func(net.Conn, string) (net.Conn, error),
	]{acceptor: acceptor, handler: handler}

	if hookHandler.Acceptor() == nil {
		t.Fatal("Acceptor() returned nil")
	}
	if hookHandler.Handler() == nil {
		t.Fatal("Handler() returned nil")
	}
}

func TestRegisterHookHandler(t *testing.T) {
	gateway := &recordingGateway{hooks: make(map[string]any)}
	acceptor := func(net.Conn, string) bool { return true }
	handler := func(net.Conn, string) (net.Conn, error) { return nil, nil }

	if err := RegisterHookHandler(gateway, HookUpstream, acceptor, handler); err != nil {
		t.Fatalf("RegisterHookHandler() error = %v", err)
	}

	rawHandler, ok := gateway.hooks[HookUpstream.Key()]
	if !ok {
		t.Fatalf("hook %q was not registered", HookUpstream.Key())
	}
	registered, ok := rawHandler.(HookHandler[
		func(net.Conn, string) bool,
		func(net.Conn, string) (net.Conn, error),
	])
	if !ok {
		t.Fatalf("registered hook type = %T", rawHandler)
	}
	if registered.Acceptor() == nil {
		t.Fatal("registered acceptor is nil")
	}
	if registered.Handler() == nil {
		t.Fatal("registered handler is nil")
	}
}

type recordingGateway struct {
	hooks map[string]any
	wg    sync.WaitGroup
}

func (g *recordingGateway) HandleConn(net.Conn) {}

func (g *recordingGateway) ExitWaitGroup() *sync.WaitGroup {
	return &g.wg
}

func (g *recordingGateway) Hook(hook string, handler any) error {
	g.hooks[hook] = handler
	return nil
}