test(data): add missing tests for audit fix coverage

Add unit tests for previously uncovered vendored sqlite functions:

- ddlmod: TestRemoveColumn (quoted/unquoted/not-found variants),
  TestClone (deep copy independence), TestRenameTable (quoted/unquoted)
- sqlite: TestOpen, TestDefaultValueOf, TestDataTypeOf (all branches),
  TestExplain, TestQuoteTo, TestSavePointAndRollbackTo,
  TestTranslateForeignKeyViolation

Raises sqlite package coverage from 38.7% to 49.5%. Remaining
uncovered code is migrator methods deeply coupled to GORM internals,
exercised by the internal/data integration tests.

Also adds -timeout 5m to CI test and benchmark steps to catch hangs.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: cpcloud

.github/workflows/ci.yml

@@ -48,13 +48,13 @@ jobs:
         run: echo "MICASA_TEST_SEED=${{ github.run_id }}"
 
       - name: Test
-        run: go test -race -shuffle on -v -coverprofile coverage.txt ./...
+        run: go test -race -shuffle on -timeout 5m -v -coverprofile coverage.txt ./...
         env:
           CGO_ENABLED: "1"
           MICASA_TEST_SEED: ${{ github.run_id }}
 
       - name: Benchmarks (smoke)
-        run: go test -bench . -benchtime 1x -run '^$' ./...
+        run: go test -bench . -benchtime 1x -timeout 5m -run '^$' ./...
 
       - name: Coverage summary
         run: go tool cover -func coverage.txt

internal/data/sqlite/ddlmod_test.go

@@ -509,6 +509,131 @@ func TestRemoveConstraint(t *testing.T) {
 	}
 }
 
+func TestRemoveColumn(t *testing.T) {
+	tests := []struct {
+		name    string
+		fields  []string
+		column  string
+		success bool
+		expect  []string
+	}{
+		{
+			name:    "backtick_quoted",
+			fields:  []string{"`id` integer NOT NULL", "`name` text"},
+			column:  "name",
+			success: true,
+			expect:  []string{"`id` integer NOT NULL"},
+		},
+		{
+			name:    "double_quoted",
+			fields:  []string{`"id" integer NOT NULL`, `"name" text`},
+			column:  "name",
+			success: true,
+			expect:  []string{`"id" integer NOT NULL`},
+		},
+		{
+			name:    "single_quoted",
+			fields:  []string{"'id' integer NOT NULL", "'name' text"},
+			column:  "name",
+			success: true,
+			expect:  []string{"'id' integer NOT NULL"},
+		},
+		{
+			name:    "unquoted",
+			fields:  []string{"id integer NOT NULL", "name text"},
+			column:  "name",
+			success: true,
+			expect:  []string{"id integer NOT NULL"},
+		},
+		{
+			name:    "not_found",
+			fields:  []string{"`id` integer NOT NULL", "`name` text"},
+			column:  "missing",
+			success: false,
+			expect:  []string{"`id` integer NOT NULL", "`name` text"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := ddl{fields: tt.fields}
+			ok := d.removeColumn(tt.column)
+			assert.Equal(t, tt.success, ok)
+			assert.Equal(t, tt.expect, d.fields)
+		})
+	}
+}
+
+func TestClone(t *testing.T) {
+	original := &ddl{
+		head:   "CREATE TABLE `test`",
+		fields: []string{"`id` integer NOT NULL", "`name` text"},
+		columns: []migrator.ColumnType{
+			{NameValue: sql.NullString{String: "id", Valid: true}},
+		},
+	}
+
+	cloned := original.clone()
+
+	// Values should be equal
+	assert.Equal(t, original.head, cloned.head)
+	assert.Equal(t, original.fields, cloned.fields)
+	assert.Equal(t, original.columns, cloned.columns)
+
+	// Mutating the clone should not affect the original
+	cloned.fields[0] = "changed"
+	assert.NotEqual(t, original.fields[0], cloned.fields[0])
+}
+
+func TestRenameTable(t *testing.T) {
+	tests := []struct {
+		name    string
+		head    string
+		src     string
+		dst     string
+		wantErr bool
+	}{
+		{
+			name: "backtick_quoted",
+			head: "CREATE TABLE `users`",
+			src:  "users",
+			dst:  "users__temp",
+		},
+		{
+			name: "double_quoted",
+			head: `CREATE TABLE "users"`,
+			src:  "users",
+			dst:  "users__temp",
+		},
+		{
+			name: "unquoted",
+			head: "CREATE TABLE users",
+			src:  "users",
+			dst:  "users__temp",
+		},
+		{
+			name:    "not_found",
+			head:    "CREATE TABLE `something`",
+			src:     "other",
+			dst:     "other__temp",
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &ddl{head: tt.head}
+			err := d.renameTable(tt.dst, tt.src)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Contains(t, d.head, tt.dst)
+			}
+		})
+	}
+}
+
 func TestGetColumns(t *testing.T) {
 	params := []struct {
 		name    string

internal/data/sqlite/sqlite_test.go

@@ -11,12 +11,15 @@ package sqlite
 import (
 	"database/sql"
 	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
 	"gorm.io/gorm/logger"
+	"gorm.io/gorm/schema"
 
 	modernsqlite "modernc.org/sqlite"
 )
@@ -126,6 +129,137 @@ func TestSQLiteVersion(t *testing.T) {
 	t.Logf("SQLite version: %s", version)
 }
 
+func TestOpen(t *testing.T) {
+	d := Open(inMemoryDSN)
+	assert.Equal(t, "sqlite", d.Name())
+
+	dialector, ok := d.(*Dialector)
+	require.True(t, ok)
+	assert.Equal(t, inMemoryDSN, dialector.DSN)
+	assert.Empty(t, dialector.DriverName)
+}
+
+func TestDefaultValueOf(t *testing.T) {
+	d := Dialector{}
+
+	auto := d.DefaultValueOf(&schema.Field{AutoIncrement: true})
+	assert.Equal(t, clause.Expr{SQL: "NULL"}, auto)
+
+	normal := d.DefaultValueOf(&schema.Field{AutoIncrement: false})
+	assert.Equal(t, clause.Expr{SQL: "DEFAULT"}, normal)
+}
+
+func TestDataTypeOf(t *testing.T) {
+	d := Dialector{}
+
+	tests := []struct {
+		field *schema.Field
+		want  string
+	}{
+		{&schema.Field{DataType: schema.Bool}, "numeric"},
+		{&schema.Field{DataType: schema.Int}, "integer"},
+		{
+			&schema.Field{DataType: schema.Int, AutoIncrement: true},
+			"integer PRIMARY KEY AUTOINCREMENT",
+		},
+		{&schema.Field{DataType: schema.Uint}, "integer"},
+		{&schema.Field{DataType: schema.Float}, "real"},
+		{&schema.Field{DataType: schema.String}, "text"},
+		{&schema.Field{DataType: schema.Time}, "datetime"},
+		{
+			&schema.Field{DataType: schema.Time, TagSettings: map[string]string{"TYPE": "date"}},
+			"date",
+		},
+		{&schema.Field{DataType: schema.Bytes}, "blob"},
+		{&schema.Field{DataType: "custom_type"}, "custom_type"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.want, func(t *testing.T) {
+			assert.Equal(t, tt.want, d.DataTypeOf(tt.field))
+		})
+	}
+}
+
+func TestExplain(t *testing.T) {
+	d := Dialector{}
+	result := d.Explain("SELECT * FROM users WHERE id = ?", 42)
+	assert.Contains(t, result, "42")
+	assert.Contains(t, result, "SELECT")
+}
+
+func TestQuoteTo(t *testing.T) {
+	d := Dialector{}
+
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{"simple", "`simple`"},
+		{"schema.table", "`schema`.`table`"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			var buf strings.Builder
+			d.QuoteTo(&buf, tt.input)
+			assert.Equal(t, tt.want, buf.String())
+		})
+	}
+}
+
+func TestSavePointAndRollbackTo(t *testing.T) {
+	db, err := gorm.Open(&Dialector{DSN: "file:test_savepoint?mode=memory"}, &gorm.Config{
+		Logger:                 logger.Default.LogMode(logger.Silent),
+		SkipDefaultTransaction: true,
+	})
+	require.NoError(t, err)
+
+	type Item struct {
+		ID   uint
+		Name string
+	}
+	require.NoError(t, db.AutoMigrate(&Item{}))
+
+	d := Dialector{}
+
+	require.NoError(t, db.Create(&Item{Name: "before"}).Error)
+
+	require.NoError(t, d.SavePoint(db, "sp1"))
+	require.NoError(t, db.Create(&Item{Name: "after_savepoint"}).Error)
+	require.NoError(t, d.RollbackTo(db, "sp1"))
+
+	var count int64
+	db.Model(&Item{}).Where("name = ?", "after_savepoint").Count(&count)
+	assert.Equal(t, int64(0), count, "rollback should have undone the insert")
+}
+
+func TestTranslateForeignKeyViolation(t *testing.T) {
+	db, err := gorm.Open(&Dialector{DSN: "file:test_fk_violation?mode=memory"}, &gorm.Config{
+		Logger:         logger.Default.LogMode(logger.Silent),
+		TranslateError: true,
+	})
+	require.NoError(t, err)
+
+	// Enable foreign keys
+	require.NoError(t, db.Exec("PRAGMA foreign_keys = ON").Error)
+
+	type Parent struct {
+		ID uint `gorm:"primarykey"`
+	}
+	type Child struct {
+		ID       uint `gorm:"primarykey"`
+		ParentID uint
+		Parent   Parent `gorm:"foreignKey:ParentID"`
+	}
+	require.NoError(t, db.AutoMigrate(&Parent{}, &Child{}))
+
+	// Insert a child referencing a non-existent parent
+	err = db.Create(&Child{ParentID: 9999}).Error
+	require.Error(t, err)
+	assert.ErrorIs(t, err, gorm.ErrForeignKeyViolated)
+}
+
 func TestCompareVersion(t *testing.T) {
 	tests := []struct {
 		v1, v2 string