Mathis/lemma
1
0
Fork 0
mirror of https://github.com/lordmathis/lemma.git synced 2025-11-05 23:44:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix tests for db type

Browse Source
This commit is contained in:
Matúš Námešný
2025-02-22 22:32:38 +01:00
parent d47f7d7fb0
commit 25defa5b65
12 changed files with 68 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
server/internal/app/config_test.go
View File

@@ -2,6 +2,7 @@ package app_test
import (
"lemma/internal/app"
"lemma/internal/db"
"os"
"testing"
"time"
@@ -17,7 +18,7 @@ func TestDefaultConfig(t *testing.T) {
got interface{}
expected interface{}
}{
{"DBPath", cfg.DBURL, "./lemma.db"},
{"DBPath", cfg.DBURL, "sqlite://lemma.db"},
{"WorkDir", cfg.WorkDir, "./data"},
{"StaticPath", cfg.StaticPath, "../app/dist"},
{"Port", cfg.Port, "8080"},
@@ -47,7 +48,7 @@ func TestLoad(t *testing.T) {
cleanup := func() {
envVars := []string{
"LEMMA_ENV",
"LEMMA_DB_PATH",
"LEMMA_DB_URL",
"LEMMA_WORKDIR",
"LEMMA_STATIC_PATH",
"LEMMA_PORT",
@@ -81,8 +82,8 @@ func TestLoad(t *testing.T) {
t.Fatalf("Load() error = %v", err)
}
if cfg.DBURL != "./lemma.db" {
t.Errorf("default DBPath = %v, want %v", cfg.DBURL, "./lemma.db")
if cfg.DBURL != "sqlite://lemma.db" {
t.Errorf("default DBPath = %v, want %v", cfg.DBURL, "sqlite://lemma.db")
}
})
@@ -93,7 +94,7 @@ func TestLoad(t *testing.T) {
// Set all environment variables
envs := map[string]string{
"LEMMA_ENV": "development",
"LEMMA_DB_PATH": "/custom/db/path.db",
"LEMMA_DB_URL": "sqlite:///custom/db/path.db",
"LEMMA_WORKDIR": "/custom/work/dir",
"LEMMA_STATIC_PATH": "/custom/static/path",
"LEMMA_PORT": "3000",
@@ -122,7 +123,8 @@ func TestLoad(t *testing.T) {
expected interface{}
}{
{"IsDevelopment", cfg.IsDevelopment, true},
{"DBPath", cfg.DBURL, "/custom/db/path.db"},
{"DBURL", cfg.DBURL, "/custom/db/path.db"},
{"DBType", cfg.DBType, db.DBTypeSQLite},
{"WorkDir", cfg.WorkDir, "/custom/work/dir"},
{"StaticPath", cfg.StaticPath, "/custom/static/path"},
{"Port", cfg.Port, "3000"},

2
server/internal/app/init.go
View File

@@ -30,7 +30,7 @@ func initSecretsService(cfg *Config) (secrets.Service, error) {
func initDatabase(cfg *Config, secretsService secrets.Service) (db.Database, error) {
logging.Debug("initializing database", "path", cfg.DBURL)
database, err := db.Init(cfg.DBURL, secretsService)
database, err := db.Init(cfg.DBType, cfg.DBURL, secretsService)
if err != nil {
return nil, fmt.Errorf("failed to initialize database: %w", err)
}

35
server/internal/db/db.go
View File

@@ -119,10 +119,31 @@ type database struct {
}
// Init initializes the database connection
func Init(dbPath string, secretsService secrets.Service) (Database, error) {
log := getLogger()
func Init(dbType DBType, dbURL string, secretsService secrets.Service) (Database, error) {
db, err := sql.Open("sqlite3", dbPath)
switch dbType {
case DBTypeSQLite:
db, err := initSQLite(dbURL)
if err != nil {
return nil, fmt.Errorf("failed to initialize SQLite database: %w", err)
}
database := &database{
DB: db,
secretsService: secretsService,
dbType: dbType,
}
return database, nil
case DBTypePostgres:
return nil, fmt.Errorf("postgres database not supported yet")
}
return nil, fmt.Errorf("unsupported database type: %s", dbType)
}
func initSQLite(dbURL string) (*sql.DB, error) {
log := getLogger()
db, err := sql.Open("sqlite3", dbURL)
if err != nil {
return nil, fmt.Errorf("failed to open database: %w", err)
}
@@ -136,13 +157,7 @@ func Init(dbPath string, secretsService secrets.Service) (Database, error) {
return nil, fmt.Errorf("failed to enable foreign keys: %w", err)
}
log.Debug("foreign keys enabled")
database := &database{
DB: db,
secretsService: secretsService,
}
return database, nil
return db, nil
}
// Close closes the database connection

9
server/internal/db/migrations.go
View File

@@ -25,9 +25,8 @@ func (db *database) Migrate() error {
var m *migrate.Migrate
driverName := db.dbType
switch driverName {
case "postgres":
switch db.dbType {
case DBTypePostgres:
driver, err := postgres.WithInstance(db.DB, &postgres.Config{})
if err != nil {
return fmt.Errorf("failed to create postgres driver: %w", err)
@@ -37,7 +36,7 @@ func (db *database) Migrate() error {
return fmt.Errorf("failed to create migrate instance: %w", err)
}
case "sqlite3":
case DBTypeSQLite:
driver, err := sqlite3.WithInstance(db.DB, &sqlite3.Config{})
if err != nil {
return fmt.Errorf("failed to create sqlite driver: %w", err)
@@ -48,7 +47,7 @@ func (db *database) Migrate() error {
}
default:
return fmt.Errorf("unsupported database driver: %s", driverName)
return fmt.Errorf("unsupported database driver: %s", db.dbType)
}
if err := m.Up(); err != nil && err != migrate.ErrNoChange {

4
server/internal/db/migrations/001_initial_schema.up.sql
View File

@@ -1,7 +1,7 @@
-- 001_initial_schema.up.sql
-- Create users table
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTO_INCREMENT,
id INTEGER PRIMARY KEY AUTOINCREMENT,
email TEXT NOT NULL UNIQUE,
display_name TEXT,
password_hash TEXT NOT NULL,
@@ -12,7 +12,7 @@ CREATE TABLE IF NOT EXISTS users (
-- Create workspaces table with integrated settings
CREATE TABLE IF NOT EXISTS workspaces (
id INTEGER PRIMARY KEY AUTO_INCREMENT,
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id INTEGER NOT NULL,
name TEXT NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,

108
server/internal/db/migrations_test.go
View File

@@ -1,53 +1,36 @@
package db_test
import (
"testing"
"lemma/internal/db"
_ "lemma/internal/testenv"
"testing"
_ "github.com/mattn/go-sqlite3"
)
func TestMigrate(t *testing.T) {
database, err := db.NewTestDB(":memory:", &mockSecrets{})
database, err := db.NewTestDB(&mockSecrets{})
if err != nil {
t.Fatalf("failed to initialize database: %v", err)
}
defer database.Close()
t.Run("migrations are applied in order", func(t *testing.T) {
if err := database.Migrate(); err != nil {
t.Fatalf("failed to run initial migrations: %v", err)
}
// Check migration version
var version int
err := database.TestDB().QueryRow("SELECT MAX(version) FROM migrations").Scan(&version)
if err != nil {
t.Fatalf("failed to get migration version: %v", err)
}
if version != 1 { // Current number of migrations in production code
t.Errorf("expected migration version 1, got %d", version)
}
// Verify number of migration entries matches versions applied
var count int
err = database.TestDB().QueryRow("SELECT COUNT(*) FROM migrations").Scan(&count)
if err != nil {
t.Fatalf("failed to count migrations: %v", err)
}
if count != 1 {
t.Errorf("expected 1 migration entries, got %d", count)
}
})
t.Run("migrations create expected schema", func(t *testing.T) {
// Run migrations
if err := database.Migrate(); err != nil {
t.Fatalf("failed to run migrations: %v", err)
}
// Verify tables exist
tables := []string{"users", "workspaces", "sessions", "system_settings", "migrations"}
tables := []string{
"users",
"workspaces",
"sessions",
"system_settings",
// Note: golang-migrate uses its own migrations table
"schema_migrations",
}
for _, table := range tables {
if !tableExists(t, database, table) {
t.Errorf("table %q does not exist", table)
@@ -63,91 +46,32 @@ func TestMigrate(t *testing.T) {
{"sessions", "idx_sessions_expires_at"},
{"sessions", "idx_sessions_refresh_token"},
}
for _, idx := range indexes {
if !indexExists(t, database, idx.table, idx.name) {
t.Errorf("index %q on table %q does not exist", idx.name, idx.table)
}
}
})
t.Run("migrations are idempotent", func(t *testing.T) {
// Run migrations again
if err := database.Migrate(); err != nil {
t.Fatalf("failed to re-run migrations: %v", err)
}
// Verify migration count hasn't changed
var count int
err = database.TestDB().QueryRow("SELECT COUNT(*) FROM migrations").Scan(&count)
if err != nil {
t.Fatalf("failed to count migrations: %v", err)
}
if count != 1 {
t.Errorf("expected 1 migration entries, got %d", count)
}
})
t.Run("rollback on migration failure", func(t *testing.T) {
// Create a test table that would conflict with a failing migration
_, err := database.TestDB().Exec("CREATE TABLE test_rollback (id INTEGER PRIMARY KEY)")
if err != nil {
t.Fatalf("failed to create test table: %v", err)
}
// Start transaction
tx, err := database.Begin()
if err != nil {
t.Fatalf("failed to start transaction: %v", err)
}
// Try operations that should fail and rollback
_, err = tx.Exec(`
CREATE TABLE test_rollback (id INTEGER PRIMARY KEY);
INSERT INTO nonexistent_table VALUES (1);
`)
if err == nil {
tx.Rollback()
t.Fatal("expected migration to fail")
}
tx.Rollback()
// Verify the migration version hasn't changed
var version int
err = database.TestDB().QueryRow("SELECT MAX(version) FROM migrations").Scan(&version)
if err != nil {
t.Fatalf("failed to get migration version: %v", err)
}
if version != 1 {
t.Errorf("expected migration version to remain at 1, got %d", version)
}
})
}
func tableExists(t *testing.T, database db.TestDatabase, tableName string) bool {
t.Helper()
var name string
err := database.TestDB().QueryRow(`
SELECT name FROM sqlite_master
WHERE type='table' AND name=?`,
tableName,
).Scan(&name)
return err == nil
}
func indexExists(t *testing.T, database db.TestDatabase, tableName, indexName string) bool {
t.Helper()
var name string
err := database.TestDB().QueryRow(`
SELECT name FROM sqlite_master
WHERE type='index' AND tbl_name=? AND name=?`,
tableName, indexName,
).Scan(&name)
return err == nil
}

2
server/internal/db/sessions_test.go
View File

@@ -13,7 +13,7 @@ import (
)
func TestSessionOperations(t *testing.T) {
database, err := db.NewTestDB(":memory:", &mockSecrets{})
database, err := db.NewTestDB(&mockSecrets{})
if err != nil {
t.Fatalf("failed to create test database: %v", err)
}

2
server/internal/db/system_test.go
View File

@@ -15,7 +15,7 @@ import (
)
func TestSystemOperations(t *testing.T) {
database, err := db.NewTestDB(":memory:", &mockSecrets{})
database, err := db.NewTestDB(&mockSecrets{})
if err != nil {
t.Fatalf("failed to create test database: %v", err)
}

4
server/internal/db/testdb.go
View File

@@ -12,8 +12,8 @@ type TestDatabase interface {
TestDB() *sql.DB
}
func NewTestDB(dbPath string, secretsService secrets.Service) (TestDatabase, error) {
db, err := Init(dbPath, secretsService)
func NewTestDB(secretsService secrets.Service) (TestDatabase, error) {
db, err := Init(DBTypeSQLite, ":memory:", secretsService)
if err != nil {
return nil, err
}

2
server/internal/db/users_test.go
View File

@@ -10,7 +10,7 @@ import (
)
func TestUserOperations(t *testing.T) {
database, err := db.NewTestDB(":memory:", &mockSecrets{})
database, err := db.NewTestDB(&mockSecrets{})
if err != nil {
t.Fatalf("failed to create test database: %v", err)
}

2
server/internal/db/workspaces_test.go
View File

@@ -10,7 +10,7 @@ import (
)
func TestWorkspaceOperations(t *testing.T) {
database, err := db.NewTestDB(":memory:", &mockSecrets{})
database, err := db.NewTestDB(&mockSecrets{})
if err != nil {
t.Fatalf("failed to create test database: %v", err)
}

4
server/internal/handlers/integration_test.go
View File

@@ -61,7 +61,7 @@ func setupTestHarness(t *testing.T) *testHarness {
t.Fatalf("Failed to initialize secrets service: %v", err)
}
database, err := db.NewTestDB(":memory:", secretsSvc)
database, err := db.NewTestDB(secretsSvc)
if err != nil {
t.Fatalf("Failed to initialize test database: %v", err)
}
@@ -99,7 +99,7 @@ func setupTestHarness(t *testing.T) *testHarness {
// Create test config
testConfig := &app.Config{
DBURL: ":memory:",
DBURL: "sqlite://:memory:",
WorkDir: tempDir,
StaticPath: "../testdata",
Port: "8081",