Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

3.2 KB
Raw Blame
package session

import (
	"encoding/json"
	"os"
	"path/filepath"
	"sync"
	"testing"
	"time"
)

// TestStore_ConcurrentMutationsPersistConsistently drives many parallel
// Create/Authenticate/Touch/Revoke calls (run with -race) to confirm narrowing
// the persistence lock keeps writes ordered and the on-disk file consistent: it
// must always unmarshal cleanly, and every persisted session must be one the
// store still knows about (no torn/stale snapshot, no phantom sessions).
func TestStore_ConcurrentMutationsPersistConsistently(t *testing.T) {
	path := filepath.Join(t.TempDir(), "sessions.json")
	s := NewStore(Config{
		Enabled:     true,
		IdleTimeout: time.Hour,
		MaxLifetime: 24 * time.Hour,
		PersistPath: path,
	})

	const goroutines = 16
	const perGoroutine = 25

	var wg sync.WaitGroup
	wg.Add(goroutines)
	for g := 0; g < goroutines; g++ {
		go func(g int) {
			defer wg.Done()
			for i := 0; i < perGoroutine; i++ {
				id, token, err := s.Create("agent", "", "")
				if err != nil {
					t.Errorf("Create: %v", err)
					return
				}
				if sess, ok := s.Authenticate(token); !ok || sess.ID != id {
					t.Errorf("Authenticate failed for freshly created session %s", id)
					return
				}
				s.Touch(id)
				if i%3 == 0 {
					s.Revoke(id)
				}
			}
		}(g)
	}
	wg.Wait()

	// The persist file must always be parseable (never torn by an interleaved write).
	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read persist file: %v", err)
	}
	var ps persistedStore
	if err := json.Unmarshal(data, &ps); err != nil {
		t.Fatalf("persist file is not consistent JSON: %v\n%s", err, data)
	}

	// Every persisted session must still be known to the store (active ones are
	// kept in memory; the snapshot is a value-copy of that map), so the on-disk
	// set is coherent — no phantom/stale entries from an out-of-order write.
	known := make(map[string]struct{})
	for _, sess := range s.List() {
		known[sess.ID] = struct{}{}
	}
	for _, rec := range ps.Sessions {
		if _, ok := known[rec.ID]; !ok {
			t.Errorf("persisted session %s is not known to the store (stale/torn snapshot)", rec.ID)
		}
	}
}

// TestStore_WriteSnapshotSkipsStale asserts the sequence guard: a snapshot with a
// seq not greater than one already written is dropped, so a stale snapshot can
// never clobber a fresher one even if writers run out of order.
func TestStore_WriteSnapshotSkipsStale(t *testing.T) {
	path := filepath.Join(t.TempDir(), "sessions.json")
	s := NewStore(Config{Enabled: true, PersistPath: path, IdleTimeout: time.Hour, MaxLifetime: 24 * time.Hour})

	fresh := snapshotJob{snapshot: persistedStore{SavedAt: time.Unix(200, 0).UTC()}, seq: 5, path: path}
	stale := snapshotJob{snapshot: persistedStore{SavedAt: time.Unix(100, 0).UTC()}, seq: 3, path: path}

	s.writeSnapshot(fresh)
	s.writeSnapshot(stale) // lower seq → must be skipped

	if s.writtenSeq != 5 {
		t.Fatalf("writtenSeq = %d, want 5 (stale write must not advance it)", s.writtenSeq)
	}
	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatalf("read: %v", err)
	}
	var ps persistedStore
	if err := json.Unmarshal(data, &ps); err != nil {
		t.Fatalf("unmarshal: %v", err)
	}
	if !ps.SavedAt.Equal(time.Unix(200, 0).UTC()) {
		t.Fatalf("on-disk SavedAt = %v, want the fresh snapshot (stale must not clobber)", ps.SavedAt)
	}
}