@pi-in-go/pigpen-ahp 0.1.0

package/extensions/ahp/internal/host/subscriptions_test.go

@@ -0,0 +1,160 @@
+package host_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/microsoft/agent-host-protocol/clients/go/ahptypes"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/host"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+func initialized(t *testing.T, h *host.Host, subs ...string) *testkit.Client {
+	t.Helper()
+	c := testkit.Connect(t, h)
+	extra := map[string]any{}
+	if len(subs) > 0 {
+		extra["initialSubscriptions"] = subs
+	}
+	c.Initialize(nextClientID(), extra)
+	return c
+}
+
+// Twins of upstream test/subscriptions.test.ts, describe "subscriptions".
+func TestSubscriptions(t *testing.T) {
+	h := testkit.NewHost(host.Options{})
+
+	twin.Run(t, "subscriptions", "returns the current state as a snapshot", func(t *testing.T) {
+		c := initialized(t, h)
+		res := c.Subscribe(wire.RootChannel)
+		if res.Snapshot == nil || res.Snapshot.Resource != wire.RootChannel {
+			t.Fatalf("snapshot = %+v", res.Snapshot)
+		}
+		if root := res.Snapshot.State.Root; root == nil || len(root.Agents) != 1 {
+			t.Fatalf("root state = %+v", root)
+		}
+	})
+
+	twin.Run(t, "subscriptions", "rejects a channel scheme the host does not serve", func(t *testing.T) {
+		c := initialized(t, h)
+		c.ExpectError("subscribe", map[string]any{"channel": "ahp-unknown:/x"}, -32602)
+	})
+
+	twin.Run(t, "subscriptions", "rejects a well-formed URI for a channel that does not exist", func(t *testing.T) {
+		c := initialized(t, h)
+		c.ExpectError("subscribe", map[string]any{"channel": "ahp-session:/nope"}, -32008)
+	})
+}
+
+// Twins of upstream test/subscriptions.test.ts, describe "action dispatch".
+func TestActionDispatch(t *testing.T) {
+	h := testkit.NewHost(host.Options{})
+
+	twin.Run(t, "subscriptions", "echoes a client-dispatchable action with its origin", func(t *testing.T) {
+		c := initialized(t, h)
+		c.Subscribe(wire.RootChannel)
+		seq := c.Dispatch(wire.RootChannel, map[string]any{"type": "root/configChanged", "config": map[string]any{"theme": "dark"}})
+		env := c.NextEnvelope(wire.RootChannel, 0)
+		if env.Channel != wire.RootChannel || actionType(t, env) != "root/configChanged" || env.RejectionReason != nil {
+			t.Fatalf("envelope = %+v", env)
+		}
+		// The origin lets the write-ahead client match the echo to its own dispatch.
+		if env.Origin == nil || env.Origin.ClientSeq != seq || env.ServerSeq <= 0 {
+			t.Fatalf("origin = %+v serverSeq = %d", env.Origin, env.ServerSeq)
+		}
+	})
+
+	twin.Run(t, "subscriptions", "rejects an action that is not client-dispatchable", func(t *testing.T) {
+		c := initialized(t, h)
+		c.Subscribe(wire.RootChannel)
+		// root/agentsChanged is server-only: the host owns the agent list.
+		c.Dispatch(wire.RootChannel, map[string]any{"type": "root/agentsChanged", "agents": []any{}})
+		env := c.NextEnvelope(wire.RootChannel, 0)
+		if env.RejectionReason == nil || !contains(*env.RejectionReason, "not client-dispatchable") {
+			t.Fatalf("rejectionReason = %v", env.RejectionReason)
+		}
+		if root := h.Store().Root(wire.RootChannel); root == nil || len(root.Agents) != 1 {
+			t.Fatalf("a rejected action must leave state untouched, got %+v", root)
+		}
+	})
+
+	twin.Run(t, "subscriptions", "silently ignores an action for a channel that does not exist", func(t *testing.T) {
+		c := initialized(t, h)
+		c.Subscribe(wire.RootChannel)
+		c.Dispatch("ahp-session:/ghost", map[string]any{"type": "session/titleChanged", "title": "x"})
+		// No echo for the ghost channel, so the next envelope on root is the one dispatched afterwards.
+		c.Dispatch(wire.RootChannel, map[string]any{"type": "root/configChanged", "config": map[string]any{"probe": 1}})
+		if env := c.NextEnvelope("", 0); env.Channel != wire.RootChannel {
+			t.Fatalf("first envelope was on %s", env.Channel)
+		}
+	})
+
+	twin.Run(t, "subscriptions", "broadcasts to every subscriber and allocates one seq per action", func(t *testing.T) {
+		alice, bob := initialized(t, h), initialized(t, h)
+		alice.Subscribe(wire.RootChannel)
+		bob.Subscribe(wire.RootChannel)
+		alice.Dispatch(wire.RootChannel, map[string]any{"type": "root/configChanged", "config": map[string]any{"shared": true}})
+		a, b := alice.NextEnvelope(wire.RootChannel, 0), bob.NextEnvelope(wire.RootChannel, 0)
+		if a.ServerSeq != b.ServerSeq || testkit.JSON(t, a.Action) != testkit.JSON(t, b.Action) {
+			t.Fatalf("alice %d %s, bob %d %s", a.ServerSeq, testkit.JSON(t, a.Action), b.ServerSeq, testkit.JSON(t, b.Action))
+		}
+		// Both clients reduce the same envelope, so they converge by construction.
+		if a.Origin == nil || b.Origin == nil || a.Origin.ClientId != b.Origin.ClientId {
+			t.Fatalf("origins differ: %+v %+v", a.Origin, b.Origin)
+		}
+	})
+
+	twin.Run(t, "subscriptions", "treats root/configChanged as a no-op until the host declares a config schema", func(t *testing.T) {
+		// AHP only merges config values into a schema the host has already published. The action is
+		// still sequenced and echoed; it just does not change state.
+		c := initialized(t, h)
+		c.Subscribe(wire.RootChannel)
+		c.Dispatch(wire.RootChannel, map[string]any{"type": "root/configChanged", "config": map[string]any{"theme": "dark"}})
+		env := c.NextEnvelope(wire.RootChannel, 0)
+		if env.RejectionReason != nil {
+			t.Fatalf("unexpected rejection %q", *env.RejectionReason)
+		}
+		if root := h.Store().Root(wire.RootChannel); root == nil || root.Config != nil {
+			t.Fatalf("config = %+v", root)
+		}
+	})
+
+	twin.Run(t, "subscriptions", "stops delivering after unsubscribe", func(t *testing.T) {
+		c := initialized(t, h)
+		c.Subscribe(wire.RootChannel)
+		c.Unsubscribe(wire.RootChannel)
+		c.Ping()
+		before := h.ServerSeq()
+		h.DispatchServerAction(wire.RootChannel, rootActiveSessions(7))
+		// The action was still sequenced and applied — the client just stops seeing it.
+		if h.ServerSeq() != before+1 {
+			t.Fatalf("serverSeq = %d, want %d", h.ServerSeq(), before+1)
+		}
+		if !c.Silent(func(n testkit.Notification) bool { _, ok := n.Envelope(); return ok }, 150*time.Millisecond) {
+			t.Fatal("an unsubscribed client received an action")
+		}
+	})
+}
+
+func rootActiveSessions(n int64) ahptypes.StateAction {
+	return ahptypes.StateAction{Value: &ahptypes.RootActiveSessionsChangedAction{Type: ahptypes.ActionTypeRootActiveSessionsChanged, ActiveSessions: n}}
+}
+
+func actionType(t *testing.T, env ahptypes.ActionEnvelope) string {
+	t.Helper()
+	m := testkit.Normalize(t, env.Action).(map[string]any)
+	s, _ := m["type"].(string)
+	return s
+}
+
+func contains(s, sub string) bool {
+	for i := 0; i+len(sub) <= len(s); i++ {
+		if s[i:i+len(sub)] == sub {
+			return true
+		}
+	}
+	return false
+}

package/extensions/ahp/internal/host/surface_test.go

@@ -0,0 +1,95 @@
+package host_test
+
+import (
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/MichaelKinsy/pigpen/ahp/internal/host"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/testkit"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/twin"
+	"github.com/MichaelKinsy/pigpen/ahp/internal/wire"
+)
+
+// Twins of upstream test/protocol-surface.test.ts: the AHP 0.9 command surface this product
+// exposes. Upstream makes the policy table exhaustive at compile time over the client library's
+// CommandMap, so an AHP upgrade forces an explicit decision; here the same table is checked against
+// the vendored spec's command list in TestCommandPolicyCoversTheSpec (an addition, not a twin).
+
+// rootMethods are the connection-level commands routed on the root channel.
+var rootMethods = []string{
+	"ping", "createResourceWatch", "listSessions", "resourceRead", "resourceWrite", "resourceList",
+	"resourceCopy", "resourceDelete", "resourceMove", "resourceResolve", "resourceMkdir", "resourceRequest",
+	"resolveSessionConfig", "sessionConfigCompletions",
+}
+
+// unsupportedRequests are commands this host deliberately does not implement.
+var unsupportedRequests = map[string]map[string]any{
+	"createChat":                       {"channel": "ahp-session:/session", "chat": "ahp-chat:/chat"},
+	"disposeChat":                      {"channel": "ahp-chat:/chat"},
+	"authenticate":                     {"channel": wire.RootChannel, "resource": "https://example.com", "token": "opaque"},
+	"invokeChangesetOperation":         {"channel": "ahp-changeset:/changes", "operationId": "apply"},
+	"listAutomationTriggerDefinitions": {"channel": wire.RootChannel},
+	"runAutomation":                    {"channel": "ahp-automations://", "automation": "ahp-automation:/job", "requestId": "request"},
+	"fetchAutomationRuns":              {"channel": "ahp-automations://", "automation": "ahp-automation:/job"},
+}
+
+func TestAHPCommandSurface(t *testing.T) {
+	h := testkit.NewHost(host.Options{})
+	client := testkit.Connect(t, h)
+	t.Cleanup(client.Close)
+	client.Initialize("surface-client", nil)
+
+	twin.Run(t, "protocol-surface", "returns MethodNotFound for every deliberately unsupported command", func(t *testing.T) {
+		for method, params := range unsupportedRequests {
+			client.ExpectError(method, params, wire.CodeMethodNotFound)
+		}
+	})
+
+	twin.Run(t, "protocol-surface", "requires the root routing channel on every connection-level command", func(t *testing.T) {
+		wrongChannel := "ahp-session:/wrong-channel"
+		for _, method := range rootMethods {
+			client.ExpectError(method, map[string]any{"channel": wrongChannel}, wire.CodeInvalidParams)
+		}
+		initializing := testkit.Connect(t, h)
+		t.Cleanup(initializing.Close)
+		initializing.ExpectError("initialize", map[string]any{"channel": wrongChannel, "clientId": "wrong-channel-client", "protocolVersions": testkit.SupportedVersions()}, wire.CodeInvalidParams)
+		reconnecting := testkit.Connect(t, h)
+		t.Cleanup(reconnecting.Close)
+		reconnecting.ExpectError("reconnect", map[string]any{"channel": wrongChannel, "clientId": "wrong-channel-reconnect", "lastSeenServerSeq": 0, "subscriptions": []string{}}, wire.CodeInvalidParams)
+	})
+}
+
+// TestCommandPolicyCoversTheSpec is the port's counterpart of upstream's compile-time exhaustiveness:
+// every command of the vendored spec must be an explicit decision, implemented or refused.
+func TestCommandPolicyCoversTheSpec(t *testing.T) {
+	raw, err := os.ReadFile("../testkit/schema/commands.schema.json")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var schema struct {
+		Defs map[string]json.RawMessage `json:"$defs"`
+	}
+	if err := json.Unmarshal(raw, &schema); err != nil {
+		t.Fatal(err)
+	}
+	implemented := map[string]bool{
+		"initialize": true, "ping": true, "reconnect": true, "subscribe": true, "createSession": true, "disposeSession": true,
+		"createTerminal": true, "disposeTerminal": true, "createResourceWatch": true, "listSessions": true,
+		"resourceRead": true, "resourceWrite": true, "resourceList": true, "resourceCopy": true, "resourceDelete": true,
+		"resourceMove": true, "resourceResolve": true, "resourceMkdir": true, "resourceRequest": true, "fetchTurns": true,
+		"resolveSessionConfig": true, "sessionConfigCompletions": true, "completions": true,
+	}
+	// unsubscribe and dispatchAction are notifications, not commands.
+	notCommands := map[string]bool{"BaseParams": true, "PaginatedParams": true, "UnsubscribeParams": true, "DispatchActionParams": true}
+	for def := range schema.Defs {
+		if !strings.HasSuffix(def, "Params") || notCommands[def] {
+			continue
+		}
+		method := strings.ToLower(def[:1]) + strings.TrimSuffix(def[1:], "Params")
+		if _, refused := unsupportedRequests[method]; !implemented[method] && !refused {
+			t.Errorf("spec command %q has no explicit policy: implement it or refuse it in unsupportedRequests", method)
+		}
+	}
+}