Files
coder/coderd/x/chatd/context_hydration_internal_test.go
T

273 lines
11 KiB
Go

package chatd
import (
"context"
"database/sql"
"testing"
"time"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
"go.uber.org/mock/gomock"
"cdr.dev/slog/v3/sloggers/slogtest"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/database/dbmock"
dbpubsub "github.com/coder/coder/v2/coderd/database/pubsub"
coderdpubsub "github.com/coder/coder/v2/coderd/pubsub"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/testutil"
)
// TestHydrateChatContextOnCreate covers the create-time pinning path, which the
// end-to-end test cannot reach: chats there are inserted directly, bypassing
// CreateChat. It pins to the agent's latest snapshot via the NULL-guarded
// HydrateAgentChatsContext so a concurrent push is never clobbered, and is a
// best-effort no-op when there is no agent or no snapshot.
func TestHydrateChatContextOnCreate(t *testing.T) {
t.Parallel()
t.Run("PinsWhenSnapshotExists", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
db := dbmock.NewMockStore(ctrl)
server := &Server{db: db, logger: slogtest.Make(t, nil)}
agentID := uuid.New()
chat := database.Chat{ID: uuid.New(), AgentID: uuid.NullUUID{UUID: agentID, Valid: true}}
snapshot := database.WorkspaceAgentContextSnapshot{
WorkspaceAgentID: agentID,
AggregateHash: []byte{0x0a, 0x0b},
SnapshotError: "one source failed",
}
db.EXPECT().InTx(gomock.Any(), gomock.Any()).DoAndReturn(
func(f func(database.Store) error, _ *database.TxOptions) error { return f(db) })
db.EXPECT().GetLatestWorkspaceAgentContextSnapshot(gomock.Any(), agentID).
Return(snapshot, nil)
// The guarded agent-scoped stamp, not an unconditional SetChatContextSnapshot,
// so a concurrent push that already hydrated the chat wins.
db.EXPECT().HydrateAgentChatsContext(gomock.Any(), database.HydrateAgentChatsContextParams{
AgentID: agentID,
AggregateHash: snapshot.AggregateHash,
ContextError: snapshot.SnapshotError,
}).Return([]uuid.UUID{chat.ID}, nil)
server.hydrateChatContextOnCreate(ctx, chat)
})
t.Run("SkipsWhenAgentless", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
// No EXPECT calls: a chat with no agent must touch the database zero times.
db := dbmock.NewMockStore(ctrl)
server := &Server{db: db, logger: slogtest.Make(t, nil)}
server.hydrateChatContextOnCreate(ctx, database.Chat{ID: uuid.New()})
})
t.Run("SkipsWhenNoSnapshot", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
db := dbmock.NewMockStore(ctrl)
server := &Server{db: db, logger: slogtest.Make(t, nil)}
agentID := uuid.New()
// ErrNoRows means the agent has not pushed yet; no stamp is written
// (HydrateAgentChatsContext has no EXPECT, so a call would fail the test).
db.EXPECT().InTx(gomock.Any(), gomock.Any()).DoAndReturn(
func(f func(database.Store) error, _ *database.TxOptions) error { return f(db) })
db.EXPECT().GetLatestWorkspaceAgentContextSnapshot(gomock.Any(), agentID).
Return(database.WorkspaceAgentContextSnapshot{}, sql.ErrNoRows)
server.hydrateChatContextOnCreate(ctx, database.Chat{
ID: uuid.New(),
AgentID: uuid.NullUUID{UUID: agentID, Valid: true},
})
})
}
// TestHydrateAndMarkChatsDirtyPublishesForHydratedAndDirtied verifies one
// event per hydrated, dirtied, or MCP-synced chat.
func TestHydrateAndMarkChatsDirtyPublishesForHydratedAndDirtied(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
db := dbmock.NewMockStore(ctrl)
ps := dbpubsub.NewInMemory()
server := &Server{db: db, logger: slogtest.Make(t, nil), pubsub: ps}
ownerID := uuid.New()
agentID := uuid.New()
hash := []byte{0x01}
now := time.Now()
hydratedChat := database.Chat{ID: uuid.New(), OwnerID: ownerID, ContextAggregateHash: hash}
dirtiedChat := database.Chat{ID: uuid.New(), OwnerID: ownerID, ContextAggregateHash: []byte{0x99}}
syncedChat := database.Chat{ID: uuid.New(), OwnerID: ownerID, ContextAggregateHash: hash}
events := make(chan codersdk.ChatWatchEvent, 3)
cancelSub, err := ps.SubscribeWithErr(
coderdpubsub.ChatWatchEventChannel(ownerID),
coderdpubsub.HandleChatWatchEvent(func(_ context.Context, payload codersdk.ChatWatchEvent, err error) {
require.NoError(t, err)
events <- payload
}),
)
require.NoError(t, err)
defer cancelSub()
db.EXPECT().HydrateAgentChatsContext(gomock.Any(), database.HydrateAgentChatsContextParams{
AgentID: agentID,
AggregateHash: hash,
}).Return([]uuid.UUID{hydratedChat.ID}, nil)
db.EXPECT().MarkChatsContextDirtyByAgent(gomock.Any(), database.MarkChatsContextDirtyByAgentParams{
AgentID: agentID,
AggregateHash: hash,
DirtySince: sql.NullTime{Time: now, Valid: true},
}).Return([]database.MarkChatsContextDirtyByAgentRow{{ID: dirtiedChat.ID, OwnerID: ownerID}}, nil)
// Return the dirtied chat from the sync to verify event deduplication.
db.EXPECT().SyncAgentChatsContextMCPResources(gomock.Any(), agentID).
Return([]uuid.UUID{syncedChat.ID, dirtiedChat.ID}, nil)
db.EXPECT().GetChatByID(gomock.Any(), hydratedChat.ID).Return(hydratedChat, nil)
db.EXPECT().GetChatByID(gomock.Any(), dirtiedChat.ID).Return(dirtiedChat, nil)
db.EXPECT().GetChatByID(gomock.Any(), syncedChat.ID).Return(syncedChat, nil)
publish, err := server.HydrateAndMarkChatsDirty(ctx, db, agentID, hash, "", now)
require.NoError(t, err)
publish()
gotChatIDs := make([]uuid.UUID, 0, 3)
for range 3 {
event := testutil.RequireReceive(ctx, t, events)
require.Equal(t, codersdk.ChatWatchEventKindContextDirty, event.Kind)
gotChatIDs = append(gotChatIDs, event.Chat.ID)
}
require.ElementsMatch(t, []uuid.UUID{hydratedChat.ID, dirtiedChat.ID, syncedChat.ID}, gotChatIDs)
}
// TestEnsureChatContextPinnedOnFirstTurn covers the lazy-bind pinning path. An
// API-created chat carries no agent at create, binds its agent on the first
// turn, and must pin the agent's already-pushed snapshot then. This is the
// mechanism that lets a workspace created mid-turn have its context pinned on
// the next turn: the agent pushes its snapshot before the chat is bound to it,
// so HydrateAgentChatsContext on that push cannot reach the chat, and the
// rebind-only binding does not pin a first-time agent.
func TestEnsureChatContextPinnedOnFirstTurn(t *testing.T) {
t.Parallel()
t.Run("PinsWhenUnpinnedAndSnapshotExists", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
db := dbmock.NewMockStore(ctrl)
ps := dbpubsub.NewInMemory()
server := &Server{db: db, logger: slogtest.Make(t, nil), pubsub: ps}
ownerID := uuid.New()
agentID := uuid.New()
chat := database.Chat{ID: uuid.New(), OwnerID: ownerID, AgentID: uuid.NullUUID{UUID: agentID, Valid: true}}
// A second unpinned chat bound to the same agent is hydrated by the
// same statement and must get its own watch event.
siblingChat := database.Chat{ID: uuid.New(), OwnerID: ownerID, AgentID: chat.AgentID}
snapshot := database.WorkspaceAgentContextSnapshot{
WorkspaceAgentID: agentID,
AggregateHash: []byte{0x0a, 0x0b},
}
pinnedChat := chat
pinnedChat.ContextAggregateHash = snapshot.AggregateHash
pinnedSibling := siblingChat
pinnedSibling.ContextAggregateHash = snapshot.AggregateHash
events := make(chan codersdk.ChatWatchEvent, 2)
cancelSub, err := ps.SubscribeWithErr(
coderdpubsub.ChatWatchEventChannel(ownerID),
coderdpubsub.HandleChatWatchEvent(func(_ context.Context, payload codersdk.ChatWatchEvent, err error) {
require.NoError(t, err)
events <- payload
}),
)
require.NoError(t, err)
defer cancelSub()
db.EXPECT().InTx(gomock.Any(), gomock.Any()).DoAndReturn(
func(f func(database.Store) error, _ *database.TxOptions) error { return f(db) })
db.EXPECT().GetLatestWorkspaceAgentContextSnapshot(gomock.Any(), agentID).
Return(snapshot, nil)
// The guarded agent-scoped stamp, not an unconditional SetChatContextSnapshot,
// so a concurrent push that already hydrated the chat wins.
db.EXPECT().HydrateAgentChatsContext(gomock.Any(), database.HydrateAgentChatsContextParams{
AgentID: agentID,
AggregateHash: snapshot.AggregateHash,
ContextError: snapshot.SnapshotError,
}).Return([]uuid.UUID{chat.ID, siblingChat.ID}, nil)
db.EXPECT().GetChatByID(gomock.Any(), chat.ID).Return(pinnedChat, nil)
db.EXPECT().GetChatByID(gomock.Any(), siblingChat.ID).Return(pinnedSibling, nil)
server.ensureChatContextPinnedOnFirstTurn(ctx, chat)
// Watching clients cached both details without pinned resources, so
// every hydrated chat must broadcast a context event.
gotChatIDs := make([]uuid.UUID, 0, 2)
for range 2 {
event := testutil.RequireReceive(ctx, t, events)
require.Equal(t, codersdk.ChatWatchEventKindContextDirty, event.Kind)
gotChatIDs = append(gotChatIDs, event.Chat.ID)
}
require.ElementsMatch(t, []uuid.UUID{chat.ID, siblingChat.ID}, gotChatIDs)
})
t.Run("SkipsPublishWhenNoSnapshot", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
db := dbmock.NewMockStore(ctrl)
server := &Server{db: db, logger: slogtest.Make(t, nil)}
agentID := uuid.New()
// ErrNoRows means the agent has not pushed yet: nothing is stamped
// and no event is published (GetChatByID has no EXPECT, so a
// post-hydration read would fail the test).
db.EXPECT().InTx(gomock.Any(), gomock.Any()).DoAndReturn(
func(f func(database.Store) error, _ *database.TxOptions) error { return f(db) })
db.EXPECT().GetLatestWorkspaceAgentContextSnapshot(gomock.Any(), agentID).
Return(database.WorkspaceAgentContextSnapshot{}, sql.ErrNoRows)
server.ensureChatContextPinnedOnFirstTurn(ctx, database.Chat{
ID: uuid.New(),
AgentID: uuid.NullUUID{UUID: agentID, Valid: true},
})
})
t.Run("SkipsWhenAlreadyPinned", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
// A non-NULL pinned hash means the chat is already pinned (or dirty
// awaiting refresh); the hook must touch the database zero times so it
// never clobbers existing bodies or a dirty chat's stale hash.
db := dbmock.NewMockStore(ctrl)
server := &Server{db: db, logger: slogtest.Make(t, nil)}
server.ensureChatContextPinnedOnFirstTurn(ctx, database.Chat{
ID: uuid.New(),
AgentID: uuid.NullUUID{UUID: uuid.New(), Valid: true},
ContextAggregateHash: []byte{0x01},
})
})
t.Run("SkipsWhenAgentless", func(t *testing.T) {
t.Parallel()
ctx := testutil.Context(t, testutil.WaitShort)
ctrl := gomock.NewController(t)
// No agent bound yet: the hook must touch the database zero times.
db := dbmock.NewMockStore(ctrl)
server := &Server{db: db, logger: slogtest.Make(t, nil)}
server.ensureChatContextPinnedOnFirstTurn(ctx, database.Chat{ID: uuid.New()})
})
}