vaultik/internal/database/database_test.go

//nolint:testpackage // exercises unexported migration internals
package database

import (
	"context"
	"database/sql"
	"fmt"
	"path/filepath"
	"testing"
)

func TestDatabase(t *testing.T) {
	t.Parallel()

	ctx := context.Background()
	dbPath := filepath.Join(t.TempDir(), "test.db")

	db, err := New(ctx, dbPath)
	if err != nil {
		t.Fatalf("failed to create database: %v", err)
	}

	defer func() {
		err := db.Close()
		if err != nil {
			t.Errorf("failed to close database: %v", err)
		}
	}()

	// Test connection
	if db.Conn() == nil {
		t.Fatal("database connection is nil")
	}

	// Test schema creation (already done in New via migrations)
	// Verify tables exist
	tables := []string{
		"schema_migrations",
		"files", "file_chunks", "chunks", "blobs",
		"blob_chunks", "chunk_files", "snapshots",
	}

	for _, table := range tables {
		var name string

		err := db.conn.QueryRowContext(ctx,
			"SELECT name FROM sqlite_master WHERE type='table' AND name=?", table,
		).Scan(&name)
		if err != nil {
			t.Errorf("table %s does not exist: %v", table, err)
		}
	}
}

func TestDatabaseInvalidPath(t *testing.T) {
	t.Parallel()

	ctx := context.Background()

	// Test with invalid path
	_, err := New(ctx, "/invalid/path/that/does/not/exist/test.db")
	if err == nil {
		t.Fatal("expected error for invalid path")
	}
}

func TestDatabaseConcurrentAccess(t *testing.T) {
	t.Parallel()

	ctx := context.Background()
	dbPath := filepath.Join(t.TempDir(), "test.db")

	db, err := New(ctx, dbPath)
	if err != nil {
		t.Fatalf("failed to create database: %v", err)
	}

	defer func() {
		err := db.Close()
		if err != nil {
			t.Errorf("failed to close database: %v", err)
		}
	}()

	// Test concurrent writes
	type result struct {
		index int
		err   error
	}

	results := make(chan result, 10)

	for i := range 10 {
		go func(i int) {
			_, err := db.ExecWithLog(ctx,
				"INSERT INTO chunks (chunk_hash, size) VALUES (?, ?)",
				fmt.Sprintf("hash%d", i), i*1024)
			results <- result{index: i, err: err}
		}(i)
	}

	// Wait for all goroutines and check results
	for range 10 {
		r := <-results
		if r.err != nil {
			t.Fatalf("concurrent insert %d failed: %v", r.index, r.err)
		}
	}

	// Verify all inserts succeeded
	var count int

	err = db.conn.QueryRowContext(ctx, "SELECT COUNT(*) FROM chunks").Scan(&count)
	if err != nil {
		t.Fatalf("failed to count chunks: %v", err)
	}

	if count != 10 {
		t.Errorf("expected 10 chunks, got %d", count)
	}
}

// TestNewSetsJournalModeAndBusyTimeout checks that the connection settings
// New passes reach SQLite. The driver drops a setting it does not recognise
// without an error, so only reading the value back shows it took effect.
func TestNewSetsJournalModeAndBusyTimeout(t *testing.T) {
	t.Parallel()

	ctx := context.Background()

	db, err := New(ctx, filepath.Join(t.TempDir(), "index.db"))
	if err != nil {
		t.Fatalf("failed to create database: %v", err)
	}

	defer func() { _ = db.Close() }()

	var journalMode string

	err = db.conn.QueryRowContext(ctx, "PRAGMA journal_mode").Scan(&journalMode)
	if err != nil {
		t.Fatalf("reading journal_mode: %v", err)
	}

	if journalMode != "wal" {
		t.Errorf("journal_mode = %q, want %q", journalMode, "wal")
	}

	var busyTimeout int

	err = db.conn.QueryRowContext(ctx, "PRAGMA busy_timeout").Scan(&busyTimeout)
	if err != nil {
		t.Fatalf("reading busy_timeout: %v", err)
	}

	if busyTimeout != busyTimeoutMs {
		t.Errorf("busy_timeout = %d, want %d", busyTimeout, busyTimeoutMs)
	}
}

// TestNewWriteSucceedsWhileAnotherHandleReads opens the same index twice,
// as a read-only command does while a backup runs, and checks that a write
// on one handle commits while the other is in the middle of a read.
func TestNewWriteSucceedsWhileAnotherHandleReads(t *testing.T) {
	t.Parallel()

	ctx := context.Background()
	dbPath := filepath.Join(t.TempDir(), "index.db")

	reader, err := New(ctx, dbPath)
	if err != nil {
		t.Fatalf("failed to open reading handle: %v", err)
	}

	defer func() { _ = reader.Close() }()

	writer, err := New(ctx, dbPath)
	if err != nil {
		t.Fatalf("failed to open writing handle: %v", err)
	}

	defer func() { _ = writer.Close() }()

	// The read lock taken by the SELECT is held until the transaction ends.
	readTx, err := reader.BeginTx(ctx, nil)
	if err != nil {
		t.Fatalf("beginning read transaction: %v", err)
	}

	defer func() { _ = readTx.Rollback() }()

	var count int

	err = readTx.QueryRowContext(ctx, "SELECT COUNT(*) FROM chunks").Scan(&count)
	if err != nil {
		t.Fatalf("reading chunks: %v", err)
	}

	_, err = writer.ExecWithLog(ctx,
		"INSERT INTO chunks (chunk_hash, size) VALUES (?, ?)", "hash", 1024)
	if err != nil {
		t.Fatalf("write while another handle reads: %v", err)
	}
}

func TestParseMigrationVersion(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name      string
		filename  string
		wantVer   int
		wantError bool
	}{
		{name: "valid 000.sql", filename: "000.sql", wantVer: 0, wantError: false},
		{name: "valid 001.sql", filename: "001.sql", wantVer: 1, wantError: false},
		{name: "valid 099.sql", filename: "099.sql", wantVer: 99, wantError: false},
		{
			name: "valid with description", filename: "001_initial_schema.sql",
			wantVer: 1, wantError: false,
		},
		{
			name: "valid large version", filename: "123_big_migration.sql",
			wantVer: 123, wantError: false,
		},
		{name: "invalid alpha version", filename: "abc.sql", wantVer: 0, wantError: true},
		{name: "invalid mixed chars", filename: "12a.sql", wantVer: 0, wantError: true},
		{name: "invalid no extension", filename: "schema.sql", wantVer: 0, wantError: true},
		{name: "empty string", filename: "", wantVer: 0, wantError: true},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			got, err := ParseMigrationVersion(tc.filename)
			if tc.wantError {
				if err == nil {
					t.Errorf("ParseMigrationVersion(%q) = %d, nil; want error",
						tc.filename, got)
				}

				return
			}

			if err != nil {
				t.Errorf("ParseMigrationVersion(%q) unexpected error: %v",
					tc.filename, err)

				return
			}

			if got != tc.wantVer {
				t.Errorf("ParseMigrationVersion(%q) = %d; want %d",
					tc.filename, got, tc.wantVer)
			}
		})
	}
}

func TestApplyMigrations_Idempotent(t *testing.T) {
	t.Parallel()

	ctx := context.Background()

	conn, err := sql.Open("sqlite", ":memory:?_foreign_keys=ON")
	if err != nil {
		t.Fatalf("failed to open database: %v", err)
	}

	defer func() {
		err := conn.Close()
		if err != nil {
			t.Errorf("failed to close database: %v", err)
		}
	}()

	conn.SetMaxOpenConns(1)
	conn.SetMaxIdleConns(1)

	// First run: apply all migrations.
	err = applyMigrations(ctx, conn)
	if err != nil {
		t.Fatalf("first applyMigrations failed: %v", err)
	}

	// Count rows in schema_migrations after first run.
	var countBefore int

	err = conn.QueryRowContext(ctx,
		"SELECT COUNT(*) FROM schema_migrations",
	).Scan(&countBefore)
	if err != nil {
		t.Fatalf("failed to count schema_migrations after first run: %v", err)
	}

	// Second run: must be a no-op.
	err = applyMigrations(ctx, conn)
	if err != nil {
		t.Fatalf("second applyMigrations failed: %v", err)
	}

	// Count rows in schema_migrations after second run — must be unchanged.
	var countAfter int

	err = conn.QueryRowContext(ctx,
		"SELECT COUNT(*) FROM schema_migrations",
	).Scan(&countAfter)
	if err != nil {
		t.Fatalf("failed to count schema_migrations after second run: %v", err)
	}

	if countBefore != countAfter {
		t.Errorf("schema_migrations row count changed: before=%d, after=%d",
			countBefore, countAfter)
	}
}

func TestBootstrapMigrationsTable_FreshDatabase(t *testing.T) {
	t.Parallel()

	ctx := context.Background()

	conn, err := sql.Open("sqlite", ":memory:?_foreign_keys=ON")
	if err != nil {
		t.Fatalf("failed to open database: %v", err)
	}

	defer func() {
		err := conn.Close()
		if err != nil {
			t.Errorf("failed to close database: %v", err)
		}
	}()

	conn.SetMaxOpenConns(1)
	conn.SetMaxIdleConns(1)

	// Verify schema_migrations does NOT exist yet.
	var tableBefore int

	err = conn.QueryRowContext(ctx,
		"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='schema_migrations'",
	).Scan(&tableBefore)
	if err != nil {
		t.Fatalf("failed to check for table before bootstrap: %v", err)
	}

	if tableBefore != 0 {
		t.Fatal("schema_migrations table should not exist before bootstrap")
	}

	// Run bootstrap.
	err = bootstrapMigrationsTable(ctx, conn)
	if err != nil {
		t.Fatalf("bootstrapMigrationsTable failed: %v", err)
	}

	// Verify schema_migrations now exists.
	var tableAfter int

	err = conn.QueryRowContext(ctx,
		"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='schema_migrations'",
	).Scan(&tableAfter)
	if err != nil {
		t.Fatalf("failed to check for table after bootstrap: %v", err)
	}

	if tableAfter != 1 {
		t.Fatalf("schema_migrations table should exist after bootstrap, got count=%d",
			tableAfter)
	}

	// Verify version 0 row exists.
	var version int

	err = conn.QueryRowContext(ctx,
		"SELECT version FROM schema_migrations WHERE version = 0",
	).Scan(&version)
	if err != nil {
		t.Fatalf("version 0 row not found in schema_migrations: %v", err)
	}

	if version != 0 {
		t.Errorf("expected version 0, got %d", version)
	}
}