Merge pull request #31 from AlphaOne1/separate_test_package

Add internal test exports and improve golangci-lint configuration

Author: AlphaOne1

.github/workflows/codeql.yml

@@ -82,7 +82,7 @@ jobs:
                 # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
                 # queries: security-extended,security-and-quality
 
-          # If the analyze step fails for one of the languages you are analyzing with
+          # If the "analyze" step fails for one of the languages you are analyzing with
           # "We were unable to automatically build your code", modify the matrix above
           # to set the build mode to "manual" for that language. Then modify this step
           # to build your code.

.golangci.yaml

@@ -1,3 +1,6 @@
+# Copyright the dmorph contributors.
+# SPDX-License-Identifier: MPL-2.0
+
 # Configuration file for golangci-lint
 # See https://golangci-lint.run/usage/configuration/ for more information
 
@@ -9,25 +12,85 @@ run:
 
 linters:
     default: all
-    #enable:
-    #    # Default linters
-    #    - errcheck
-    #    - govet
-    #    - ineffassign
-    #    - staticcheck
-    #    - unused
-    #    # Additional linters
-    #    - gosec
-    #    - misspell
-    #    - revive
-    #    - bodyclose
-    #    - noctx
+
+    disable:
+        - exhaustruct
+        - forbidigo
+        - noinlineerr
+        - nonamedreturns
+        - wsl
+        - wsl_v5
 
     exclusions:
+        warn-unused: true
+
         rules:
-            - path: main_test.go
+            - path: _test\.go
               linters:
-                  - gosec
+                  - cyclop
+                  - dupl
+                  - dupword
+                  - err113
+                  - funlen
+                  - gocognit
+                  - maintidx
+                  - nestif
+
+            - path: examples/
+              linters:
+                  - err113
+
+    settings:
+        cyclop:
+            max-complexity: 25
+
+        depguard:
+            rules:
+                main:
+                    files:
+                        - $all
+                        - "!$test"
+                        - "!**/examples/**/*"
+                    allow:
+                        - $gostd
+                test:
+                    files:
+                        - $test
+                        - "**/examples/**/*"
+                    allow:
+                        - $gostd
+                        - github.com/stretchr/testify/assert
+                        - github.com/stretchr/testify/require
+                        - github.com/AlphaOne1/dmorph
+                        - modernc.org/sqlite
+
+        exhaustive:
+            default-signifies-exhaustive: true
+
+        mnd:
+            ignored-numbers:
+                - "2"
+
+        paralleltest:
+            ignore-missing: true
+
+        perfsprint:
+            errorf: false
+
+        testpackage:
+            skip-regexp: internal_test\.go
+
+        varnamelen:
+            max-distance: 10
+            ignore-names:
+              - ctx
+              - db
+              - err
+              - tx
+
+        whitespace:
+            multi-if: true
+            multi-func: true
 
 issues:
     max-issues-per-linter: 0

dialects.go

@@ -4,48 +4,58 @@
 package dmorph
 
 import (
+	"context"
 	"database/sql"
 	"errors"
 	"fmt"
 )
 
 // BaseDialect is a convenience type for databases that manage the necessary operations solely using
 // queries. Defining the CreateTemplate, AppliedTemplate and RegisterTemplate enables the BaseDialect to
-// perform all the necessary operation to fulfill the Dialect interface.
+// perform all the necessary operations to fulfill the Dialect interface.
 type BaseDialect struct {
 	CreateTemplate   string // statement ensuring the existence of the migration table
 	AppliedTemplate  string // statement getting applied migrations ordered by application date
 	RegisterTemplate string // statement registering a migration
 }
 
 // EnsureMigrationTableExists ensures that the migration table, saving the applied migrations ids, exists.
-func (b BaseDialect) EnsureMigrationTableExists(db *sql.DB, tableName string) error {
-	tx, err := db.Begin()
+func (b BaseDialect) EnsureMigrationTableExists(ctx context.Context, db *sql.DB, tableName string) error {
+	tx, err := db.BeginTx(ctx, nil)
 
 	if err != nil {
 		return err
 	}
 
-	defer func() { _ = tx.Rollback() }()
-
-	_, execErr := tx.Exec(fmt.Sprintf(b.CreateTemplate, tableName))
+	// Safety net for unexpected panics
+	defer func() {
+		if tx != nil {
+			_ = tx.Rollback()
+		}
+	}()
 
-	if execErr != nil {
+	if _, execErr := tx.ExecContext(ctx, fmt.Sprintf(b.CreateTemplate, tableName)); execErr != nil {
 		rollbackErr := tx.Rollback()
+		tx = nil
+
 		return errors.Join(execErr, rollbackErr)
 	}
 
 	if err := tx.Commit(); err != nil {
 		rollbackErr := tx.Rollback()
+		tx = nil
+
 		return errors.Join(err, rollbackErr)
 	}
 
+	tx = nil
+
 	return nil
 }
 
 // AppliedMigrations gets the already applied migrations from the database, ordered by application date.
-func (b BaseDialect) AppliedMigrations(db *sql.DB, tableName string) ([]string, error) {
-	rows, rowsErr := db.Query(fmt.Sprintf(b.AppliedTemplate, tableName))
+func (b BaseDialect) AppliedMigrations(ctx context.Context, db *sql.DB, tableName string) ([]string, error) {
+	rows, rowsErr := db.QueryContext(ctx, fmt.Sprintf(b.AppliedTemplate, tableName))
 
 	if rowsErr != nil {
 		return nil, rowsErr
@@ -67,8 +77,8 @@ func (b BaseDialect) AppliedMigrations(db *sql.DB, tableName string) ([]string,
 }
 
 // RegisterMigration registers a migration in the migration table.
-func (b BaseDialect) RegisterMigration(tx *sql.Tx, id string, tableName string) error {
-	_, err := tx.Exec(fmt.Sprintf(b.RegisterTemplate, tableName),
+func (b BaseDialect) RegisterMigration(ctx context.Context, tx *sql.Tx, id string, tableName string) error {
+	_, err := tx.ExecContext(ctx, fmt.Sprintf(b.RegisterTemplate, tableName),
 		sql.Named("id", id))
 
 	return err

dialects_test.go

@@ -1,15 +1,15 @@
 // Copyright the DMorph contributors.
 // SPDX-License-Identifier: MPL-2.0
 
-package dmorph
+package dmorph_test
 
 import (
-	"database/sql"
-	"os"
-	"regexp"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/AlphaOne1/dmorph"
 )
 
 // TestDialectStatements verifies that each database dialect has valid and
@@ -19,19 +19,17 @@ func TestDialectStatements(t *testing.T) {
 	// that the statements for the databases are somehow filled
 	tests := []struct {
 		name   string
-		caller func() BaseDialect
+		caller func() dmorph.BaseDialect
 	}{
-		{name: "CSVQ", caller: DialectCSVQ},
-		{name: "DB2", caller: DialectDB2},
-		{name: "MSSQL", caller: DialectMSSQL},
-		{name: "MySQL", caller: DialectMySQL},
-		{name: "Oracle", caller: DialectOracle},
-		{name: "Postgres", caller: DialectPostgres},
-		{name: "SQLite", caller: DialectSQLite},
+		{name: "CSVQ", caller: dmorph.DialectCSVQ},
+		{name: "DB2", caller: dmorph.DialectDB2},
+		{name: "MSSQL", caller: dmorph.DialectMSSQL},
+		{name: "MySQL", caller: dmorph.DialectMySQL},
+		{name: "Oracle", caller: dmorph.DialectOracle},
+		{name: "Postgres", caller: dmorph.DialectPostgres},
+		{name: "SQLite", caller: dmorph.DialectSQLite},
 	}
 
-	re := regexp.MustCompile("%s")
-
 	for k, v := range tests {
 		d := v.caller()
 
@@ -40,83 +38,54 @@ func TestDialectStatements(t *testing.T) {
 		}
 		assert.Contains(t, d.CreateTemplate, "%s",
 			"no table name placeholder in create template for", v.name)
-		assert.Regexp(t, re, d.CreateTemplate)
 
 		if len(d.AppliedTemplate) < 10 {
 			t.Errorf("%v: applied template is too short for %v", k, v.name)
 		}
 		assert.Contains(t, d.AppliedTemplate, "%s",
 			"no table name placeholder in applied template for", v.name)
-		assert.Regexp(t, re, d.AppliedTemplate)
 
 		if len(d.RegisterTemplate) < 10 {
 			t.Errorf("%v: register template is too short for %v", k, v.name)
 		}
 		assert.Contains(t, d.RegisterTemplate, "%s",
 			"no table name placeholder in register template for", v.name)
-		assert.Regexp(t, re, d.RegisterTemplate)
 	}
 }
 
 // TestCallsOnClosedDB verifies that methods fail as expected when called on a closed database connection.
 func TestCallsOnClosedDB(t *testing.T) {
-	dbFile, dbFileErr := prepareDB()
-
-	if dbFileErr != nil {
-		t.Errorf("DB file could not be created: %v", dbFileErr)
-	} else {
-		defer func() { _ = os.Remove(dbFile) }()
-	}
-
-	db, dbErr := sql.Open("sqlite", dbFile)
-
-	if dbErr != nil {
-		t.Errorf("DB file could not be created: %v", dbErr)
-	} else {
-		_ = db.Close()
-	}
+	db := openTempSQLite(t)
+	require.NoError(t, db.Close())
 
 	assert.Error(t,
-		DialectSQLite().EnsureMigrationTableExists(db, "irrelevant"),
+		dmorph.DialectSQLite().EnsureMigrationTableExists(t.Context(), db, "irrelevant"),
 		"expected error on closed database")
 
-	_, err := DialectSQLite().AppliedMigrations(db, "irrelevant")
+	_, err := dmorph.DialectSQLite().AppliedMigrations(t.Context(), db, "irrelevant")
 	assert.Error(t, err, "expected error on closed database")
 }
 
 // TestEnsureMigrationTableExistsSQLError tests the EnsureMigrationTableExists function
 // for handling SQL errors during execution.
 func TestEnsureMigrationTableExistsSQLError(t *testing.T) {
-	d := BaseDialect{
+	dialect := dmorph.BaseDialect{
 		CreateTemplate: `
             CRATE TABLE test (
                 id        VARCHAR(255) PRIMARY KEY,
                 create_ts TIMESTAMP DEFAULT CURRENT_TIMESTAMP
             )`,
 	}
 
-	dbFile, dbFileErr := prepareDB()
-
-	if dbFileErr != nil {
-		t.Errorf("DB file could not be created: %v", dbFileErr)
-	} else {
-		defer func() { _ = os.Remove(dbFile) }()
-	}
+	db := openTempSQLite(t)
 
-	db, dbErr := sql.Open("sqlite", dbFile)
-
-	if dbErr != nil {
-		t.Errorf("DB file could not be created: %v", dbErr)
-	} else {
-		defer func() { _ = db.Close() }()
-	}
-
-	assert.Error(t, d.EnsureMigrationTableExists(db, "test"), "expected error")
+	assert.Error(t, dialect.EnsureMigrationTableExists(t.Context(), db, "test"), "expected error")
 }
 
-// TestEnsureMigrationTableExistsCommitError tests the behavior of EnsureMigrationTableExists when a commit error occurs.
+// TestEnsureMigrationTableExistsCommitError tests the behavior of EnsureMigrationTableExists
+// when a commit error occurs.
 func TestEnsureMigrationTableExistsCommitError(t *testing.T) {
-	d := BaseDialect{
+	dialect := dmorph.BaseDialect{
 		CreateTemplate: `
 			CREATE TABLE t0 (
 			    id INTEGER PRIMARY KEY
@@ -134,25 +103,11 @@ func TestEnsureMigrationTableExistsCommitError(t *testing.T) {
 			DELETE FROM t0 WHERE id = 1;`,
 	}
 
-	dbFile, dbFileErr := prepareDB()
-
-	if dbFileErr != nil {
-		t.Errorf("DB file could not be created: %v", dbFileErr)
-	} else {
-		defer func() { _ = os.Remove(dbFile) }()
-	}
-
-	db, dbErr := sql.Open("sqlite", dbFile)
-
-	if dbErr != nil {
-		t.Errorf("DB file could not be created: %v", dbErr)
-	} else {
-		defer func() { _ = db.Close() }()
-	}
+	db := openTempSQLite(t)
 
-	_, execErr := db.Exec("PRAGMA foreign_keys = ON")
+	_, execErr := db.ExecContext(t.Context(), "PRAGMA foreign_keys = ON")
 
-	assert.NoError(t, execErr, "foreign keys checking could not be enabled")
+	require.NoError(t, execErr, "foreign keys checking could not be enabled")
 
-	assert.Error(t, d.EnsureMigrationTableExists(db, "test"), "expected error")
+	assert.Error(t, dialect.EnsureMigrationTableExists(t.Context(), db, "test"), "expected error")
 }

exports_internal_test.go

@@ -0,0 +1,18 @@
+package dmorph
+
+import (
+	"context"
+	"database/sql"
+)
+
+// The exported names in this file are only used for internal testing and are not part of the public API.
+
+var (
+	TapplyStepsStream    = applyStepsStream
+	TmigrationFromFileFS = migrationFromFileFS
+	TmigrationOrder      = migrationOrder
+)
+
+func (m *Morpher) TapplyMigrations(ctx context.Context, db *sql.DB, lastMigration string) error {
+	return m.applyMigrations(ctx, db, lastMigration)
+}