Files
archie/internal/plugin/host_running_test.go
T
sam c835aabb1e feat(plugins): load plugin and secret-engine files without a restart
docs/prds/plugin-settings-live.md: a `plugin-settings` change now applies
live for plugin_dir, module_dir and secret_engine_dir, and a file dropped
into any of those directories loads on the reconciliation tick.

- PluginSettingsKind moves to ApplyMode "live" and joins
  runtimeResourceKinds, so a stored directory change re-layers immediately.
- A reconciler re-runs the directory loads and the layering on the
  apply-status restamp interval. Files are content-hashed, so only new and
  changed files load.
- plugin.Host grows Add and Replace for the running state (Register keeps
  its pre-Start rule), and plugin.LoadFile / secret.Registry.LoadFile are
  the single-file load paths the boot loader and the reconciler share.
- Yaegi cannot unload, so a removed file keeps running and the removal is
  reported through apply status against the live version until restart; a
  clean pass clears it.
- A plugin-settings document that changes skills_dir is refused before the
  layering, since skills_dir has no live consumer.
- applystatus.Reporter.AppliedVersion lets the reconciliation report an
  outcome without resetting the version to zero.
2026-10-02 10:01:35 +10:00

201 lines
6.6 KiB
Go

package plugin_test
import (
"context"
"errors"
"slices"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/plugin"
)
// The running-state operations a live plugin load needs: Add puts one new
// module beside the running set, Replace swaps one module's implementation,
// and neither disturbs a module it is not touching.
// docs/prds/plugin-settings-live.md ("The three registries").
func TestHostAddStartsANewModuleWhileRunning(t *testing.T) {
t.Parallel()
events := &eventLog{}
host := plugin.NewHost()
base := &fakeModule{manifest: validManifest("base"), events: events}
if err := host.Register(base); err != nil {
t.Fatal(err)
}
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
added := &fakeModule{manifest: validManifest("late", "base"), events: events}
if err := host.Add(context.Background(), added); err != nil {
t.Fatalf("Add() error = %v", err)
}
if !host.Has("late") {
t.Fatal("Add() did not register the module")
}
if got, want := events.snapshot(), []string{"start:base", "start:late"}; !slices.Equal(got, want) {
t.Fatalf("lifecycle events = %v, want %v", got, want)
}
// The already-running set is stopped after the added module, since the
// added module came later.
if err := host.Stop(context.Background()); err != nil {
t.Fatal(err)
}
if got, want := events.snapshot(), []string{"start:base", "start:late", "stop:late", "stop:base"}; !slices.Equal(got, want) {
t.Fatalf("lifecycle events = %v, want %v", got, want)
}
}
func TestHostAddRefusesDuplicateAndUnknownDependency(t *testing.T) {
t.Parallel()
host := plugin.NewHost()
if err := host.Register(&fakeModule{manifest: validManifest("base")}); err != nil {
t.Fatal(err)
}
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
if err := host.Add(context.Background(), &fakeModule{manifest: validManifest("base")}); err == nil {
t.Fatal("Add() of a duplicate id succeeded")
}
if err := host.Add(context.Background(), &fakeModule{manifest: validManifest("dependent", "missing")}); err == nil {
t.Fatal("Add() with an unregistered dependency succeeded")
}
if host.Has("dependent") {
t.Error("a refused Add() left the module registered")
}
}
func TestHostAddRollsBackItsOwnStartFailure(t *testing.T) {
t.Parallel()
events := &eventLog{}
host := plugin.NewHost()
if err := host.Register(&fakeModule{manifest: validManifest("base"), events: events}); err != nil {
t.Fatal(err)
}
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
broken := &fakeModule{manifest: validManifest("late"), events: events, startErr: errors.New("boom")}
if err := host.Add(context.Background(), broken); err == nil {
t.Fatal("Add() of a module whose Start fails succeeded")
}
if host.Has("late") {
t.Error("Add() left a module whose Start failed registered")
}
if got, want := events.snapshot(), []string{"start:base", "start:late"}; !slices.Equal(got, want) {
t.Fatalf("lifecycle events = %v, want the base module untouched by the failed add: %v", got, want)
}
}
func TestHostReplaceStopsTheOldAndStartsTheNew(t *testing.T) {
t.Parallel()
events := &eventLog{}
host := plugin.NewHost()
oldManifest := validManifest("module")
oldManifest.Version = "1.0.0"
if err := host.Register(&fakeModule{manifest: oldManifest, events: events}); err != nil {
t.Fatal(err)
}
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
newManifest := validManifest("module")
newManifest.Version = "2.0.0"
if err := host.Replace(context.Background(), &fakeModule{manifest: newManifest, events: events}); err != nil {
t.Fatalf("Replace() error = %v", err)
}
if got, want := events.snapshot(), []string{"start:module", "stop:module", "start:module"}; !slices.Equal(got, want) {
t.Fatalf("lifecycle events = %v, want %v", got, want)
}
manifests := host.Manifests()
if len(manifests) != 1 || manifests[0].Version != "2.0.0" {
t.Fatalf("manifests after replace = %+v, want the new 2.0.0", manifests)
}
}
func TestHostReplaceRestartsTheOldWhenTheNewStartFails(t *testing.T) {
t.Parallel()
events := &eventLog{}
host := plugin.NewHost()
if err := host.Register(&fakeModule{manifest: validManifest("module"), events: events}); err != nil {
t.Fatal(err)
}
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
broken := &fakeModule{manifest: validManifest("module"), events: events, startErr: errors.New("boom")}
err := host.Replace(context.Background(), broken)
if err == nil {
t.Fatal("Replace() with a failing new module succeeded")
}
if got, want := events.snapshot(), []string{"start:module", "stop:module", "start:module", "start:module"}; !slices.Equal(got, want) {
t.Fatalf("lifecycle events = %v, want the old module restarted after the failed start: %v", got, want)
}
if !host.Has("module") {
t.Error("a refused Replace() unregistered the module")
}
}
func TestHostReplaceRefusesAModuleARunningDependentNeeds(t *testing.T) {
t.Parallel()
events := &eventLog{}
host := plugin.NewHost()
if err := host.Register(&fakeModule{manifest: validManifest("base"), events: events}); err != nil {
t.Fatal(err)
}
if err := host.Register(&fakeModule{manifest: validManifest("dependent", "base"), events: events}); err != nil {
t.Fatal(err)
}
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
err := host.Replace(context.Background(), &fakeModule{manifest: validManifest("base"), events: events})
if err == nil || !strings.Contains(err.Error(), "dependent") {
t.Fatalf("Replace() of a depended-on module = %v, want a refusal naming the dependent", err)
}
if got, want := events.snapshot(), []string{"start:base", "start:dependent"}; !slices.Equal(got, want) {
t.Fatalf("lifecycle events = %v, want the dependent left running: %v", got, want)
}
}
func TestHostReplaceRefusesAnUnregisteredModule(t *testing.T) {
t.Parallel()
host := plugin.NewHost()
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
if err := host.Replace(context.Background(), &fakeModule{manifest: validManifest("absent")}); err == nil {
t.Fatal("Replace() of an unregistered module succeeded")
}
}
func TestHostAddBeforeStartBehavesLikeRegister(t *testing.T) {
t.Parallel()
events := &eventLog{}
host := plugin.NewHost()
if err := host.Add(context.Background(), &fakeModule{manifest: validManifest("early"), events: events}); err != nil {
t.Fatalf("Add() before Start error = %v", err)
}
if err := host.Start(context.Background()); err != nil {
t.Fatal(err)
}
if got, want := events.snapshot(), []string{"start:early"}; !slices.Equal(got, want) {
t.Fatalf("lifecycle events = %v, want the module started by Start(): %v", got, want)
}
}