Files
coder/coderd/x/chatd/chatstate/queue_client_order_test.go
T
Thomas Kosiewski bb31a19e5b fix(coderd): return queued chat messages in promotion order (#30255)
Clients read the chat queue through GetChatQueuedMessages, which ordered by created_at, while chatstate promotes by position. Promoting a queued message changes only its position, and concurrent senders can commit with created_at and position in opposite orders, so clients showed the wrong next message. Order GetChatQueuedMessages by position, id.

---
_Generated with [`xum`](https://github.com/coder/xum) • Model: `anthropic:claude-opus-5-5` • Thinking: `high`_
2026-10-02 00:04:55 +02:00

104 lines
4.0 KiB
Go

package chatstate_test
import (
"testing"
"github.com/google/uuid"
"github.com/stretchr/testify/require"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/x/chatd/chatstate"
"github.com/coder/coder/v2/codersdk"
"github.com/coder/coder/v2/testutil"
)
// clientQueueIDs returns the queue in the order clients receive it: the
// stream snapshot (stream_loop.go) and the messages API
// (coderd/exp_chats.go) both read GetChatQueuedMessages.
func clientQueueIDs(t *testing.T, f *testFixture, chatID uuid.UUID) []int64 {
t.Helper()
ctx := testutil.Context(t, testutil.WaitShort)
rows, err := f.DB.GetChatQueuedMessages(ctx, chatID)
require.NoError(t, err)
ids := make([]int64, len(rows))
for i, r := range rows {
ids[i] = r.ID
}
return ids
}
// TestClientQueueOrderMatchesPromotionOrder checks that clients receive the
// queue in the order promotions take it (position, id), including when
// position and created_at disagree.
func TestClientQueueOrderMatchesPromotionOrder(t *testing.T) {
t.Parallel()
// An explicit promote on a running chat moves the target to the head
// by position only; created_at keeps the old order.
t.Run("PromoteWhileRunning", func(t *testing.T) {
t.Parallel()
f := newTestFixture(t)
ctx := testutil.Context(t, testutil.WaitShort)
created := createTestChat(t, f)
m := chatstate.NewChatMachine(f.DB, f.Pub, created.Chat.ID)
first := sendQueuedMessage(t, f, m, "first")
second := sendQueuedMessage(t, f, m, "second")
require.Equal(t, chatstate.StateR1, f.classify(ctx, t, created.Chat.ID))
require.NoError(t, m.Update(ctx, func(tx *chatstate.Tx, _ database.Store) error {
_, err := tx.PromoteQueuedMessage(chatstate.PromoteQueuedMessageInput{
QueuedMessageID: second.QueuedMessage.ID,
})
return err
}))
require.Equal(t, chatstate.StateI1, f.classify(ctx, t, created.Chat.ID))
promotionOrder := queuedIDsByPosition(ctx, t, f, created.Chat.ID)
require.Equal(t, []int64{second.QueuedMessage.ID, first.QueuedMessage.ID}, promotionOrder)
require.Equal(t, promotionOrder, clientQueueIDs(t, f, created.Chat.ID),
"clients see the promoted message behind the message that will run after it")
})
// Two senders: the first transaction starts (fixing now() and so
// created_at) before the second, but takes the chat lock after it.
// In production the window is the round trip between BEGIN and the
// lock statement; the outer transaction widens it.
t.Run("ConcurrentSenders", func(t *testing.T) {
t.Parallel()
f := newTestFixture(t)
ctx := testutil.Context(t, testutil.WaitShort)
created := createTestChat(t, f)
m := chatstate.NewChatMachine(f.DB, f.Pub, created.Chat.ID)
var early, late chatstate.SendMessageResult
require.NoError(t, f.DB.InTx(func(tx database.Store) error {
// The first statement pins the transaction start time.
if _, err := tx.GetDatabaseNow(ctx); err != nil {
return err
}
// The other sender commits on its own connection meanwhile.
late = sendQueuedMessage(t, f, m, "committed first")
// Update reuses this transaction and only now locks the chat.
return chatstate.NewChatMachine(tx, f.Pub, created.Chat.ID).Update(ctx, func(stx *chatstate.Tx, _ database.Store) error {
var err error
early, err = stx.SendMessage(chatstate.SendMessageInput{
Message: userTextMessage("began first", f.User.ID, f.Model.ID),
BusyBehavior: chatstate.BusyBehaviorQueue,
MaxQueueSize: codersdk.DefaultChatMaxQueuedMessagesPerChat,
})
return err
})
}, nil))
require.NotNil(t, early.QueuedMessage)
require.NotNil(t, late.QueuedMessage)
require.True(t, early.QueuedMessage.CreatedAt.Before(late.QueuedMessage.CreatedAt),
"the scenario needs created_at to disagree with position")
promotionOrder := queuedIDsByPosition(ctx, t, f, created.Chat.ID)
require.Equal(t, []int64{late.QueuedMessage.ID, early.QueuedMessage.ID}, promotionOrder)
require.Equal(t, promotionOrder, clientQueueIDs(t, f, created.Chat.ID),
"clients see the later-locked message first, but it is promoted second")
})
}