aboutsummaryrefslogtreecommitdiffstats
path: root/internal/repositories
diff options
context:
space:
mode:
authorEugene Triguba <eugenetriguba@gmail.com>2024-03-02 11:07:30 -0500
committerGitHub <noreply@github.com>2024-03-02 11:07:30 -0500
commit571bc9bf2efa841b29bf036f4d307664bfbe155d (patch)
tree41fb3a459db99d1f0ec2ed2e00d4ca580a5d0c46 /internal/repositories
parentUpdate readme (diff)
parentRemove Latest() from migration fs repo in favor of using List on service (diff)
downloadcli-571bc9bf2efa841b29bf036f4d307664bfbe155d.zip
Merge pull request #1 from eugenetriguba/0.3.0
Diffstat (limited to 'internal/repositories')
-rw-r--r--internal/repositories/migration_db_repo.go233
-rw-r--r--internal/repositories/migration_db_repo_test.go264
-rw-r--r--internal/repositories/migration_fs_repo.go106
-rw-r--r--internal/repositories/migration_fs_repo_test.go145
4 files changed, 511 insertions, 237 deletions
diff --git a/internal/repositories/migration_db_repo.go b/internal/repositories/migration_db_repo.go
index 42cf0e8..7a90a2a 100644
--- a/internal/repositories/migration_db_repo.go
+++ b/internal/repositories/migration_db_repo.go
@@ -3,50 +3,80 @@ package repositories
import (
"database/sql"
"errors"
+ "fmt"
"strings"
"github.com/eugenetriguba/bolt/internal/models"
- "github.com/eugenetriguba/bolt/internal/sqlparse"
)
-type MigrationDBRepo struct {
- db *sql.DB
+type sqlExecutor interface {
+ Exec(query string, args ...interface{}) (sql.Result, error)
+}
+
+type SqlDb interface {
+ Exec(query string, args ...any) (sql.Result, error)
+ Query(query string, args ...any) (*sql.Rows, error)
+ QueryRow(query string, args ...any) *sql.Row
+ Begin() (*sql.Tx, error)
+}
+
+type MigrationDBRepo interface {
+ List() (map[string]*models.Migration, error)
+ IsApplied(version string) (bool, error)
+ Apply(upgradeScript string, migration *models.Migration) error
+ ApplyWithTx(upgradeScript string, migration *models.Migration) error
+ Revert(downgradeScript string, migration *models.Migration) error
+ RevertWithTx(downgradeScript string, migration *models.Migration) error
+}
+
+type migrationDBRepo struct {
+ db SqlDb
}
// NewMigrationDBRepo initializes the MigrationDBRepo with a
// database. Furthermore, it ensures the migration table it
// operates on exists. If it is unable to create or confirm
// the table exists, an error is returned.
-func NewMigrationDBRepo(db *sql.DB) (*MigrationDBRepo, error) {
+func NewMigrationDBRepo(db SqlDb) (MigrationDBRepo, error) {
_, err := db.Exec(`
CREATE TABLE IF NOT EXISTS bolt_migrations(
version CHARACTER(14) PRIMARY KEY NOT NULL
);
`)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf(
+ "unable to confirm bolt_migrations database table exists: %w",
+ err,
+ )
}
- return &MigrationDBRepo{db: db}, nil
+ return &migrationDBRepo{db: db}, nil
}
// List retrieves a map of migration models that can be
// looked up by their `Version`. All migrations retrieved
// will be ones that have been applied, and their message
// will always be an empty string.
-func (mr *MigrationDBRepo) List() (map[string]*models.Migration, error) {
+func (mr migrationDBRepo) List() (map[string]*models.Migration, error) {
rows, err := mr.db.Query(`SELECT version FROM bolt_migrations;`)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf(
+ "unable to execute query to select versions from "+
+ "bolt_migrations database table: %w",
+ err,
+ )
}
defer rows.Close()
- var migrations = make(map[string]*models.Migration)
+ var migrations = make(map[string]*models.Migration, 0)
for rows.Next() {
var version string
err := rows.Scan(&version)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf(
+ "unable to scan version row from applied migrations: %w",
+ err,
+ )
}
trimmedVersion := strings.TrimSpace(version)
migrations[trimmedVersion] = &models.Migration{
@@ -67,15 +97,19 @@ func (mr *MigrationDBRepo) List() (map[string]*models.Migration, error) {
// applied will be false when the version isn't applied and
// when the version might be applied, but there was an error.
// Check err first before looking at whether the version is applied.
-func (mr *MigrationDBRepo) IsApplied(version string) (applied bool, err error) {
+func (mr migrationDBRepo) IsApplied(version string) (bool, error) {
row := mr.db.QueryRow(`SELECT 1 FROM bolt_migrations WHERE version = $1`, version)
var scanResult int
- err = row.Scan(&scanResult)
+ err := row.Scan(&scanResult)
if errors.Is(err, sql.ErrNoRows) {
return false, nil
}
if err != nil {
- return false, err
+ return false, fmt.Errorf(
+ "unable to check whether the migration %s is applied: %w",
+ version,
+ err,
+ )
}
return true, nil
}
@@ -84,110 +118,143 @@ func (mr *MigrationDBRepo) IsApplied(version string) (applied bool, err error) {
// and adding the applied migration version into the migrations table. When
// successfully applied, the `migration` model's `Applied` field will be set
// to true.
-func (mr *MigrationDBRepo) Apply(
+func (mr migrationDBRepo) Apply(
upgradeScript string,
migration *models.Migration,
) error {
- sqlParser := sqlparse.NewSqlParser(strings.NewReader(upgradeScript))
- execOptions, err := sqlParser.Parse()
+ err := applyMigration(mr.db, upgradeScript, *migration)
if err != nil {
return err
}
- if execOptions.UseTransaction {
- tx, err := mr.db.Begin()
- if err != nil {
- return err
- }
- defer tx.Rollback()
-
- _, err = tx.Exec(upgradeScript)
- if err != nil {
- return err
- }
+ migration.Applied = true
+ return nil
+}
- _, err = tx.Exec(
- `INSERT INTO bolt_migrations(version) VALUES ($1);`,
- migration.Version,
+// ApplyWithTx applies a migration like Apply. However, it
+// wraps the operation is a database transaction.
+func (mr migrationDBRepo) ApplyWithTx(
+ upgradeScript string,
+ migration *models.Migration,
+) error {
+ tx, err := mr.db.Begin()
+ if err != nil {
+ return fmt.Errorf(
+ "unable to start transaction during upgrade script execution: %w",
+ err,
)
- if err != nil {
- return err
- }
- err = tx.Commit()
- if err != nil {
- return err
- }
- } else {
- _, err = mr.db.Exec(upgradeScript)
- if err != nil {
- return err
- }
+ }
+ defer tx.Rollback()
+
+ err = applyMigration(tx, upgradeScript, *migration)
+ if err != nil {
+ return err
+ }
- _, err = mr.db.Exec(
- `INSERT INTO bolt_migrations(version) VALUES ($1);`,
- migration.Version,
+ err = tx.Commit()
+ if err != nil {
+ return fmt.Errorf(
+ "unable to commit transaction during upgrade script execution: %w",
+ err,
)
- if err != nil {
- return err
- }
}
migration.Applied = true
return nil
}
+func applyMigration(
+ executor sqlExecutor,
+ upgradeScript string,
+ migration models.Migration,
+) error {
+ _, err := executor.Exec(upgradeScript)
+ if err != nil {
+ return fmt.Errorf("unable to execute upgrade script: %w", err)
+ }
+
+ _, err = executor.Exec(
+ `INSERT INTO bolt_migrations(version) VALUES ($1);`,
+ migration.Version,
+ )
+ if err != nil {
+ return fmt.Errorf(
+ "unable to insert applied migration: %w",
+ err,
+ )
+ }
+
+ return nil
+}
+
// Revert reverts a migration by executing the corresponding downgrade script
// and deleting the migration version from the migrations table. When successfully
// reverted, the `migration` model's `Applied` field will be set to false.
-func (mr *MigrationDBRepo) Revert(
+func (mr migrationDBRepo) Revert(
downgradeScript string,
migration *models.Migration,
) error {
- sqlParser := sqlparse.NewSqlParser(strings.NewReader(downgradeScript))
- execOptions, err := sqlParser.Parse()
+ err := revertMigration(mr.db, downgradeScript, *migration)
if err != nil {
return err
}
- if execOptions.UseTransaction {
- tx, err := mr.db.Begin()
- if err != nil {
- return err
- }
- defer tx.Rollback()
-
- _, err = tx.Exec(downgradeScript)
- if err != nil {
- return err
- }
+ migration.Applied = false
+ return nil
+}
- _, err = tx.Exec(
- `DELETE FROM bolt_migrations WHERE version = $1;`,
- migration.Version,
+// RevertWithTx reverts a migration like Revert. However, it
+// wraps the operation is a database transaction.
+func (mr migrationDBRepo) RevertWithTx(
+ downgradeScript string,
+ migration *models.Migration,
+) error {
+ tx, err := mr.db.Begin()
+ if err != nil {
+ return fmt.Errorf(
+ "unable to start transaction during downgrade script execution: %w",
+ err,
)
- if err != nil {
- return err
- }
+ }
+ defer tx.Rollback()
- err = tx.Commit()
- if err != nil {
- return err
- }
- } else {
- _, err = mr.db.Exec(downgradeScript)
- if err != nil {
- return err
- }
+ err = revertMigration(tx, downgradeScript, *migration)
+ if err != nil {
+ return err
+ }
- _, err = mr.db.Exec(
- `DELETE FROM bolt_migrations WHERE version = $1;`,
- migration.Version,
+ err = tx.Commit()
+ if err != nil {
+ return fmt.Errorf(
+ "unable to commit transaction during downgrade script execution: %w",
+ err,
)
- if err != nil {
- return err
- }
}
migration.Applied = false
return nil
}
+
+func revertMigration(
+ executor sqlExecutor,
+ downgradeScript string,
+ migration models.Migration,
+) error {
+ _, err := executor.Exec(downgradeScript)
+ if err != nil {
+ return fmt.Errorf("unable to execute downgrade script: %w", err)
+ }
+
+ _, err = executor.Exec(
+ `DELETE FROM bolt_migrations WHERE version = $1;`,
+ migration.Version,
+ )
+ if err != nil {
+ return fmt.Errorf(
+ "unable to remove reverted migration from bolt_migrations table: %w",
+ err,
+ )
+ }
+
+ return nil
+}
diff --git a/internal/repositories/migration_db_repo_test.go b/internal/repositories/migration_db_repo_test.go
index 55b8eb2..2775faa 100644
--- a/internal/repositories/migration_db_repo_test.go
+++ b/internal/repositories/migration_db_repo_test.go
@@ -2,16 +2,17 @@ package repositories_test
import (
"database/sql"
+ "errors"
"testing"
"time"
"github.com/eugenetriguba/bolt/internal/bolttest"
"github.com/eugenetriguba/bolt/internal/models"
"github.com/eugenetriguba/bolt/internal/repositories"
- "gotest.tools/v3/assert"
+ "github.com/eugenetriguba/checkmate/assert"
)
-func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) {
+func TestNewMigrationDBRepo_CreatesTable(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
row := db.QueryRow(`
SELECT 1
@@ -24,7 +25,7 @@ func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) {
assert.ErrorIs(t, err, sql.ErrNoRows)
_, err = repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
row = db.QueryRow(`
SELECT 1
@@ -33,47 +34,75 @@ func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) {
AND TABLE_NAME = 'bolt_migrations'
`)
err = row.Scan(&scanResult)
- assert.NilError(t, err)
+ assert.Nil(t, err)
}
-func TestMigrationDBRepo_NewMigrationDBRepoLeavesCurrentTable(t *testing.T) {
+func TestNewMigrationDBRepo_TableAlreadyExists(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
_, err := db.Exec(`CREATE TABLE bolt_migrations(id INT NOT NULL PRIMARY KEY)`)
- assert.NilError(t, err)
+ assert.Nil(t, err)
_, err = db.Exec(`INSERT INTO bolt_migrations(id) VALUES (1);`)
- assert.NilError(t, err)
+ assert.Nil(t, err)
_, err = repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
row := db.QueryRow(`SELECT id FROM bolt_migrations`)
var scanResult int
err = row.Scan(&scanResult)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, scanResult, 1)
}
-func TestMigrationDBRepo_ListWithEmptyTable(t *testing.T) {
+func TestNewMigrationDBRepo_TableCreationErr(t *testing.T) {
+ expectedErr := errors.New("error!")
+ db := bolttest.MockSqlDb{
+ ExecReturnValue: bolttest.ExecReturnValue{
+ Err: expectedErr,
+ },
+ }
+
+ _, err := repositories.NewMigrationDBRepo(&db)
+
+ assert.ErrorIs(t, err, expectedErr)
+}
+
+func TestList_EmptyTable(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
migrations, err := repo.List()
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, len(migrations), 0)
}
-func TestMigrationDBRepo_ListWithSingleResult(t *testing.T) {
+func TestList_QueryErr(t *testing.T) {
+ expectedErr := errors.New("error!")
+ db := bolttest.MockSqlDb{
+ QueryReturnValue: bolttest.QueryReturnValue{
+ Err: expectedErr,
+ },
+ }
+ repo, err := repositories.NewMigrationDBRepo(&db)
+ assert.Nil(t, err)
+
+ _, err = repo.List()
+
+ assert.ErrorIs(t, err, expectedErr)
+}
+
+func TestList_SingleResult(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
version := "20230101000000"
_, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version)
- assert.NilError(t, err)
+ assert.Nil(t, err)
migrations, err := repo.List()
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, len(migrations), 1)
assert.DeepEqual(
t,
@@ -82,17 +111,17 @@ func TestMigrationDBRepo_ListWithSingleResult(t *testing.T) {
)
}
-func TestMigrationDBRepo_ListWithShortVersion(t *testing.T) {
+func TestList_ShortVersion(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
version := "20230101"
_, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version)
- assert.NilError(t, err)
+ assert.Nil(t, err)
migrations, err := repo.List()
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, len(migrations), 1)
assert.DeepEqual(
t,
@@ -101,39 +130,101 @@ func TestMigrationDBRepo_ListWithShortVersion(t *testing.T) {
)
}
-func TestMigrationDBRepo_IsAppliedWithNotApplied(t *testing.T) {
+func TestIsApplied_WithNotApplied(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
version := "20230101010101"
applied, err := repo.IsApplied(version)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, applied, false)
}
-func TestMigrationDBRepo_IsAppliedWithApplied(t *testing.T) {
+func TestIsApplied_WithApplied(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
version := "20230101010101"
_, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version)
- assert.NilError(t, err)
+ assert.Nil(t, err)
applied, err := repo.IsApplied(version)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, applied, true)
}
-func TestMigrationDBRepo_Apply(t *testing.T) {
+func TestApply(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
- migration := models.NewMigration(time.Now(), "test")
+ migration := models.NewTimestampMigration(time.Now(), "test")
err = repo.Apply(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`, migration)
- assert.NilError(t, err)
+ assert.Nil(t, err)
+ assert.Equal(t, migration.Applied, true)
+
+ row := db.QueryRow(`
+ SELECT 1
+ FROM INFORMATION_SCHEMA.TABLES
+ WHERE TABLE_SCHEMA = 'public'
+ AND TABLE_NAME = 'tmp'
+ `)
+ var scanResult int
+ err = row.Scan(&scanResult)
+ assert.Nil(t, err)
+ applied, err := repo.IsApplied(migration.Version)
+ assert.Nil(t, err)
+ assert.Equal(t, applied, true)
+}
+
+func TestApply_MalformedSql(t *testing.T) {
+ db := bolttest.NewTestDB(t, "postgres")
+ repo, err := repositories.NewMigrationDBRepo(db)
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "test")
+
+ err = repo.Apply("this is not SQL", migration)
+ assert.ErrorContains(t, err, "syntax error")
+ assert.Equal(t, migration.Applied, false)
+}
+
+func TestApplyWithTx_BeginErr(t *testing.T) {
+ expectedErr := errors.New("error!")
+ db := bolttest.MockSqlDb{
+ BeginReturnValue: bolttest.BeginReturnValue{
+ Err: expectedErr,
+ },
+ }
+ repo, err := repositories.NewMigrationDBRepo(&db)
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "test")
+
+ err = repo.ApplyWithTx("SELECT 1 FROM bolt_migrations;", migration)
+
+ assert.ErrorIs(t, err, expectedErr)
+}
+
+func TestApplyWithTx_ExecErr(t *testing.T) {
+ db := bolttest.NewTestDB(t, "postgres")
+ repo, err := repositories.NewMigrationDBRepo(db)
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "test")
+
+ err = repo.ApplyWithTx("SELECT 1 FROM abc123donotexist;", migration)
+
+ assert.ErrorContains(t, err, `relation "abc123donotexist" does not exist`)
+}
+
+func TestApplyWithTx_SuccessfullyApplied(t *testing.T) {
+ db := bolttest.NewTestDB(t, "postgres")
+ repo, err := repositories.NewMigrationDBRepo(db)
+ assert.Nil(t, err)
+
+ migration := models.NewTimestampMigration(time.Now(), "test")
+ err = repo.ApplyWithTx(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`, migration)
+ assert.Nil(t, err)
assert.Equal(t, migration.Applied, true)
row := db.QueryRow(`
@@ -144,30 +235,30 @@ func TestMigrationDBRepo_Apply(t *testing.T) {
`)
var scanResult int
err = row.Scan(&scanResult)
- assert.NilError(t, err)
+ assert.Nil(t, err)
applied, err := repo.IsApplied(migration.Version)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, applied, true)
}
-func TestMigrationDBRepo_Revert(t *testing.T) {
+func TestRevert(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
+ assert.Nil(t, err)
_, err = db.Exec(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`)
- assert.NilError(t, err)
+ assert.Nil(t, err)
- migration := models.NewMigration(time.Now(), "test")
+ migration := models.NewTimestampMigration(time.Now(), "test")
_, err = db.Exec(
`INSERT INTO bolt_migrations(version) VALUES ($1);`,
migration.Version,
)
- assert.NilError(t, err)
+ assert.Nil(t, err)
migration.Applied = true
err = repo.Revert(`DROP TABLE tmp;`, migration)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, migration.Applied, false)
row := db.QueryRow(`
@@ -183,61 +274,82 @@ func TestMigrationDBRepo_Revert(t *testing.T) {
row = db.QueryRow(`SELECT count(*) FROM bolt_migrations`)
var count int
err = row.Scan(&count)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, count, 0)
}
-func TestMigrationDBRepo_ApplyAndRevertWithoutTransaction(t *testing.T) {
+func TestRevert_MalformedSql(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
- _, err = db.Exec("CREATE TABLE tmp(id INT PRIMARY KEY, id2 INT, id3 INT)")
- assert.NilError(t, err)
-
- migration := models.NewMigration(time.Now(), "test")
- // CREATE INDEX CONCURRENTLY cannot run inside a transaction.
- err = repo.Apply(
- `-- bolt: no-transaction\CREATE INDEX CONCURRENTLY i1 ON tmp(id2);`,
- migration,
- )
- assert.NilError(t, err)
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "test")
+ migration.Applied = true
+
+ err = repo.Revert("this is not SQL", migration)
+ assert.ErrorContains(t, err, "syntax error")
assert.Equal(t, migration.Applied, true)
+}
- err = repo.Revert(
- "-- bolt: no-transaction\nCREATE INDEX CONCURRENTLY i2 ON tmp(id3);",
- migration,
- )
- assert.NilError(t, err)
- assert.Equal(t, migration.Applied, false)
+func TestRevertWithTx_BeginErr(t *testing.T) {
+ expectedErr := errors.New("error!")
+ db := bolttest.MockSqlDb{
+ BeginReturnValue: bolttest.BeginReturnValue{
+ Err: expectedErr,
+ },
+ }
+ repo, err := repositories.NewMigrationDBRepo(&db)
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "test")
+
+ err = repo.RevertWithTx("DROP TABLE bolt_migrations;", migration)
+
+ assert.ErrorIs(t, err, expectedErr)
}
-func TestMigrationDBRepo_ApplyMalformedSql(t *testing.T) {
+func TestRevertWithTx_ExecErr(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
- migration := models.NewMigration(time.Now(), "test")
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "test")
- err = repo.Apply("this is not SQL", migration)
- assert.ErrorContains(t, err, "syntax error")
- assert.Equal(t, migration.Applied, false)
+ err = repo.RevertWithTx("DROP TABLE abc123donotexist;", migration)
- err = repo.Apply("-- bolt: no-transaction\nthis is not SQL", migration)
- assert.ErrorContains(t, err, "syntax error")
- assert.Equal(t, migration.Applied, false)
+ assert.ErrorContains(t, err, `table "abc123donotexist" does not exist`)
}
-func TestMigrationDBRepo_RevertMalformedSql(t *testing.T) {
+func TestRevertWithTx_SuccessfullyReverted(t *testing.T) {
db := bolttest.NewTestDB(t, "postgres")
repo, err := repositories.NewMigrationDBRepo(db)
- assert.NilError(t, err)
- migration := models.NewMigration(time.Now(), "test")
+ assert.Nil(t, err)
+
+ _, err = db.Exec(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`)
+ assert.Nil(t, err)
+
+ migration := models.NewTimestampMigration(time.Now(), "test")
+ _, err = db.Exec(
+ `INSERT INTO bolt_migrations(version) VALUES ($1);`,
+ migration.Version,
+ )
+ assert.Nil(t, err)
migration.Applied = true
- err = repo.Revert("this is not SQL", migration)
- assert.ErrorContains(t, err, "syntax error")
- assert.Equal(t, migration.Applied, true)
+ err = repo.RevertWithTx(`DROP TABLE tmp;`, migration)
+ assert.Nil(t, err)
+ assert.Equal(t, migration.Applied, false)
- err = repo.Revert("-- bolt: no-transaction\nthis is not SQL", migration)
- assert.ErrorContains(t, err, "syntax error")
- assert.Equal(t, migration.Applied, true)
+ row := db.QueryRow(`
+ SELECT 1
+ FROM INFORMATION_SCHEMA.TABLES
+ WHERE TABLE_SCHEMA = 'public'
+ AND TABLE_NAME = 'tmp'
+ `)
+ var scanResult int
+ err = row.Scan(&scanResult)
+ assert.ErrorIs(t, err, sql.ErrNoRows)
+
+ row = db.QueryRow(`SELECT count(*) FROM bolt_migrations`)
+ var count int
+ err = row.Scan(&count)
+ assert.Nil(t, err)
+ assert.Equal(t, count, 0)
}
diff --git a/internal/repositories/migration_fs_repo.go b/internal/repositories/migration_fs_repo.go
index 5478b5c..e535013 100644
--- a/internal/repositories/migration_fs_repo.go
+++ b/internal/repositories/migration_fs_repo.go
@@ -3,6 +3,7 @@ package repositories
import (
"errors"
"fmt"
+ "io/fs"
"os"
"path/filepath"
"strings"
@@ -22,27 +23,44 @@ func (e *ErrIsNotDir) Error() string {
)
}
-type MigrationFsRepo struct {
+type MigrationFsRepo interface {
+ Create(migration *models.Migration) error
+ List() (map[string]*models.Migration, error)
+ ReadUpgradeScript(migration *models.Migration) (string, error)
+ ReadDowngradeScript(migration *models.Migration) (string, error)
+}
+
+type migrationFsRepo struct {
migrationsDirPath string
}
-func NewMigrationFsRepo(migrationsConfig *configloader.MigrationsConfig) (*MigrationFsRepo, error) {
+func NewMigrationFsRepo(
+ migrationsConfig *configloader.MigrationsConfig,
+) (MigrationFsRepo, error) {
fileInfo, err := os.Stat(migrationsConfig.DirectoryPath)
- if errors.Is(err, os.ErrNotExist) {
+ if errors.Is(err, fs.ErrNotExist) {
err = os.MkdirAll(migrationsConfig.DirectoryPath, 0755)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf(
+ "unable to create migration directory at %s: %w",
+ migrationsConfig.DirectoryPath,
+ err,
+ )
}
} else if err != nil {
- return nil, err
- } else if err == nil && !fileInfo.IsDir() {
+ return nil, fmt.Errorf(
+ "unable to check if migration directory at %s exists: %w",
+ migrationsConfig.DirectoryPath,
+ err,
+ )
+ } else if !fileInfo.IsDir() {
return nil, &ErrIsNotDir{path: migrationsConfig.DirectoryPath}
}
- return &MigrationFsRepo{migrationsDirPath: migrationsConfig.DirectoryPath}, nil
+ return &migrationFsRepo{migrationsDirPath: migrationsConfig.DirectoryPath}, nil
}
-func (mr *MigrationFsRepo) Create(migration *models.Migration) error {
+func (mr migrationFsRepo) Create(migration *models.Migration) error {
newMigrationDir := filepath.Join(mr.migrationsDirPath, mr.migrationDirname(migration))
err := os.Mkdir(newMigrationDir, 0755)
@@ -63,59 +81,41 @@ func (mr *MigrationFsRepo) Create(migration *models.Migration) error {
return nil
}
-func (mr *MigrationFsRepo) Exists(version string) (bool, error) {
- migrations, err := mr.List()
- if err != nil {
- return false, err
- }
-
- _, ok := migrations[version]
- return ok, nil
-}
-
-func (mr *MigrationFsRepo) Get(version string) (*models.Migration, error) {
- migrations, err := mr.List()
- if err != nil {
- return nil, err
- }
-
- migration, ok := migrations[version]
- if !ok {
- return nil, fmt.Errorf("migration %s does not exist", version)
- }
-
- return migration, nil
-}
-
-func (mr *MigrationFsRepo) List() (map[string]*models.Migration, error) {
+func (mr migrationFsRepo) List() (map[string]*models.Migration, error) {
entries, err := os.ReadDir(mr.migrationsDirPath)
if err != nil {
return nil, err
}
- var migrations = make(map[string]*models.Migration)
+ var migrations = make(map[string]*models.Migration, 0)
for _, entry := range entries {
- parts := strings.SplitN(entry.Name(), "_", 2)
- if len(parts) != 2 {
- return nil, fmt.Errorf(
- "%s is an invalid migration name: expected a "+
- "migration directory of the format <version>_<message>",
- entry.Name(),
- )
- }
- migrations[parts[0]] = &models.Migration{
- Version: parts[0],
- Message: parts[1],
- Applied: false,
+ migration, err := dirEntryToMigration(entry)
+ if err != nil {
+ return nil, err
}
+ migrations[migration.Version] = migration
}
return migrations, nil
}
-func (mr *MigrationFsRepo) ReadUpgradeScript(
- migration *models.Migration,
-) (string, error) {
+func dirEntryToMigration(entry fs.DirEntry) (*models.Migration, error) {
+ parts := strings.SplitN(entry.Name(), "_", 2)
+ if len(parts) != 2 {
+ return nil, fmt.Errorf(
+ "%s is an invalid migration name: expected a "+
+ "migration directory of the format <version>_<message>",
+ entry.Name(),
+ )
+ }
+ return &models.Migration{
+ Version: parts[0],
+ Message: parts[1],
+ Applied: false,
+ }, nil
+}
+
+func (mr migrationFsRepo) ReadUpgradeScript(migration *models.Migration) (string, error) {
upgradeScriptPath := filepath.Join(
mr.migrationsDirPath,
mr.migrationDirname(migration),
@@ -124,7 +124,7 @@ func (mr *MigrationFsRepo) ReadUpgradeScript(
return mr.readScriptContents(upgradeScriptPath)
}
-func (mr *MigrationFsRepo) ReadDowngradeScript(
+func (mr migrationFsRepo) ReadDowngradeScript(
migration *models.Migration,
) (string, error) {
downgradeScriptPath := filepath.Join(
@@ -135,7 +135,7 @@ func (mr *MigrationFsRepo) ReadDowngradeScript(
return mr.readScriptContents(downgradeScriptPath)
}
-func (mr *MigrationFsRepo) readScriptContents(scriptPath string) (string, error) {
+func (mr migrationFsRepo) readScriptContents(scriptPath string) (string, error) {
contents, err := os.ReadFile(scriptPath)
if err != nil {
return "", err
@@ -146,13 +146,13 @@ func (mr *MigrationFsRepo) readScriptContents(scriptPath string) (string, error)
// migrationDirname creates the directory name that
// should be used for this migration.
-func (mr *MigrationFsRepo) migrationDirname(migration *models.Migration) string {
+func (mr migrationFsRepo) migrationDirname(migration *models.Migration) string {
return fmt.Sprintf("%s_%s", migration.Version, mr.normalizeMessage(migration))
}
// normalizeMessage normalizes the Message of a migration
// to be filesystem friendly.
-func (mr *MigrationFsRepo) normalizeMessage(migration *models.Migration) string {
+func (mr migrationFsRepo) normalizeMessage(migration *models.Migration) string {
message := strings.ToLower(migration.Message)
message = strings.TrimSpace(message)
message = strings.ReplaceAll(message, " ", "_")
diff --git a/internal/repositories/migration_fs_repo_test.go b/internal/repositories/migration_fs_repo_test.go
index 8fdcd8f..32de193 100644
--- a/internal/repositories/migration_fs_repo_test.go
+++ b/internal/repositories/migration_fs_repo_test.go
@@ -10,45 +10,54 @@ import (
"github.com/eugenetriguba/bolt/internal/configloader"
"github.com/eugenetriguba/bolt/internal/models"
"github.com/eugenetriguba/bolt/internal/repositories"
- "gotest.tools/v3/assert"
+ "github.com/eugenetriguba/checkmate/assert"
)
func assertFileExists(t *testing.T, path string) {
_, err := os.Stat(path)
- assert.NilError(t, err)
+ assert.Nil(t, err)
}
-func TestNewMigrationFsRepoCreatesDirIfNotExists(t *testing.T) {
+func TestNewMigrationFsRepo_CreatesDirIfNotExists(t *testing.T) {
tempDir := t.TempDir()
migrationsDir := filepath.Join(tempDir, "migrations")
migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir}
_, err := repositories.NewMigrationFsRepo(&migrationsConfig)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assertFileExists(t, migrationsDir)
}
-func TestNewMigrationFsRepoMigrationDirIsFile(t *testing.T) {
+func TestNewMigrationFsRepo_MigrationDirIsFile(t *testing.T) {
tempDir := t.TempDir()
migrationsDir := filepath.Join(tempDir, "migrations")
migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir}
_, err := os.Create(migrationsDir)
- assert.NilError(t, err)
+ assert.Nil(t, err)
_, err = repositories.NewMigrationFsRepo(&migrationsConfig)
+
assert.ErrorContains(t, err, "is not a directory")
}
-func TestMigrationFsRepoCreate(t *testing.T) {
+func TestNewMigrationFsRepo_UnknownStatErr(t *testing.T) {
+ migrationsConfig := configloader.MigrationsConfig{DirectoryPath: "\000x"}
+
+ _, err := repositories.NewMigrationFsRepo(&migrationsConfig)
+
+ assert.ErrorContains(t, err, "unable to check if migration directory")
+}
+
+func TestCreate_SuccessfullyCreated(t *testing.T) {
tempDir := t.TempDir()
migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir}
repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
- assert.NilError(t, err)
- migration := models.NewMigration(time.Now(), "add users table")
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "add users table")
err = repo.Create(migration)
- assert.NilError(t, err)
+ assert.Nil(t, err)
migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version)
assertFileExists(t, filepath.Join(tempDir, migrationDirName))
@@ -56,15 +65,31 @@ func TestMigrationFsRepoCreate(t *testing.T) {
assertFileExists(t, filepath.Join(tempDir, migrationDirName, "downgrade.sql"))
}
-func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) {
+func TestCreate_FailsToCreateDir(t *testing.T) {
+ tempDir := t.TempDir()
+ migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir}
+ repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
+ assert.Nil(t, err)
+ migration := models.NewTimestampMigration(time.Now(), "add users table")
+ migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version)
+ _, err = os.Create(filepath.Join(tempDir, migrationDirName))
+ assert.Nil(t, err)
+
+ err = repo.Create(migration)
+
+ assert.NotNil(t, err)
+ assert.ErrorContains(t, err, "file exists")
+}
+
+func TestReadUpgradeScript_SuccessfullyRead(t *testing.T) {
tempDir := t.TempDir()
migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir}
repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
- assert.NilError(t, err)
+ assert.Nil(t, err)
- migration := models.NewMigration(time.Now(), "add users table")
+ migration := models.NewSequentialMigration(1, "add users table")
err = repo.Create(migration)
- assert.NilError(t, err)
+ assert.Nil(t, err)
migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version)
expectedUpgradeScriptContents := []byte("CREATE TABLE users(id int PRIMARY KEY);")
@@ -73,6 +98,35 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) {
expectedUpgradeScriptContents,
0755,
)
+
+ upgradeScriptContents, err := repo.ReadUpgradeScript(migration)
+ assert.Nil(t, err)
+ assert.Equal(t, upgradeScriptContents, string(expectedUpgradeScriptContents))
+}
+
+func TestReadUpgradeScript_FileDoesNotExist(t *testing.T) {
+ migrationsConfig := configloader.MigrationsConfig{DirectoryPath: t.TempDir()}
+ repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
+ assert.Nil(t, err)
+ migration := models.NewSequentialMigration(1, "add users table")
+
+ _, err = repo.ReadUpgradeScript(migration)
+
+ assert.NotNil(t, err)
+ assert.ErrorContains(t, err, "no such file or directory")
+}
+
+func TestReadDowngradeScript_SuccessfullyRead(t *testing.T) {
+ tempDir := t.TempDir()
+ migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir}
+ repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
+ assert.Nil(t, err)
+
+ migration := models.NewSequentialMigration(1, "add users table")
+ err = repo.Create(migration)
+ assert.Nil(t, err)
+
+ migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version)
expectedDowngradeScriptContents := []byte("DROP TABLE users;")
os.WriteFile(
filepath.Join(tempDir, migrationDirName, "downgrade.sql"),
@@ -80,36 +134,77 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) {
0755,
)
- upgradeScriptContents, err := repo.ReadUpgradeScript(migration)
- assert.NilError(t, err)
- assert.Equal(t, upgradeScriptContents, string(expectedUpgradeScriptContents))
downgradeScriptContents, err := repo.ReadDowngradeScript(migration)
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, downgradeScriptContents, string(expectedDowngradeScriptContents))
}
-func TestMigrationFsRepo_List(t *testing.T) {
+func TestReadDowngradeScript_FileDoesNotExist(t *testing.T) {
+ migrationsConfig := configloader.MigrationsConfig{DirectoryPath: t.TempDir()}
+ repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
+ assert.Nil(t, err)
+ migration := models.NewSequentialMigration(1, "add users table")
+
+ _, err = repo.ReadDowngradeScript(migration)
+
+ assert.NotNil(t, err)
+ assert.ErrorContains(t, err, "no such file or directory")
+}
+
+func TestList_Success(t *testing.T) {
tempDir := t.TempDir()
migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir}
repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
- assert.NilError(t, err)
+ assert.Nil(t, err)
- migration1 := models.NewMigration(
+ migration1 := models.NewTimestampMigration(
time.Date(2020, 10, 12, 1, 1, 1, 1, time.UTC),
"migration_1",
)
- migration2 := models.NewMigration(
+ migration2 := models.NewTimestampMigration(
time.Date(2022, 10, 12, 1, 1, 1, 1, time.UTC),
"migration_2",
)
err = repo.Create(migration1)
- assert.NilError(t, err)
+ assert.Nil(t, err)
repo.Create(migration2)
- assert.NilError(t, err)
+ assert.Nil(t, err)
migrations, err := repo.List()
- assert.NilError(t, err)
+ assert.Nil(t, err)
assert.Equal(t, len(migrations), 2)
assert.DeepEqual(t, migrations[migration1.Version], migration1)
assert.DeepEqual(t, migrations[migration2.Version], migration2)
}
+
+func TestList_DirDoesNotExist(t *testing.T) {
+ migrationsDir := filepath.Join(t.TempDir(), "migrations")
+ migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir}
+ repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
+ assert.Nil(t, err)
+ err = os.RemoveAll(migrationsDir)
+ assert.Nil(t, err)
+
+ _, err = repo.List()
+
+ assert.NotNil(t, err)
+ assert.ErrorContains(t, err, "no such file or directory")
+}
+
+func TestList_InvalidMigrationName(t *testing.T) {
+ migrationsDir := filepath.Join(t.TempDir(), "migrations")
+ migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir}
+ repo, err := repositories.NewMigrationFsRepo(&migrationsConfig)
+ assert.Nil(t, err)
+ err = os.Mkdir(filepath.Join(migrationsDir, "invalid"), 0755)
+ assert.Nil(t, err)
+
+ _, err = repo.List()
+
+ assert.NotNil(t, err)
+ assert.ErrorContains(
+ t,
+ err,
+ "expected a migration directory of the format <version>_<message>",
+ )
+}