Commilitia-Drop/internal/db/bootstrap_test.go

package db

import (
	"context"
	"path/filepath"
	"sort"
	"testing"
)

func TestBootstrapCreatesAllTables(t *testing.T) {
	tmp := filepath.Join(t.TempDir(), "test.db")
	d, err := Open(tmp)
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer d.Close()

	if err := Bootstrap(context.Background(), d); err != nil {
		t.Fatalf("bootstrap: %v", err)
	}

	want := []string{"clipboard_state", "devices", "login_requests", "push_subscriptions", "transfer_sessions"}
	rows, err := d.Query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name")
	if err != nil {
		t.Fatalf("query tables: %v", err)
	}
	defer rows.Close()

	var got []string
	for rows.Next() {
		var name string
		if err := rows.Scan(&name); err != nil {
			t.Fatalf("scan: %v", err)
		}
		got = append(got, name)
	}
	sort.Strings(got)
	if len(got) != len(want) {
		t.Fatalf("table count: got %v, want %v", got, want)
	}
	for i := range want {
		if got[i] != want[i] {
			t.Errorf("table[%d]: got %q, want %q", i, got[i], want[i])
		}
	}
}

func TestBootstrapIsIdempotent(t *testing.T) {
	tmp := filepath.Join(t.TempDir(), "test.db")
	d, err := Open(tmp)
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer d.Close()

	for i := 0; i < 3; i++ {
		if err := Bootstrap(context.Background(), d); err != nil {
			t.Fatalf("bootstrap iter %d: %v", i, err)
		}
	}
}

func TestOpenEnablesWALMode(t *testing.T) {
	tmp := filepath.Join(t.TempDir(), "test.db")
	d, err := Open(tmp)
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer d.Close()

	var mode string
	if err := d.QueryRow("PRAGMA journal_mode").Scan(&mode); err != nil {
		t.Fatalf("pragma: %v", err)
	}
	if mode != "wal" {
		t.Errorf("journal_mode: got %q, want %q", mode, "wal")
	}
}

// Simulates the prod upgrade: a clipboard_state created before the version
// column existed must gain it (defaulting to 0) on bootstrap, idempotently.
func TestBootstrapAddsClipboardVersionToLegacyDB(t *testing.T) {
	tmp := filepath.Join(t.TempDir(), "legacy.db")
	d, err := Open(tmp)
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer d.Close()

	_, err = d.Exec(`CREATE TABLE clipboard_state (
		user_id TEXT PRIMARY KEY, content_type TEXT NOT NULL, content TEXT,
		source_device TEXT, updated_at INTEGER NOT NULL)`)
	if err != nil {
		t.Fatalf("legacy schema: %v", err)
	}
	if _, err := d.Exec(`INSERT INTO clipboard_state (user_id, content_type, content, updated_at)
		VALUES ('u', 'text/plain', 'hi', 100)`); err != nil {
		t.Fatalf("seed row: %v", err)
	}

	if err := Bootstrap(context.Background(), d); err != nil {
		t.Fatalf("bootstrap: %v", err)
	}

	var version int64
	if err := d.QueryRow(`SELECT version FROM clipboard_state WHERE user_id='u'`).Scan(&version); err != nil {
		t.Fatalf("select version (column missing?): %v", err)
	}
	if version != 0 {
		t.Errorf("legacy row version: got %d, want 0", version)
	}
	// Second bootstrap must be a no-op (column already present).
	if err := Bootstrap(context.Background(), d); err != nil {
		t.Fatalf("second bootstrap: %v", err)
	}
}

// Simulates the prod upgrade to the Auth Broker model: a legacy devices table keyed
// (user_id, name) must be recreated with the device_id primary key. The ephemeral
// device rows are dropped (re-created on the next request / scan), and the migration
// is idempotent.
func TestBootstrapRecreatesLegacyDevices(t *testing.T) {
	tmp := filepath.Join(t.TempDir(), "legacy.db")
	d, err := Open(tmp)
	if err != nil {
		t.Fatalf("open: %v", err)
	}
	defer d.Close()

	if _, err := d.Exec(`CREATE TABLE devices (
		user_id TEXT NOT NULL, name TEXT NOT NULL, type TEXT NOT NULL,
		last_seen INTEGER NOT NULL, PRIMARY KEY (user_id, name))`); err != nil {
		t.Fatalf("legacy schema: %v", err)
	}
	if _, err := d.Exec(`INSERT INTO devices (user_id, name, type, last_seen) VALUES ('u','old','browser',1)`); err != nil {
		t.Fatalf("seed row: %v", err)
	}

	if err := Bootstrap(context.Background(), d); err != nil {
		t.Fatalf("bootstrap: %v", err)
	}

	// The table now has the device_id-keyed shape (this insert would fail otherwise).
	if _, err := d.Exec(`INSERT INTO devices (device_id, user_id, name, type, tier, broker_sid, created_at, last_seen)
		VALUES ('dev_1','u','New','browser','full','sid',1,1)`); err != nil {
		t.Fatalf("new schema insert (device_id missing?): %v", err)
	}
	// The legacy row was dropped with the table.
	var legacy int
	if err := d.QueryRow(`SELECT COUNT(*) FROM devices WHERE name='old'`).Scan(&legacy); err != nil {
		t.Fatalf("count legacy: %v", err)
	}
	if legacy != 0 {
		t.Errorf("legacy device row should be dropped on recreate; got %d", legacy)
	}

	// Idempotent: a second bootstrap leaves the new shape and its rows intact.
	if err := Bootstrap(context.Background(), d); err != nil {
		t.Fatalf("second bootstrap: %v", err)
	}
	var kept int
	if err := d.QueryRow(`SELECT COUNT(*) FROM devices WHERE device_id='dev_1'`).Scan(&kept); err != nil {
		t.Fatalf("count after second bootstrap: %v", err)
	}
	if kept != 1 {
		t.Errorf("device row should survive idempotent bootstrap; got %d", kept)
	}
}