Files
archie/internal/gateway/session_concurrency_test.go
T
sam 61b4b7b0cf refactor(store): replace legacy persistence with SQLite
Task and event persistence now uses a dedicated SQLite sidecar derived from the configured state prefix, matching the independently persisted conversation store. The configured path now means a state-path prefix rather than a database file so fresh SQLite state never attempts to interpret the previous storage format.

Remove the retired implementation and dependency completely, strengthen SQLite migrations and concurrency behavior, restore backend-neutral coverage, and align configuration, operational guidance, UI labels, and deployment documentation with the new storage and host-daemon topology.
2026-08-09 22:27:25 +10:00

93 lines
2.6 KiB
Go

package gateway
import (
"context"
"fmt"
"sync"
"testing"
)
// TestSessionTrackerConcurrentResolve pins that the active-session map is
// safe under the concurrent dispatch the Telegram gateway actually uses:
// go-telegram/bot runs each update in its own goroutine. Run with -race.
func TestSessionTrackerConcurrentResolve(t *testing.T) {
tests := []struct {
name string
channels int
workers int
}{
{"single channel contended", 1, 32},
{"many channels", 16, 32},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
ctx := context.Background()
store := NewSessionStoreMemory()
t.Cleanup(func() { _ = store.Close() })
tracker := newSessionTracker(store)
var wg sync.WaitGroup
for i := range tc.workers {
wg.Go(func() {
channel := fmt.Sprintf("chan-%d", i%tc.channels)
if _, err := tracker.resolve(ctx, "telegram", "bot", channel, ""); err != nil {
t.Errorf("resolve: %v", err)
}
tracker.setActive(channel, "", "override-"+channel)
_ = tracker.getActive(channel, "")
})
}
wg.Wait()
})
}
}
// TestSessionTrackerResolveIsStable pins that resolve returns the same
// session for the same channel+thread across concurrent callers, so
// interleaved messages cannot land in different sessions.
func TestSessionTrackerResolveIsStable(t *testing.T) {
ctx := context.Background()
store := NewSessionStoreMemory()
t.Cleanup(func() { _ = store.Close() })
tracker := newSessionTracker(store)
const workers = 32
ids := make([]string, workers)
var wg sync.WaitGroup
for i := range workers {
wg.Go(func() {
id, err := tracker.resolve(ctx, "telegram", "bot", "chan", "thread")
if err != nil {
t.Errorf("resolve: %v", err)
return
}
ids[i] = id
})
}
wg.Wait()
for i, id := range ids {
if id != ids[0] {
t.Fatalf("worker %d resolved %q, worker 0 resolved %q", i, id, ids[0])
}
}
}
// TestCanonicalMessageIDIsSessionScoped pins that the same upstream message
// copied into another session gets its own identity, so branch lineage does
// not alias across conversations.
func TestCanonicalMessageIDIsSessionScoped(t *testing.T) {
a := newMessageID("session-a", "tg-1")
b := newMessageID("session-b", "tg-1")
if a == b {
t.Errorf("sessions a and b both derived %q for the same upstream ID", a)
}
if again := newMessageID("session-a", "tg-1"); again != a {
t.Errorf("derivation is not deterministic: %q then %q", a, again)
}
if first, second := newMessageID("session-a", ""), newMessageID("session-a", ""); first == second {
t.Error("messages with no upstream ID must get distinct identities")
}
}