Skip to content

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

13.3 KB
Raw Blame
package session

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

func TestTouchDebouncesPersistence(t *testing.T) {
	path := filepath.Join(t.TempDir(), "sessions.json")
	base := time.Now()
	cur := base
	s := NewStore(Config{Enabled: true, IdleTimeout: time.Hour, MaxLifetime: 24 * time.Hour, PersistPath: path})
	s.now = func() time.Time { return cur }

	id, _, err := s.Create("agent", "", "")
	if err != nil {
		t.Fatalf("create: %v", err)
	}

	readLastSeen := func() time.Time {
		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("unmarshal persist file: %v", err)
		}
		for _, rec := range ps.Sessions {
			if rec.ID == id {
				return rec.LastSeenAt
			}
		}
		t.Fatalf("session %q not in persist file", id)
		return time.Time{}
	}

	// First touch persists immediately (lastTouchSave is zero).
	cur = base.Add(time.Second)
	s.Touch(id)
	seen1 := readLastSeen()
	if !seen1.Equal(cur) {
		t.Fatalf("first touch: persisted LastSeen=%v, want %v", seen1, cur)
	}

	// Second touch within the debounce window must NOT rewrite the file.
	cur = base.Add(2 * time.Second)
	s.Touch(id)
	if seen2 := readLastSeen(); !seen2.Equal(seen1) {
		t.Fatalf("touch within window persisted (LastSeen %v -> %v); expected debounce", seen1, seen2)
	}

	// After the interval elapses, a touch persists again.
	cur = base.Add(2*time.Second + touchPersistInterval + time.Second)
	s.Touch(id)
	if seen3 := readLastSeen(); !seen3.Equal(cur) {
		t.Fatalf("touch after interval: persisted LastSeen=%v, want %v", seen3, cur)
	}
}

func TestAuthenticateTokenIndex_ManySessions(t *testing.T) {
	s := NewStore(Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})

	type rec struct{ id, token string }
	recs := make([]rec, 0, 5)
	for i := 0; i < 5; i++ {
		id, token, err := s.Create("agent", "", "")
		if err != nil {
			t.Fatalf("create %d: %v", i, err)
		}
		recs = append(recs, rec{id, token})
	}

	// Each token must resolve (O(1) index) to its own session, not another.
	for i, r := range recs {
		sess, ok := s.Authenticate(r.token)
		if !ok || sess == nil {
			t.Fatalf("auth %d failed for valid token", i)
		}
		if sess.ID != r.id {
			t.Fatalf("auth %d returned session %q, want %q", i, sess.ID, r.id)
		}
	}

	// Unknown token fails.
	if _, ok := s.Authenticate("ses_nope"); ok {
		t.Fatal("authenticated an unknown token")
	}

	// Revoked session no longer authenticates (status filtered).
	if !s.Revoke(recs[0].id) {
		t.Fatal("revoke failed")
	}
	if _, ok := s.Authenticate(recs[0].token); ok {
		t.Fatal("authenticated a revoked session")
	}
	// Other sessions still authenticate.
	if _, ok := s.Authenticate(recs[1].token); !ok {
		t.Fatal("a non-revoked session stopped authenticating")
	}
}

func TestCreateAndAuthenticate(t *testing.T) {
	s := NewStore(Config{Enabled: true, IdleTimeout: 30 * time.Minute, MaxLifetime: 24 * time.Hour})
	id, token, err := s.Create("agent-1", "test session", "")
	if err != nil {
		t.Fatal(err)
	}
	if !strings.HasPrefix(id, "ses_") {
		t.Fatalf("session ID should start with ses_, got %q", id)
	}
	if !strings.HasPrefix(token, "ses_") {
		t.Fatalf("token should start with ses_, got %q", token)
	}
	if len(token) != 4+48 { // ses_ + 48 hex chars
		t.Fatalf("token length should be 52, got %d", len(token))
	}
	if len(id) != 4+16 { // ses_ + 16 hex chars
		t.Fatalf("session ID length should be 20, got %d", len(id))
	}

	sess, ok := s.Authenticate(token)
	if !ok || sess == nil {
		t.Fatal("expected successful authentication")
	}
	if sess.AgentID != "agent-1" {
		t.Fatalf("expected agentId agent-1, got %q", sess.AgentID)
	}
	if sess.Label != "test session" {
		t.Fatalf("expected label 'test session', got %q", sess.Label)
	}
}

func TestAuthenticateInvalidToken(t *testing.T) {
	s := NewStore(Config{Enabled: true})
	_, _, _ = s.Create("agent-1", "", "")
	sess, ok := s.Authenticate("ses_invalidtoken")
	if ok || sess != nil {
		t.Fatal("expected failed authentication for invalid token")
	}
}

func TestAuthenticateEmptyToken(t *testing.T) {
	s := NewStore(Config{Enabled: true})
	sess, ok := s.Authenticate("")
	if ok || sess != nil {
		t.Fatal("expected failed authentication for empty token")
	}
}

func TestExpiry(t *testing.T) {
	s := NewStore(Config{Enabled: true, MaxLifetime: 1 * time.Hour, IdleTimeout: 30 * time.Minute})
	now := time.Now()
	s.now = func() time.Time { return now }

	_, token, _ := s.Create("agent-1", "", "")

	// Advance past max lifetime
	s.now = func() time.Time { return now.Add(2 * time.Hour) }
	sess, ok := s.Authenticate(token)
	if ok || sess != nil {
		t.Fatal("expected authentication to fail after expiry")
	}
}

func TestIdleTimeout(t *testing.T) {
	s := NewStore(Config{Enabled: true, MaxLifetime: 24 * time.Hour, IdleTimeout: 10 * time.Minute})
	now := time.Now()
	s.now = func() time.Time { return now }

	_, token, _ := s.Create("agent-1", "", "")

	// Advance past idle timeout
	s.now = func() time.Time { return now.Add(15 * time.Minute) }
	sess, ok := s.Authenticate(token)
	if ok || sess != nil {
		t.Fatal("expected authentication to fail after idle timeout")
	}
}

func TestIdleTimeoutReset(t *testing.T) {
	s := NewStore(Config{Enabled: true, MaxLifetime: 24 * time.Hour, IdleTimeout: 10 * time.Minute})
	now := time.Now()
	s.now = func() time.Time { return now }

	_, token, _ := s.Create("agent-1", "", "")

	// Advance 8 minutes and authenticate (resets idle)
	s.now = func() time.Time { return now.Add(8 * time.Minute) }
	sess, ok := s.Authenticate(token)
	if !ok || sess == nil {
		t.Fatal("expected auth to succeed within idle window")
	}

	// Another 8 minutes from the last auth (total 16 from create, but only 8 from last use)
	s.now = func() time.Time { return now.Add(16 * time.Minute) }
	sess, ok = s.Authenticate(token)
	if !ok || sess == nil {
		t.Fatal("expected auth to succeed after idle reset")
	}
}

func TestAuthenticateWithoutTouchDoesNotResetIdleTimeout(t *testing.T) {
	s := NewStore(Config{Enabled: true, MaxLifetime: 24 * time.Hour, IdleTimeout: 10 * time.Minute})
	now := time.Now()
	s.now = func() time.Time { return now }

	id, token, _ := s.Create("agent-1", "", "")
	sess, ok := s.Get(id)
	if !ok || sess == nil {
		t.Fatal("expected session to exist")
	}
	initialLastSeen := sess.LastSeenAt

	s.now = func() time.Time { return now.Add(8 * time.Minute) }
	sess, ok = s.AuthenticateWithoutTouch(token)
	if !ok || sess == nil {
		t.Fatal("expected auth without touch to succeed within idle window")
	}
	if !sess.LastSeenAt.Equal(initialLastSeen) {
		t.Fatal("AuthenticateWithoutTouch should not update LastSeenAt")
	}

	s.now = func() time.Time { return now.Add(11 * time.Minute) }
	sess, ok = s.Authenticate(token)
	if ok || sess != nil {
		t.Fatal("expected session to expire when it was never touched")
	}
}

func TestTouchResetsIdleTimeout(t *testing.T) {
	s := NewStore(Config{Enabled: true, MaxLifetime: 24 * time.Hour, IdleTimeout: 10 * time.Minute})
	now := time.Now()
	s.now = func() time.Time { return now }

	id, token, _ := s.Create("agent-1", "", "")

	s.now = func() time.Time { return now.Add(8 * time.Minute) }
	sess, ok := s.AuthenticateWithoutTouch(token)
	if !ok || sess == nil {
		t.Fatal("expected auth without touch to succeed")
	}
	if !s.Touch(id) {
		t.Fatal("expected touch to succeed")
	}

	s.now = func() time.Time { return now.Add(16 * time.Minute) }
	sess, ok = s.Authenticate(token)
	if !ok || sess == nil {
		t.Fatal("expected auth to succeed after touch reset")
	}
}

func TestRevoke(t *testing.T) {
	s := NewStore(Config{Enabled: true})
	id, token, _ := s.Create("agent-1", "", "")

	ok := s.Revoke(id)
	if !ok {
		t.Fatal("expected revoke to succeed")
	}

	sess, ok := s.Authenticate(token)
	if ok || sess != nil {
		t.Fatal("expected authentication to fail after revoke")
	}
}

func TestRevokeNotFound(t *testing.T) {
	s := NewStore(Config{Enabled: true})
	if s.Revoke("ses_nonexistent") {
		t.Fatal("expected revoke to return false for non-existent session")
	}
}

func TestGet(t *testing.T) {
	s := NewStore(Config{Enabled: true})
	id, _, _ := s.Create("agent-1", "my label", "")

	sess, ok := s.Get(id)
	if !ok || sess == nil {
		t.Fatal("expected Get to find session")
	}
	if sess.AgentID != "agent-1" || sess.Label != "my label" {
		t.Fatal("unexpected session data")
	}
}

func TestList(t *testing.T) {
	s := NewStore(Config{Enabled: true})
	_, _, _ = s.Create("agent-1", "", "")
	_, _, _ = s.Create("agent-2", "", "")

	list := s.List()
	if len(list) != 2 {
		t.Fatalf("expected 2 sessions, got %d", len(list))
	}
}

func TestPersistAndLoad(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "sessions.json")

	s1 := NewStore(Config{Enabled: true, PersistPath: path, IdleTimeout: 1 * time.Hour, MaxLifetime: 24 * time.Hour})
	_, token, _ := s1.Create("agent-1", "persist test", "")

	// Create a new store from the same file
	s2 := NewStore(Config{Enabled: true, PersistPath: path, IdleTimeout: 1 * time.Hour, MaxLifetime: 24 * time.Hour})

	sess, ok := s2.Authenticate(token)
	if !ok || sess == nil {
		t.Fatal("expected session to survive persistence round-trip")
	}
	if sess.AgentID != "agent-1" {
		t.Fatalf("expected agent-1, got %q", sess.AgentID)
	}
}

func TestPrunedOnLoad(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "sessions.json")

	s1 := NewStore(Config{Enabled: true, PersistPath: path, MaxLifetime: 1 * time.Hour, IdleTimeout: 30 * time.Minute})
	now := time.Now()
	s1.now = func() time.Time { return now }
	_, _, _ = s1.Create("agent-1", "will expire", "")

	// Load with time advanced past expiry — set now before NewStore calls loadPersisted
	futureTime := now.Add(2 * time.Hour)
	s2 := &Store{
		sessions: make(map[string]*Session),
		now:      func() time.Time { return futureTime },
	}
	s2.applyConfig(Config{Enabled: true, PersistPath: path, MaxLifetime: 1 * time.Hour, IdleTimeout: 30 * time.Minute})
	s2.loadPersisted()

	if len(s2.List()) != 0 {
		t.Fatal("expected expired sessions to be pruned on load")
	}
}

func TestAtomicWrite(t *testing.T) {
	dir := t.TempDir()
	path := filepath.Join(dir, "sessions.json")

	s := NewStore(Config{Enabled: true, PersistPath: path})
	_, _, _ = s.Create("agent-1", "", "")

	// Verify file exists and is valid JSON
	data, err := os.ReadFile(path)
	if err != nil {
		t.Fatal(err)
	}
	var store persistedStore
	if err := json.Unmarshal(data, &store); err != nil {
		t.Fatalf("persisted file is not valid JSON: %v", err)
	}
	if len(store.Sessions) != 1 {
		t.Fatalf("expected 1 persisted session, got %d", len(store.Sessions))
	}
	// Verify no raw token in persisted data
	if strings.Contains(string(data), "ses_") && strings.Contains(string(data), `"token"`) {
		t.Fatal("raw token found in persisted data")
	}
}

func TestNilStore(t *testing.T) {
	var s *Store
	_, ok := s.Authenticate("token")
	if ok {
		t.Fatal("nil store should not authenticate")
	}
	if s.Revoke("id") {
		t.Fatal("nil store should not revoke")
	}
	if s.Enabled() {
		t.Fatal("nil store should not be enabled")
	}
	if s.List() != nil {
		t.Fatal("nil store should return nil list")
	}
}

// enabled and mode were a two-field encoding of one question and the halves
// drifted: mode was documented as reducing the auth surface and read by nothing.
// Enabled() is now the one predicate, so every consumer follows both fields.
func TestEnabledFoldsModeAndEnabled(t *testing.T) {
	for _, tt := range []struct {
		name string
		cfg  Config
		want bool
	}{
		{"enabled, mode unset", Config{Enabled: true}, true},
		{"enabled, preferred", Config{Enabled: true, Mode: ModePreferred}, true},
		{"enabled, off", Config{Enabled: true, Mode: ModeOff}, false},
		{"disabled, preferred", Config{Enabled: false, Mode: ModePreferred}, false},
		{"disabled, off", Config{Enabled: false, Mode: ModeOff}, false},
		// Every value the validator refuses, and the case variants it accepts as
		// off. The table used to cover only the two canonical spellings, so a
		// predicate that served everything but exact "off" looked correct here.
		{"enabled, required", Config{Enabled: true, Mode: ModeRequired}, false},
		{"enabled, a typo", Config{Enabled: true, Mode: "prefered"}, false},
		{"enabled, off capitalised", Config{Enabled: true, Mode: "Off"}, false},
		{"enabled, off shouted", Config{Enabled: true, Mode: "OFF"}, false},
		{"enabled, off with space", Config{Enabled: true, Mode: " off "}, false},
		{"enabled, preferred capitalised", Config{Enabled: true, Mode: " Preferred "}, true},
	} {
		if got := NewStore(tt.cfg).Enabled(); got != tt.want {
			t.Errorf("%s: Enabled() = %v, want %v", tt.name, got, tt.want)
		}
	}
}

// ModeServes is an allowlist over the normalized value, not "anything but off".
// A denylist reads every unvalidated value — a typo, a posture the server does not
// implement — as the default and leaves an auth mechanism serving, which is the
// state refusing those values exists to end.
func TestModeServesOnlyTheValuesTheValidatorAccepts(t *testing.T) {
	for _, tt := range []struct {
		mode string
		want bool
	}{
		{"", true},
		{ModePreferred, true},
		{" Preferred ", true},
		{ModeOff, false},
		{"Off", false},
		{"OFF", false},
		{" off ", false},
		{ModeRequired, false},
		{"prefered", false},
	} {
		if got := ModeServes(tt.mode); got != tt.want {
			t.Errorf("ModeServes(%q) = %v, want %v — a value the validator does not accept must never serve, and a case variant of off must mean off",
				tt.mode, got, tt.want)
		}
	}
}