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.
93 lines
2.6 KiB
Go
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")
|
|
}
|
|
}
|