Files
archie/internal/infrastructure/gatewayrpc/store_client_test.go
T
sam 89d8dc0e7f feat(messaging): migrate gateway session persistence onto domain types
SessionStore message history now stores/loads domain/messaging.Message:
sender attribution, derived role, and conversation address are canonical
record fields. SQLite gains a role column with open-time backfill for
pre-migration databases. gateway.Message remains the channel-facing
transport; conversion lives in one boundary module. ChatContract,
gatewayrpc proto, and dashboard JSON are unchanged; the RPC client
splits into ChatContract (Client) and SessionStore (StoreClient) views.

Sessions stay SessionContext: UUID keys and platform/bot/title/branch
metadata have no lossless home in Conversation; keyed migration tracked
separately once Agent/user/binding ownership settles.

Refs: archie-core-d9dv
2026-09-08 21:28:19 +10:00

107 lines
3.7 KiB
Go

package gatewayrpc
import (
"context"
"net"
"testing"
"time"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/test/bufconn"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/gateway"
)
// remoteStore wires a StoreClient to a real SQLite session store through the
// gRPC server, mirroring production (standalone gateway owns the store,
// archied dials in).
func remoteStore(t *testing.T, sessions gateway.SessionStore, chat gateway.ChatContract) gateway.SessionStore {
t.Helper()
listener := bufconn.Listen(1 << 20)
server := grpc.NewServer()
RegisterServer(server, chat, sessions)
go func() { _ = server.Serve(listener) }()
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
conn, err := grpc.NewClient("passthrough:///gateway", grpc.WithTransportCredentials(insecure.NewCredentials()), grpc.WithContextDialer(func(ctx context.Context, _ string) (net.Conn, error) { return listener.DialContext(ctx) }))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = conn.Close() })
return NewStoreClient(conn)
}
// TestStoreClientPreservesCanonicalRecords pins the remote store contract:
// messages cross the wire in their gateway shape (the proto is unchanged)
// and come back as the same canonical records -- sender, derived role, and
// conversation address intact. Roles are passed empty to prove the server
// derives them from the owning session, exactly like the in-process
// boundary.
func TestStoreClientPreservesCanonicalRecords(t *testing.T) {
ctx := t.Context()
sessions := gateway.NewSessionStoreMemory()
t.Cleanup(func() { _ = sessions.Close() })
router := gateway.NewRouter(nil, nil, "web")
router.InitSessions(sessions)
local := &gateway.LocalChatAdapter{Router: router, Sessions: sessions}
store := remoteStore(t, sessions, local)
sc := gateway.SessionContext{
SessionID: "sess-1",
Source: gateway.SessionSource{Platform: "web", BotUser: "archie", ChannelID: "chat-1"},
CreatedAt: time.Now().UTC(),
LastActiveAt: time.Now().UTC(),
}
if err := store.Save(ctx, sc); err != nil {
t.Fatalf("Save: %v", err)
}
msgs := []messaging.Message{
{SourceID: "w-1", Sender: "web", Text: "hello", At: time.Now().UTC()},
{SourceID: "w-2", Sender: "archie", Text: "hi", At: time.Now().UTC()},
}
for _, m := range msgs {
if err := store.SaveMessage(ctx, "sess-1", m); err != nil {
t.Fatalf("SaveMessage: %v", err)
}
}
got, err := store.RecentMessages(ctx, "sess-1", 10)
if err != nil {
t.Fatalf("RecentMessages: %v", err)
}
if len(got) != 2 {
t.Fatalf("RecentMessages returned %d messages, want 2", len(got))
}
want := []messaging.Message{
{
SourceID: "w-1", Sender: "web", Role: messaging.RoleUser, Text: "hello",
ConversationID: messaging.ConversationID{ChannelID: "chat-1"},
},
{
SourceID: "w-2", Sender: "archie", Role: messaging.RoleAssistant, Text: "hi",
ConversationID: messaging.ConversationID{ChannelID: "chat-1"},
},
}
for i, w := range want {
if got[i].SourceID != w.SourceID || got[i].Sender != w.Sender ||
got[i].Role != w.Role || got[i].Text != w.Text ||
got[i].ConversationID != w.ConversationID {
t.Fatalf("message %d = %+v, want %+v", i, got[i], w)
}
if got[i].ID == "" {
t.Fatalf("message %d has no canonical ID", i)
}
}
page, err := store.SearchMessages(ctx, "sess-1", gateway.MessageQuery{Query: "hello", Limit: 10})
if err != nil {
t.Fatalf("SearchMessages: %v", err)
}
if len(page.Messages) != 1 || page.Messages[0].Role != messaging.RoleUser ||
page.Messages[0].ConversationID.ChannelID != "chat-1" {
t.Fatalf("SearchMessages = %+v, want the user message with its conversation", page.Messages)
}
}