From db7de4b31b1836abed822077840665639f0d66da Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Fri, 19 Jan 2024 23:27:27 -0500 Subject: Add ability to use sequential or timestamp-based versions --- internal/repositories/migration_db_repo_test.go | 10 +++--- internal/repositories/migration_fs_repo.go | 46 ++++++++++++++++++------- internal/repositories/migration_fs_repo_test.go | 8 ++--- 3 files changed, 43 insertions(+), 21 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_db_repo_test.go b/internal/repositories/migration_db_repo_test.go index 55b8eb2..dc635b0 100644 --- a/internal/repositories/migration_db_repo_test.go +++ b/internal/repositories/migration_db_repo_test.go @@ -131,7 +131,7 @@ func TestMigrationDBRepo_Apply(t *testing.T) { repo, err := repositories.NewMigrationDBRepo(db) assert.NilError(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.Equal(t, migration.Applied, true) @@ -158,7 +158,7 @@ func TestMigrationDBRepo_Revert(t *testing.T) { _, err = db.Exec(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`) assert.NilError(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, @@ -194,7 +194,7 @@ func TestMigrationDBRepo_ApplyAndRevertWithoutTransaction(t *testing.T) { _, err = db.Exec("CREATE TABLE tmp(id INT PRIMARY KEY, id2 INT, id3 INT)") assert.NilError(t, err) - migration := models.NewMigration(time.Now(), "test") + migration := models.NewTimestampMigration(time.Now(), "test") // CREATE INDEX CONCURRENTLY cannot run inside a transaction. err = repo.Apply( `-- bolt: no-transaction\CREATE INDEX CONCURRENTLY i1 ON tmp(id2);`, @@ -215,7 +215,7 @@ func TestMigrationDBRepo_ApplyMalformedSql(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) assert.NilError(t, err) - migration := models.NewMigration(time.Now(), "test") + migration := models.NewTimestampMigration(time.Now(), "test") err = repo.Apply("this is not SQL", migration) assert.ErrorContains(t, err, "syntax error") @@ -230,7 +230,7 @@ func TestMigrationDBRepo_RevertMalformedSql(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) assert.NilError(t, err) - migration := models.NewMigration(time.Now(), "test") + migration := models.NewTimestampMigration(time.Now(), "test") migration.Applied = true err = repo.Revert("this is not SQL", migration) diff --git a/internal/repositories/migration_fs_repo.go b/internal/repositories/migration_fs_repo.go index 5478b5c..65afe5f 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" @@ -87,6 +88,19 @@ func (mr *MigrationFsRepo) Get(version string) (*models.Migration, error) { return migration, nil } +func (mr *MigrationFsRepo) Latest() (*models.Migration, error) { + entries, err := os.ReadDir(mr.migrationsDirPath) + if err != nil { + return nil, err + } + + if len(entries) > 0 { + return dirEntryToMigration(entries[len(entries)-1]) + } + + return nil, nil +} + func (mr *MigrationFsRepo) List() (map[string]*models.Migration, error) { entries, err := os.ReadDir(mr.migrationsDirPath) if err != nil { @@ -95,24 +109,32 @@ func (mr *MigrationFsRepo) List() (map[string]*models.Migration, error) { var migrations = make(map[string]*models.Migration) 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 _", - 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 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 _", + entry.Name(), + ) + } + return &models.Migration{ + Version: parts[0], + Message: parts[1], + Applied: false, + }, nil +} + func (mr *MigrationFsRepo) ReadUpgradeScript( migration *models.Migration, ) (string, error) { diff --git a/internal/repositories/migration_fs_repo_test.go b/internal/repositories/migration_fs_repo_test.go index 8fdcd8f..b1659fd 100644 --- a/internal/repositories/migration_fs_repo_test.go +++ b/internal/repositories/migration_fs_repo_test.go @@ -45,7 +45,7 @@ func TestMigrationFsRepoCreate(t *testing.T) { migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir} repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) assert.NilError(t, err) - migration := models.NewMigration(time.Now(), "add users table") + migration := models.NewTimestampMigration(time.Now(), "add users table") err = repo.Create(migration) assert.NilError(t, err) @@ -62,7 +62,7 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) { repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) assert.NilError(t, err) - migration := models.NewMigration(time.Now(), "add users table") + migration := models.NewTimestampMigration(time.Now(), "add users table") err = repo.Create(migration) assert.NilError(t, err) @@ -94,11 +94,11 @@ func TestMigrationFsRepo_List(t *testing.T) { repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) assert.NilError(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", ) -- cgit v1.2.3 From b06eba3df09a8fcd777b8fe350c2b184758963d1 Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sun, 28 Jan 2024 16:10:14 -0500 Subject: Use checkmate for tests --- internal/repositories/migration_db_repo_test.go | 118 ++++++++++++------------ internal/repositories/migration_fs_repo_test.go | 40 ++++---- 2 files changed, 79 insertions(+), 79 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_db_repo_test.go b/internal/repositories/migration_db_repo_test.go index dc635b0..5d1a9f1 100644 --- a/internal/repositories/migration_db_repo_test.go +++ b/internal/repositories/migration_db_repo_test.go @@ -8,7 +8,7 @@ import ( "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" ) func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) { @@ -21,10 +21,10 @@ func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) { `) var scanResult int err := row.Scan(&scanResult) - assert.ErrorIs(t, err, sql.ErrNoRows) + checkmate.AssertErrorIs(t, err, sql.ErrNoRows) _, err = repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) row = db.QueryRow(` SELECT 1 @@ -33,49 +33,49 @@ func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) { AND TABLE_NAME = 'bolt_migrations' `) err = row.Scan(&scanResult) - assert.NilError(t, err) + checkmate.AssertNil(t, err) } func TestMigrationDBRepo_NewMigrationDBRepoLeavesCurrentTable(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) + checkmate.AssertNil(t, err) _, err = db.Exec(`INSERT INTO bolt_migrations(id) VALUES (1);`) - assert.NilError(t, err) + checkmate.AssertNil(t, err) _, err = repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) row := db.QueryRow(`SELECT id FROM bolt_migrations`) var scanResult int err = row.Scan(&scanResult) - assert.NilError(t, err) - assert.Equal(t, scanResult, 1) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, scanResult, 1) } func TestMigrationDBRepo_ListWithEmptyTable(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migrations, err := repo.List() - assert.NilError(t, err) - assert.Equal(t, len(migrations), 0) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, len(migrations), 0) } func TestMigrationDBRepo_ListWithSingleResult(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) version := "20230101000000" _, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migrations, err := repo.List() - assert.NilError(t, err) - assert.Equal(t, len(migrations), 1) - assert.DeepEqual( + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, len(migrations), 1) + checkmate.AssertDeepEqual( t, migrations[version], &models.Migration{Version: version, Message: "", Applied: true}, @@ -85,16 +85,16 @@ func TestMigrationDBRepo_ListWithSingleResult(t *testing.T) { func TestMigrationDBRepo_ListWithShortVersion(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) version := "20230101" _, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migrations, err := repo.List() - assert.NilError(t, err) - assert.Equal(t, len(migrations), 1) - assert.DeepEqual( + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, len(migrations), 1) + checkmate.AssertDeepEqual( t, migrations[version], &models.Migration{Version: version, Message: "", Applied: true}, @@ -104,37 +104,37 @@ func TestMigrationDBRepo_ListWithShortVersion(t *testing.T) { func TestMigrationDBRepo_IsAppliedWithNotApplied(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) version := "20230101010101" applied, err := repo.IsApplied(version) - assert.NilError(t, err) - assert.Equal(t, applied, false) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, applied, false) } func TestMigrationDBRepo_IsAppliedWithApplied(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) version := "20230101010101" _, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version) - assert.NilError(t, err) + checkmate.AssertNil(t, err) applied, err := repo.IsApplied(version) - assert.NilError(t, err) - assert.Equal(t, applied, true) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, applied, true) } func TestMigrationDBRepo_Apply(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") err = repo.Apply(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`, migration) - assert.NilError(t, err) - assert.Equal(t, migration.Applied, true) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, migration.Applied, true) row := db.QueryRow(` SELECT 1 @@ -144,31 +144,31 @@ func TestMigrationDBRepo_Apply(t *testing.T) { `) var scanResult int err = row.Scan(&scanResult) - assert.NilError(t, err) + checkmate.AssertNil(t, err) applied, err := repo.IsApplied(migration.Version) - assert.NilError(t, err) - assert.Equal(t, applied, true) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, applied, true) } func TestMigrationDBRepo_Revert(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) _, err = db.Exec(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") _, err = db.Exec( `INSERT INTO bolt_migrations(version) VALUES ($1);`, migration.Version, ) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migration.Applied = true err = repo.Revert(`DROP TABLE tmp;`, migration) - assert.NilError(t, err) - assert.Equal(t, migration.Applied, false) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, migration.Applied, false) row := db.QueryRow(` SELECT 1 @@ -178,21 +178,21 @@ func TestMigrationDBRepo_Revert(t *testing.T) { `) var scanResult int err = row.Scan(&scanResult) - assert.ErrorIs(t, err, sql.ErrNoRows) + checkmate.AssertErrorIs(t, err, sql.ErrNoRows) row = db.QueryRow(`SELECT count(*) FROM bolt_migrations`) var count int err = row.Scan(&count) - assert.NilError(t, err) - assert.Equal(t, count, 0) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, count, 0) } func TestMigrationDBRepo_ApplyAndRevertWithoutTransaction(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(t, err) _, err = db.Exec("CREATE TABLE tmp(id INT PRIMARY KEY, id2 INT, id3 INT)") - assert.NilError(t, err) + checkmate.AssertNil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") // CREATE INDEX CONCURRENTLY cannot run inside a transaction. @@ -200,44 +200,44 @@ func TestMigrationDBRepo_ApplyAndRevertWithoutTransaction(t *testing.T) { `-- bolt: no-transaction\CREATE INDEX CONCURRENTLY i1 ON tmp(id2);`, migration, ) - assert.NilError(t, err) - assert.Equal(t, migration.Applied, true) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(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) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, migration.Applied, false) } func TestMigrationDBRepo_ApplyMalformedSql(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(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) + checkmate.AssertErrorContains(t, err, "syntax error") + checkmate.AssertEqual(t, migration.Applied, false) err = repo.Apply("-- bolt: no-transaction\nthis is not SQL", migration) - assert.ErrorContains(t, err, "syntax error") - assert.Equal(t, migration.Applied, false) + checkmate.AssertErrorContains(t, err, "syntax error") + checkmate.AssertEqual(t, migration.Applied, false) } func TestMigrationDBRepo_RevertMalformedSql(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - assert.NilError(t, err) + checkmate.AssertNil(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) + checkmate.AssertErrorContains(t, err, "syntax error") + checkmate.AssertEqual(t, migration.Applied, true) err = repo.Revert("-- bolt: no-transaction\nthis is not SQL", migration) - assert.ErrorContains(t, err, "syntax error") - assert.Equal(t, migration.Applied, true) + checkmate.AssertErrorContains(t, err, "syntax error") + checkmate.AssertEqual(t, migration.Applied, true) } diff --git a/internal/repositories/migration_fs_repo_test.go b/internal/repositories/migration_fs_repo_test.go index b1659fd..2398260 100644 --- a/internal/repositories/migration_fs_repo_test.go +++ b/internal/repositories/migration_fs_repo_test.go @@ -10,12 +10,12 @@ 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" ) func assertFileExists(t *testing.T, path string) { _, err := os.Stat(path) - assert.NilError(t, err) + checkmate.AssertNil(t, err) } func TestNewMigrationFsRepoCreatesDirIfNotExists(t *testing.T) { @@ -24,7 +24,7 @@ func TestNewMigrationFsRepoCreatesDirIfNotExists(t *testing.T) { migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir} _, err := repositories.NewMigrationFsRepo(&migrationsConfig) - assert.NilError(t, err) + checkmate.AssertNil(t, err) assertFileExists(t, migrationsDir) } @@ -34,21 +34,21 @@ func TestNewMigrationFsRepoMigrationDirIsFile(t *testing.T) { migrationsDir := filepath.Join(tempDir, "migrations") migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir} _, err := os.Create(migrationsDir) - assert.NilError(t, err) + checkmate.AssertNil(t, err) _, err = repositories.NewMigrationFsRepo(&migrationsConfig) - assert.ErrorContains(t, err, "is not a directory") + checkmate.AssertErrorContains(t, err, "is not a directory") } func TestMigrationFsRepoCreate(t *testing.T) { tempDir := t.TempDir() migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir} repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migration := models.NewTimestampMigration(time.Now(), "add users table") err = repo.Create(migration) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version) assertFileExists(t, filepath.Join(tempDir, migrationDirName)) @@ -60,11 +60,11 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) { tempDir := t.TempDir() migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir} repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migration := models.NewTimestampMigration(time.Now(), "add users table") err = repo.Create(migration) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version) expectedUpgradeScriptContents := []byte("CREATE TABLE users(id int PRIMARY KEY);") @@ -81,18 +81,18 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) { ) upgradeScriptContents, err := repo.ReadUpgradeScript(migration) - assert.NilError(t, err) - assert.Equal(t, upgradeScriptContents, string(expectedUpgradeScriptContents)) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, upgradeScriptContents, string(expectedUpgradeScriptContents)) downgradeScriptContents, err := repo.ReadDowngradeScript(migration) - assert.NilError(t, err) - assert.Equal(t, downgradeScriptContents, string(expectedDowngradeScriptContents)) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, downgradeScriptContents, string(expectedDowngradeScriptContents)) } func TestMigrationFsRepo_List(t *testing.T) { tempDir := t.TempDir() migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir} repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migration1 := models.NewTimestampMigration( time.Date(2020, 10, 12, 1, 1, 1, 1, time.UTC), @@ -103,13 +103,13 @@ func TestMigrationFsRepo_List(t *testing.T) { "migration_2", ) err = repo.Create(migration1) - assert.NilError(t, err) + checkmate.AssertNil(t, err) repo.Create(migration2) - assert.NilError(t, err) + checkmate.AssertNil(t, err) migrations, err := repo.List() - assert.NilError(t, err) - assert.Equal(t, len(migrations), 2) - assert.DeepEqual(t, migrations[migration1.Version], migration1) - assert.DeepEqual(t, migrations[migration2.Version], migration2) + checkmate.AssertNil(t, err) + checkmate.AssertEqual(t, len(migrations), 2) + checkmate.AssertDeepEqual(t, migrations[migration1.Version], migration1) + checkmate.AssertDeepEqual(t, migrations[migration2.Version], migration2) } -- cgit v1.2.3 From 345e28bd44ba6a38bf7ee9bfe2066f333bbbe894 Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sun, 28 Jan 2024 16:29:00 -0500 Subject: Update to checkmate v0.2.0 --- internal/repositories/migration_db_repo_test.go | 118 ++++++++++++------------ internal/repositories/migration_fs_repo_test.go | 40 ++++---- 2 files changed, 79 insertions(+), 79 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_db_repo_test.go b/internal/repositories/migration_db_repo_test.go index 5d1a9f1..4e41b36 100644 --- a/internal/repositories/migration_db_repo_test.go +++ b/internal/repositories/migration_db_repo_test.go @@ -8,7 +8,7 @@ import ( "github.com/eugenetriguba/bolt/internal/bolttest" "github.com/eugenetriguba/bolt/internal/models" "github.com/eugenetriguba/bolt/internal/repositories" - "github.com/eugenetriguba/checkmate" + "github.com/eugenetriguba/checkmate/assert" ) func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) { @@ -21,10 +21,10 @@ func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) { `) var scanResult int err := row.Scan(&scanResult) - checkmate.AssertErrorIs(t, err, sql.ErrNoRows) + assert.ErrorIs(t, err, sql.ErrNoRows) _, err = repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) row = db.QueryRow(` SELECT 1 @@ -33,49 +33,49 @@ func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) { AND TABLE_NAME = 'bolt_migrations' `) err = row.Scan(&scanResult) - checkmate.AssertNil(t, err) + assert.Nil(t, err) } func TestMigrationDBRepo_NewMigrationDBRepoLeavesCurrentTable(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") _, err := db.Exec(`CREATE TABLE bolt_migrations(id INT NOT NULL PRIMARY KEY)`) - checkmate.AssertNil(t, err) + assert.Nil(t, err) _, err = db.Exec(`INSERT INTO bolt_migrations(id) VALUES (1);`) - checkmate.AssertNil(t, err) + assert.Nil(t, err) _, err = repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) row := db.QueryRow(`SELECT id FROM bolt_migrations`) var scanResult int err = row.Scan(&scanResult) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, scanResult, 1) + assert.Nil(t, err) + assert.Equal(t, scanResult, 1) } func TestMigrationDBRepo_ListWithEmptyTable(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migrations, err := repo.List() - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, len(migrations), 0) + assert.Nil(t, err) + assert.Equal(t, len(migrations), 0) } func TestMigrationDBRepo_ListWithSingleResult(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) version := "20230101000000" _, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migrations, err := repo.List() - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, len(migrations), 1) - checkmate.AssertDeepEqual( + assert.Nil(t, err) + assert.Equal(t, len(migrations), 1) + assert.DeepEqual( t, migrations[version], &models.Migration{Version: version, Message: "", Applied: true}, @@ -85,16 +85,16 @@ func TestMigrationDBRepo_ListWithSingleResult(t *testing.T) { func TestMigrationDBRepo_ListWithShortVersion(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) version := "20230101" _, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migrations, err := repo.List() - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, len(migrations), 1) - checkmate.AssertDeepEqual( + assert.Nil(t, err) + assert.Equal(t, len(migrations), 1) + assert.DeepEqual( t, migrations[version], &models.Migration{Version: version, Message: "", Applied: true}, @@ -104,37 +104,37 @@ func TestMigrationDBRepo_ListWithShortVersion(t *testing.T) { func TestMigrationDBRepo_IsAppliedWithNotApplied(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) version := "20230101010101" applied, err := repo.IsApplied(version) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, applied, false) + assert.Nil(t, err) + assert.Equal(t, applied, false) } func TestMigrationDBRepo_IsAppliedWithApplied(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) version := "20230101010101" _, err = db.Exec(`INSERT INTO bolt_migrations(version) VALUES ($1);`, version) - checkmate.AssertNil(t, err) + assert.Nil(t, err) applied, err := repo.IsApplied(version) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, applied, true) + assert.Nil(t, err) + assert.Equal(t, applied, true) } func TestMigrationDBRepo_Apply(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") err = repo.Apply(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`, migration) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, migration.Applied, true) + assert.Nil(t, err) + assert.Equal(t, migration.Applied, true) row := db.QueryRow(` SELECT 1 @@ -144,31 +144,31 @@ func TestMigrationDBRepo_Apply(t *testing.T) { `) var scanResult int err = row.Scan(&scanResult) - checkmate.AssertNil(t, err) + assert.Nil(t, err) applied, err := repo.IsApplied(migration.Version) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, applied, true) + assert.Nil(t, err) + assert.Equal(t, applied, true) } func TestMigrationDBRepo_Revert(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) _, err = db.Exec(`CREATE TABLE tmp(id INT NOT NULL PRIMARY KEY)`) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") _, err = db.Exec( `INSERT INTO bolt_migrations(version) VALUES ($1);`, migration.Version, ) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration.Applied = true err = repo.Revert(`DROP TABLE tmp;`, migration) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, migration.Applied, false) + assert.Nil(t, err) + assert.Equal(t, migration.Applied, false) row := db.QueryRow(` SELECT 1 @@ -178,21 +178,21 @@ func TestMigrationDBRepo_Revert(t *testing.T) { `) var scanResult int err = row.Scan(&scanResult) - checkmate.AssertErrorIs(t, err, sql.ErrNoRows) + assert.ErrorIs(t, err, sql.ErrNoRows) row = db.QueryRow(`SELECT count(*) FROM bolt_migrations`) var count int err = row.Scan(&count) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, count, 0) + assert.Nil(t, err) + assert.Equal(t, count, 0) } func TestMigrationDBRepo_ApplyAndRevertWithoutTransaction(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) _, err = db.Exec("CREATE TABLE tmp(id INT PRIMARY KEY, id2 INT, id3 INT)") - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") // CREATE INDEX CONCURRENTLY cannot run inside a transaction. @@ -200,44 +200,44 @@ func TestMigrationDBRepo_ApplyAndRevertWithoutTransaction(t *testing.T) { `-- bolt: no-transaction\CREATE INDEX CONCURRENTLY i1 ON tmp(id2);`, migration, ) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, migration.Applied, true) + assert.Nil(t, err) + assert.Equal(t, migration.Applied, true) err = repo.Revert( "-- bolt: no-transaction\nCREATE INDEX CONCURRENTLY i2 ON tmp(id3);", migration, ) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, migration.Applied, false) + assert.Nil(t, err) + assert.Equal(t, migration.Applied, false) } func TestMigrationDBRepo_ApplyMalformedSql(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") err = repo.Apply("this is not SQL", migration) - checkmate.AssertErrorContains(t, err, "syntax error") - checkmate.AssertEqual(t, migration.Applied, false) + assert.ErrorContains(t, err, "syntax error") + assert.Equal(t, migration.Applied, false) err = repo.Apply("-- bolt: no-transaction\nthis is not SQL", migration) - checkmate.AssertErrorContains(t, err, "syntax error") - checkmate.AssertEqual(t, migration.Applied, false) + assert.ErrorContains(t, err, "syntax error") + assert.Equal(t, migration.Applied, false) } func TestMigrationDBRepo_RevertMalformedSql(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration := models.NewTimestampMigration(time.Now(), "test") migration.Applied = true err = repo.Revert("this is not SQL", migration) - checkmate.AssertErrorContains(t, err, "syntax error") - checkmate.AssertEqual(t, migration.Applied, true) + assert.ErrorContains(t, err, "syntax error") + assert.Equal(t, migration.Applied, true) err = repo.Revert("-- bolt: no-transaction\nthis is not SQL", migration) - checkmate.AssertErrorContains(t, err, "syntax error") - checkmate.AssertEqual(t, migration.Applied, true) + assert.ErrorContains(t, err, "syntax error") + assert.Equal(t, migration.Applied, true) } diff --git a/internal/repositories/migration_fs_repo_test.go b/internal/repositories/migration_fs_repo_test.go index 2398260..72ba792 100644 --- a/internal/repositories/migration_fs_repo_test.go +++ b/internal/repositories/migration_fs_repo_test.go @@ -10,12 +10,12 @@ import ( "github.com/eugenetriguba/bolt/internal/configloader" "github.com/eugenetriguba/bolt/internal/models" "github.com/eugenetriguba/bolt/internal/repositories" - "github.com/eugenetriguba/checkmate" + "github.com/eugenetriguba/checkmate/assert" ) func assertFileExists(t *testing.T, path string) { _, err := os.Stat(path) - checkmate.AssertNil(t, err) + assert.Nil(t, err) } func TestNewMigrationFsRepoCreatesDirIfNotExists(t *testing.T) { @@ -24,7 +24,7 @@ func TestNewMigrationFsRepoCreatesDirIfNotExists(t *testing.T) { migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir} _, err := repositories.NewMigrationFsRepo(&migrationsConfig) - checkmate.AssertNil(t, err) + assert.Nil(t, err) assertFileExists(t, migrationsDir) } @@ -34,21 +34,21 @@ func TestNewMigrationFsRepoMigrationDirIsFile(t *testing.T) { migrationsDir := filepath.Join(tempDir, "migrations") migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir} _, err := os.Create(migrationsDir) - checkmate.AssertNil(t, err) + assert.Nil(t, err) _, err = repositories.NewMigrationFsRepo(&migrationsConfig) - checkmate.AssertErrorContains(t, err, "is not a directory") + assert.ErrorContains(t, err, "is not a directory") } func TestMigrationFsRepoCreate(t *testing.T) { tempDir := t.TempDir() migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir} repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration := models.NewTimestampMigration(time.Now(), "add users table") err = repo.Create(migration) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version) assertFileExists(t, filepath.Join(tempDir, migrationDirName)) @@ -60,11 +60,11 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) { tempDir := t.TempDir() migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir} repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration := models.NewTimestampMigration(time.Now(), "add users table") err = repo.Create(migration) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migrationDirName := fmt.Sprintf("%s_add_users_table", migration.Version) expectedUpgradeScriptContents := []byte("CREATE TABLE users(id int PRIMARY KEY);") @@ -81,18 +81,18 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) { ) upgradeScriptContents, err := repo.ReadUpgradeScript(migration) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, upgradeScriptContents, string(expectedUpgradeScriptContents)) + assert.Nil(t, err) + assert.Equal(t, upgradeScriptContents, string(expectedUpgradeScriptContents)) downgradeScriptContents, err := repo.ReadDowngradeScript(migration) - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, downgradeScriptContents, string(expectedDowngradeScriptContents)) + assert.Nil(t, err) + assert.Equal(t, downgradeScriptContents, string(expectedDowngradeScriptContents)) } func TestMigrationFsRepo_List(t *testing.T) { tempDir := t.TempDir() migrationsConfig := configloader.MigrationsConfig{DirectoryPath: tempDir} repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migration1 := models.NewTimestampMigration( time.Date(2020, 10, 12, 1, 1, 1, 1, time.UTC), @@ -103,13 +103,13 @@ func TestMigrationFsRepo_List(t *testing.T) { "migration_2", ) err = repo.Create(migration1) - checkmate.AssertNil(t, err) + assert.Nil(t, err) repo.Create(migration2) - checkmate.AssertNil(t, err) + assert.Nil(t, err) migrations, err := repo.List() - checkmate.AssertNil(t, err) - checkmate.AssertEqual(t, len(migrations), 2) - checkmate.AssertDeepEqual(t, migrations[migration1.Version], migration1) - checkmate.AssertDeepEqual(t, migrations[migration2.Version], migration2) + assert.Nil(t, err) + assert.Equal(t, len(migrations), 2) + assert.DeepEqual(t, migrations[migration1.Version], migration1) + assert.DeepEqual(t, migrations[migration2.Version], migration2) } -- cgit v1.2.3 From 95eea2a07198576e3f4b0a246dd5e2b0cd4ef219 Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sun, 28 Jan 2024 17:47:31 -0500 Subject: Wrap db repo and console errs to give better errors --- internal/repositories/migration_db_repo.go | 53 ++++++++++++++++++++++-------- internal/repositories/migration_fs_repo.go | 4 ++- 2 files changed, 42 insertions(+), 15 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_db_repo.go b/internal/repositories/migration_db_repo.go index 42cf0e8..93b9c73 100644 --- a/internal/repositories/migration_db_repo.go +++ b/internal/repositories/migration_db_repo.go @@ -3,6 +3,7 @@ package repositories import ( "database/sql" "errors" + "fmt" "strings" "github.com/eugenetriguba/bolt/internal/models" @@ -91,19 +92,22 @@ func (mr *MigrationDBRepo) Apply( sqlParser := sqlparse.NewSqlParser(strings.NewReader(upgradeScript)) execOptions, err := sqlParser.Parse() if err != nil { - return err + return fmt.Errorf("unable to parse sql file for upgrade script: %w", err) } if execOptions.UseTransaction { tx, err := mr.db.Begin() if err != nil { - return err + return fmt.Errorf( + "unable to start transaction during upgrade script execution: %w", + err, + ) } defer tx.Rollback() _, err = tx.Exec(upgradeScript) if err != nil { - return err + return fmt.Errorf("unable to execute upgrade script: %w", err) } _, err = tx.Exec( @@ -111,16 +115,22 @@ func (mr *MigrationDBRepo) Apply( migration.Version, ) if err != nil { - return err + return fmt.Errorf( + "unable to insert applied migration to bolt_migrations table: %w", + err, + ) } err = tx.Commit() if err != nil { - return err + return fmt.Errorf( + "unable to commit transaction during upgrade script execution: %w", + err, + ) } } else { _, err = mr.db.Exec(upgradeScript) if err != nil { - return err + return fmt.Errorf("unable to execute upgrade script: %w", err) } _, err = mr.db.Exec( @@ -128,7 +138,10 @@ func (mr *MigrationDBRepo) Apply( migration.Version, ) if err != nil { - return err + return fmt.Errorf( + "unable to insert applied migration to bolt_migrations table: %w", + err, + ) } } @@ -146,19 +159,22 @@ func (mr *MigrationDBRepo) Revert( sqlParser := sqlparse.NewSqlParser(strings.NewReader(downgradeScript)) execOptions, err := sqlParser.Parse() if err != nil { - return err + return fmt.Errorf("unable to parse sql file for downgrade script: %w", err) } if execOptions.UseTransaction { tx, err := mr.db.Begin() if err != nil { - return err + return fmt.Errorf( + "unable to start transaction during downgrade script execution: %w", + err, + ) } defer tx.Rollback() _, err = tx.Exec(downgradeScript) if err != nil { - return err + return fmt.Errorf("unable to execute downgrade script: %w", err) } _, err = tx.Exec( @@ -166,17 +182,23 @@ func (mr *MigrationDBRepo) Revert( migration.Version, ) if err != nil { - return err + return fmt.Errorf( + "unable to remove reverted migration from bolt_migrations table: %w", + err, + ) } err = tx.Commit() if err != nil { - return err + return fmt.Errorf( + "unable to commit transaction during downgrade script execution: %w", + err, + ) } } else { _, err = mr.db.Exec(downgradeScript) if err != nil { - return err + return fmt.Errorf("unable to execute downgrade script: %w", err) } _, err = mr.db.Exec( @@ -184,7 +206,10 @@ func (mr *MigrationDBRepo) Revert( migration.Version, ) if err != nil { - return err + return fmt.Errorf( + "unable to remove reverted migration from bolt_migrations table: %w", + err, + ) } } diff --git a/internal/repositories/migration_fs_repo.go b/internal/repositories/migration_fs_repo.go index 65afe5f..c541006 100644 --- a/internal/repositories/migration_fs_repo.go +++ b/internal/repositories/migration_fs_repo.go @@ -27,7 +27,9 @@ 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) { err = os.MkdirAll(migrationsConfig.DirectoryPath, 0755) -- cgit v1.2.3 From fb84192eef75c909d031aa867d407f1b7797e9db Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sun, 28 Jan 2024 19:57:15 -0500 Subject: Add more wrapped errors --- internal/repositories/migration_db_repo.go | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_db_repo.go b/internal/repositories/migration_db_repo.go index 93b9c73..b9e2d78 100644 --- a/internal/repositories/migration_db_repo.go +++ b/internal/repositories/migration_db_repo.go @@ -25,7 +25,10 @@ func NewMigrationDBRepo(db *sql.DB) (*MigrationDBRepo, error) { ); `) if err != nil { - return nil, err + return nil, fmt.Errorf( + "unable to create bolt_migrations database table: %w", + err, + ) } return &MigrationDBRepo{db: db}, nil @@ -38,7 +41,11 @@ func NewMigrationDBRepo(db *sql.DB) (*MigrationDBRepo, 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() @@ -47,7 +54,10 @@ func (mr *MigrationDBRepo) List() (map[string]*models.Migration, error) { 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{ -- cgit v1.2.3 From bf1d3b3e1fc42132678b244e479839416a03a6ce Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Thu, 29 Feb 2024 19:53:20 -0500 Subject: Add service tests --- internal/repositories/migration_db_repo.go | 235 +++++++++++++----------- internal/repositories/migration_db_repo_test.go | 2 +- internal/repositories/migration_fs_repo.go | 40 ++-- 3 files changed, 155 insertions(+), 122 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_db_repo.go b/internal/repositories/migration_db_repo.go index b9e2d78..500fea4 100644 --- a/internal/repositories/migration_db_repo.go +++ b/internal/repositories/migration_db_repo.go @@ -7,10 +7,22 @@ import ( "strings" "github.com/eugenetriguba/bolt/internal/models" - "github.com/eugenetriguba/bolt/internal/sqlparse" ) -type MigrationDBRepo struct { +type SQLExecutor interface { + Exec(query string, args ...interface{}) (sql.Result, 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 *sql.DB } @@ -18,7 +30,7 @@ type MigrationDBRepo struct { // 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 *sql.DB) (MigrationDBRepo, error) { _, err := db.Exec(` CREATE TABLE IF NOT EXISTS bolt_migrations( version CHARACTER(14) PRIMARY KEY NOT NULL @@ -31,14 +43,14 @@ func NewMigrationDBRepo(db *sql.DB) (*MigrationDBRepo, error) { ) } - 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, fmt.Errorf( @@ -49,7 +61,7 @@ func (mr *MigrationDBRepo) List() (map[string]*models.Migration, error) { } 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) @@ -78,15 +90,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 } @@ -95,134 +111,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 fmt.Errorf("unable to parse sql file for upgrade script: %w", err) + return err } - if execOptions.UseTransaction { - tx, err := mr.db.Begin() - if err != nil { - return fmt.Errorf( - "unable to start transaction during upgrade script execution: %w", - err, - ) - } - defer tx.Rollback() - - _, err = tx.Exec(upgradeScript) - if err != nil { - return fmt.Errorf("unable to execute upgrade script: %w", 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 fmt.Errorf( - "unable to insert applied migration to bolt_migrations table: %w", - err, - ) - } - err = tx.Commit() - if err != nil { - return fmt.Errorf( - "unable to commit transaction during upgrade script execution: %w", - err, - ) - } - } else { - _, err = mr.db.Exec(upgradeScript) - if err != nil { - return fmt.Errorf("unable to execute upgrade script: %w", err) - } + } + defer tx.Rollback() - _, err = mr.db.Exec( - `INSERT INTO bolt_migrations(version) VALUES ($1);`, - migration.Version, + err = applyMigration(tx, upgradeScript, *migration) + if err != nil { + return err + } + + err = tx.Commit() + if err != nil { + return fmt.Errorf( + "unable to commit transaction during upgrade script execution: %w", + err, ) - if err != nil { - return fmt.Errorf( - "unable to insert applied migration to bolt_migrations table: %w", - 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 fmt.Errorf("unable to parse sql file for downgrade script: %w", err) + return err } - if execOptions.UseTransaction { - tx, err := mr.db.Begin() - if err != nil { - return fmt.Errorf( - "unable to start transaction during downgrade script execution: %w", - err, - ) - } - defer tx.Rollback() - - _, err = tx.Exec(downgradeScript) - if err != nil { - return fmt.Errorf("unable to execute downgrade script: %w", 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 fmt.Errorf( - "unable to remove reverted migration from bolt_migrations table: %w", - err, - ) - } + } + defer tx.Rollback() - err = tx.Commit() - if err != nil { - return fmt.Errorf( - "unable to commit transaction during downgrade script execution: %w", - err, - ) - } - } else { - _, err = mr.db.Exec(downgradeScript) - if err != nil { - return fmt.Errorf("unable to execute downgrade script: %w", 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 fmt.Errorf( - "unable to remove reverted migration from bolt_migrations table: %w", - 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 4e41b36..9f4f9e8 100644 --- a/internal/repositories/migration_db_repo_test.go +++ b/internal/repositories/migration_db_repo_test.go @@ -197,7 +197,7 @@ func TestMigrationDBRepo_ApplyAndRevertWithoutTransaction(t *testing.T) { migration := models.NewTimestampMigration(time.Now(), "test") // CREATE INDEX CONCURRENTLY cannot run inside a transaction. err = repo.Apply( - `-- bolt: no-transaction\CREATE INDEX CONCURRENTLY i1 ON tmp(id2);`, + `-- bolt: no-transaction\nCREATE INDEX CONCURRENTLY i1 ON tmp(id2);`, migration, ) assert.Nil(t, err) diff --git a/internal/repositories/migration_fs_repo.go b/internal/repositories/migration_fs_repo.go index c541006..9d21c59 100644 --- a/internal/repositories/migration_fs_repo.go +++ b/internal/repositories/migration_fs_repo.go @@ -23,13 +23,23 @@ func (e *ErrIsNotDir) Error() string { ) } -type MigrationFsRepo struct { +type MigrationFsRepo interface { + Create(migration *models.Migration) error + Exists(version string) (bool, error) + Get(version string) (*models.Migration, error) + List() (map[string]*models.Migration, error) + Latest() (*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) { +) (MigrationFsRepo, error) { fileInfo, err := os.Stat(migrationsConfig.DirectoryPath) if errors.Is(err, os.ErrNotExist) { err = os.MkdirAll(migrationsConfig.DirectoryPath, 0755) @@ -42,10 +52,10 @@ func NewMigrationFsRepo( 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) @@ -66,7 +76,7 @@ func (mr *MigrationFsRepo) Create(migration *models.Migration) error { return nil } -func (mr *MigrationFsRepo) Exists(version string) (bool, error) { +func (mr migrationFsRepo) Exists(version string) (bool, error) { migrations, err := mr.List() if err != nil { return false, err @@ -76,7 +86,7 @@ func (mr *MigrationFsRepo) Exists(version string) (bool, error) { return ok, nil } -func (mr *MigrationFsRepo) Get(version string) (*models.Migration, error) { +func (mr migrationFsRepo) Get(version string) (*models.Migration, error) { migrations, err := mr.List() if err != nil { return nil, err @@ -90,7 +100,7 @@ func (mr *MigrationFsRepo) Get(version string) (*models.Migration, error) { return migration, nil } -func (mr *MigrationFsRepo) Latest() (*models.Migration, error) { +func (mr migrationFsRepo) Latest() (*models.Migration, error) { entries, err := os.ReadDir(mr.migrationsDirPath) if err != nil { return nil, err @@ -103,13 +113,13 @@ func (mr *MigrationFsRepo) Latest() (*models.Migration, error) { return nil, 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 { migration, err := dirEntryToMigration(entry) if err != nil { @@ -137,9 +147,7 @@ func dirEntryToMigration(entry fs.DirEntry) (*models.Migration, error) { }, nil } -func (mr *MigrationFsRepo) ReadUpgradeScript( - migration *models.Migration, -) (string, error) { +func (mr migrationFsRepo) ReadUpgradeScript(migration *models.Migration) (string, error) { upgradeScriptPath := filepath.Join( mr.migrationsDirPath, mr.migrationDirname(migration), @@ -148,7 +156,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( @@ -159,7 +167,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 @@ -170,13 +178,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, " ", "_") -- cgit v1.2.3 From 6760ae82d62449f41c68950264c02c40be81bfb3 Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sat, 2 Mar 2024 09:29:41 -0500 Subject: Improve coverage for separate Tx methods --- internal/repositories/migration_db_repo.go | 19 ++- internal/repositories/migration_db_repo_test.go | 188 +++++++++++++++++++----- 2 files changed, 163 insertions(+), 44 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_db_repo.go b/internal/repositories/migration_db_repo.go index 500fea4..7a90a2a 100644 --- a/internal/repositories/migration_db_repo.go +++ b/internal/repositories/migration_db_repo.go @@ -9,10 +9,17 @@ import ( "github.com/eugenetriguba/bolt/internal/models" ) -type SQLExecutor interface { +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) @@ -23,14 +30,14 @@ type MigrationDBRepo interface { } type migrationDBRepo struct { - db *sql.DB + 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 @@ -38,7 +45,7 @@ func NewMigrationDBRepo(db *sql.DB) (MigrationDBRepo, error) { `) if err != nil { return nil, fmt.Errorf( - "unable to create bolt_migrations database table: %w", + "unable to confirm bolt_migrations database table exists: %w", err, ) } @@ -157,7 +164,7 @@ func (mr migrationDBRepo) ApplyWithTx( } func applyMigration( - executor SQLExecutor, + executor sqlExecutor, upgradeScript string, migration models.Migration, ) error { @@ -229,7 +236,7 @@ func (mr migrationDBRepo) RevertWithTx( } func revertMigration( - executor SQLExecutor, + executor sqlExecutor, downgradeScript string, migration models.Migration, ) error { diff --git a/internal/repositories/migration_db_repo_test.go b/internal/repositories/migration_db_repo_test.go index 9f4f9e8..2775faa 100644 --- a/internal/repositories/migration_db_repo_test.go +++ b/internal/repositories/migration_db_repo_test.go @@ -2,6 +2,7 @@ package repositories_test import ( "database/sql" + "errors" "testing" "time" @@ -11,7 +12,7 @@ import ( "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 @@ -36,7 +37,7 @@ func TestMigrationDBRepo_NewMigrationDBRepoCreatesTable(t *testing.T) { 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.Nil(t, err) @@ -53,7 +54,20 @@ func TestMigrationDBRepo_NewMigrationDBRepoLeavesCurrentTable(t *testing.T) { 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.Nil(t, err) @@ -63,7 +77,22 @@ func TestMigrationDBRepo_ListWithEmptyTable(t *testing.T) { 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.Nil(t, err) @@ -82,7 +111,7 @@ 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.Nil(t, err) @@ -101,7 +130,7 @@ 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.Nil(t, err) @@ -112,7 +141,7 @@ func TestMigrationDBRepo_IsAppliedWithNotApplied(t *testing.T) { 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.Nil(t, err) @@ -126,7 +155,7 @@ func TestMigrationDBRepo_IsAppliedWithApplied(t *testing.T) { 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.Nil(t, err) @@ -150,7 +179,69 @@ func TestMigrationDBRepo_Apply(t *testing.T) { assert.Equal(t, applied, true) } -func TestMigrationDBRepo_Revert(t *testing.T) { +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(` + 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 TestRevert(t *testing.T) { db := bolttest.NewTestDB(t, "postgres") repo, err := repositories.NewMigrationDBRepo(db) assert.Nil(t, err) @@ -187,57 +278,78 @@ func TestMigrationDBRepo_Revert(t *testing.T) { 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.Nil(t, err) - _, err = db.Exec("CREATE TABLE tmp(id INT PRIMARY KEY, id2 INT, id3 INT)") - assert.Nil(t, err) - migration := models.NewTimestampMigration(time.Now(), "test") - // CREATE INDEX CONCURRENTLY cannot run inside a transaction. - err = repo.Apply( - `-- bolt: no-transaction\nCREATE INDEX CONCURRENTLY i1 ON tmp(id2);`, - migration, - ) - 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.Revert( - "-- bolt: no-transaction\nCREATE INDEX CONCURRENTLY i2 ON tmp(id3);", - migration, - ) +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) - assert.Equal(t, migration.Applied, false) + 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.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.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) } -- cgit v1.2.3 From 018083b9259c2265ad3ea2432f315641e5b996ce Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sat, 2 Mar 2024 10:18:41 -0500 Subject: Clean up fs repo and fs repo tests --- internal/repositories/migration_fs_repo.go | 46 +++----- internal/repositories/migration_fs_repo_test.go | 141 ++++++++++++++++++++++-- 2 files changed, 147 insertions(+), 40 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_fs_repo.go b/internal/repositories/migration_fs_repo.go index 9d21c59..9d6c3aa 100644 --- a/internal/repositories/migration_fs_repo.go +++ b/internal/repositories/migration_fs_repo.go @@ -25,8 +25,6 @@ func (e *ErrIsNotDir) Error() string { type MigrationFsRepo interface { Create(migration *models.Migration) error - Exists(version string) (bool, error) - Get(version string) (*models.Migration, error) List() (map[string]*models.Migration, error) Latest() (*models.Migration, error) ReadUpgradeScript(migration *models.Migration) (string, error) @@ -41,14 +39,22 @@ 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} } @@ -76,31 +82,11 @@ 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) Latest() (*models.Migration, error) { + // TODO: ReadDir returns migrations sorted by filename. + // To be correct, it seems like we will need to sort these + // migrations by the version style that is configured and then + // grab the latest. entries, err := os.ReadDir(mr.migrationsDirPath) if err != nil { return nil, err diff --git a/internal/repositories/migration_fs_repo_test.go b/internal/repositories/migration_fs_repo_test.go index 72ba792..d10bddc 100644 --- a/internal/repositories/migration_fs_repo_test.go +++ b/internal/repositories/migration_fs_repo_test.go @@ -18,18 +18,18 @@ func assertFileExists(t *testing.T, path string) { 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.Nil(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} @@ -37,10 +37,19 @@ func TestNewMigrationFsRepoMigrationDirIsFile(t *testing.T) { 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) @@ -56,13 +65,29 @@ 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.Nil(t, err) + + migration := models.NewSequentialMigration(1, "add users table") err = repo.Create(migration) assert.Nil(t, err) @@ -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,15 +134,24 @@ func TestMigrationFsRepoReadUpgradeAndDowngradeScript(t *testing.T) { 0755, ) - upgradeScriptContents, err := repo.ReadUpgradeScript(migration) - assert.Nil(t, err) - assert.Equal(t, upgradeScriptContents, string(expectedUpgradeScriptContents)) downgradeScriptContents, err := repo.ReadDowngradeScript(migration) 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) @@ -113,3 +176,61 @@ func TestMigrationFsRepo_List(t *testing.T) { 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 _", + ) +} + +func TestLatest_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.Latest() + + assert.NotNil(t, err) + assert.ErrorContains(t, err, "no such file or directory") +} + +func TestLatest_NoMigrations(t *testing.T) { + migrationsDir := filepath.Join(t.TempDir(), "migrations") + migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir} + repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) + assert.Nil(t, err) + + latestMigration, err := repo.Latest() + + assert.Nil(t, err) + assert.Nil(t, latestMigration) +} -- cgit v1.2.3 From a37df93853def914dbda165cdcf09ae8e0305ec3 Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sat, 2 Mar 2024 11:04:00 -0500 Subject: Remove Latest() from migration fs repo in favor of using List on service --- internal/repositories/migration_fs_repo.go | 18 ----------------- internal/repositories/migration_fs_repo_test.go | 26 ------------------------- 2 files changed, 44 deletions(-) (limited to 'internal/repositories') diff --git a/internal/repositories/migration_fs_repo.go b/internal/repositories/migration_fs_repo.go index 9d6c3aa..e535013 100644 --- a/internal/repositories/migration_fs_repo.go +++ b/internal/repositories/migration_fs_repo.go @@ -26,7 +26,6 @@ func (e *ErrIsNotDir) Error() string { type MigrationFsRepo interface { Create(migration *models.Migration) error List() (map[string]*models.Migration, error) - Latest() (*models.Migration, error) ReadUpgradeScript(migration *models.Migration) (string, error) ReadDowngradeScript(migration *models.Migration) (string, error) } @@ -82,23 +81,6 @@ func (mr migrationFsRepo) Create(migration *models.Migration) error { return nil } -func (mr migrationFsRepo) Latest() (*models.Migration, error) { - // TODO: ReadDir returns migrations sorted by filename. - // To be correct, it seems like we will need to sort these - // migrations by the version style that is configured and then - // grab the latest. - entries, err := os.ReadDir(mr.migrationsDirPath) - if err != nil { - return nil, err - } - - if len(entries) > 0 { - return dirEntryToMigration(entries[len(entries)-1]) - } - - return nil, nil -} - func (mr migrationFsRepo) List() (map[string]*models.Migration, error) { entries, err := os.ReadDir(mr.migrationsDirPath) if err != nil { diff --git a/internal/repositories/migration_fs_repo_test.go b/internal/repositories/migration_fs_repo_test.go index d10bddc..32de193 100644 --- a/internal/repositories/migration_fs_repo_test.go +++ b/internal/repositories/migration_fs_repo_test.go @@ -208,29 +208,3 @@ func TestList_InvalidMigrationName(t *testing.T) { "expected a migration directory of the format _", ) } - -func TestLatest_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.Latest() - - assert.NotNil(t, err) - assert.ErrorContains(t, err, "no such file or directory") -} - -func TestLatest_NoMigrations(t *testing.T) { - migrationsDir := filepath.Join(t.TempDir(), "migrations") - migrationsConfig := configloader.MigrationsConfig{DirectoryPath: migrationsDir} - repo, err := repositories.NewMigrationFsRepo(&migrationsConfig) - assert.Nil(t, err) - - latestMigration, err := repo.Latest() - - assert.Nil(t, err) - assert.Nil(t, latestMigration) -} -- cgit v1.2.3