aboutsummaryrefslogtreecommitdiffstats
path: root/internal/services/migration_test.go
diff options
context:
space:
mode:
authorEugene Triguba <hello@eugenetriguba.com>2025-10-18 10:43:39 -0400
committerEugene Triguba <hello@eugenetriguba.com>2025-11-26 11:46:57 -0500
commite5658d1f61415054029b66cd2f703f1f40138460 (patch)
treec609e209f4cebc62dd985d1b773558f47eb73bf6 /internal/services/migration_test.go
parentAdd is-branch main check for docs deployment (diff)
downloadcli-e5658d1f61415054029b66cd2f703f1f40138460.zip
Add support for migration dependencies
Diffstat (limited to 'internal/services/migration_test.go')
-rw-r--r--internal/services/migration_test.go771
1 files changed, 370 insertions, 401 deletions
diff --git a/internal/services/migration_test.go b/internal/services/migration_test.go
index 09d33a3..c931dc9 100644
--- a/internal/services/migration_test.go
+++ b/internal/services/migration_test.go
@@ -18,7 +18,7 @@ func TestListMigrations(t *testing.T) {
localFilesystemMigrations []*models.Migration
remoteAppliedMigrations []*models.Migration
cfg configloader.Config
- sortOrder sortOrder
+ sortOrder SortOrder
expectedMigrations []*models.Migration
}
@@ -85,16 +85,12 @@ func TestListMigrations(t *testing.T) {
sortOrder: SortOrderAsc,
expectedMigrations: []*models.Migration{},
},
- // Ensure that migrations are sorted in asc order for sequential migrations
+ // Ensure that migrations are sorted by dependencies (topological order)
{
localFilesystemMigrations: []*models.Migration{
- {Version: "20000"},
- {Version: "10000"},
- {Version: "1010"},
- {Version: "1009"},
- {Version: "190"},
- {Version: "110"},
- {Version: "001"},
+ {Version: "003", Dependencies: []string{"001", "002"}},
+ {Version: "002", Dependencies: []string{"001"}},
+ {Version: "001", Dependencies: []string{}},
},
remoteAppliedMigrations: []*models.Migration{},
cfg: configloader.Config{
@@ -104,25 +100,17 @@ func TestListMigrations(t *testing.T) {
},
sortOrder: SortOrderAsc,
expectedMigrations: []*models.Migration{
- {Version: "001"},
- {Version: "110"},
- {Version: "190"},
- {Version: "1009"},
- {Version: "1010"},
- {Version: "10000"},
- {Version: "20000"},
+ {Version: "001", Dependencies: []string{}},
+ {Version: "002", Dependencies: []string{"001"}},
+ {Version: "003", Dependencies: []string{"001", "002"}},
},
},
- // Ensure that migrations are sorted in desc order for sequential migrations
+ // Ensure that migrations are sorted in reverse topological order for desc
{
localFilesystemMigrations: []*models.Migration{
- {Version: "001"},
- {Version: "110"},
- {Version: "190"},
- {Version: "1009"},
- {Version: "1010"},
- {Version: "10000"},
- {Version: "20000"},
+ {Version: "001", Dependencies: []string{}},
+ {Version: "002", Dependencies: []string{"001"}},
+ {Version: "003", Dependencies: []string{"001", "002"}},
},
remoteAppliedMigrations: []*models.Migration{},
cfg: configloader.Config{
@@ -132,69 +120,9 @@ func TestListMigrations(t *testing.T) {
},
sortOrder: SortOrderDesc,
expectedMigrations: []*models.Migration{
- {Version: "20000"},
- {Version: "10000"},
- {Version: "1010"},
- {Version: "1009"},
- {Version: "190"},
- {Version: "110"},
- {Version: "001"},
- },
- },
- // Ensure that migrations are sorted in asc order for timestamp migrations
- {
- localFilesystemMigrations: []*models.Migration{
- {Version: "20080509220905"},
- {Version: "20080509220405"},
- {Version: "20080509150405"},
- {Version: "20080502150405"},
- {Version: "20080102150405"},
- {Version: "20070102150405"},
- {Version: "20060102150405"},
- },
- remoteAppliedMigrations: []*models.Migration{},
- cfg: configloader.Config{
- Migrations: configloader.MigrationsConfig{
- VersionStyle: configloader.VersionStyleTimestamp,
- },
- },
- sortOrder: SortOrderAsc,
- expectedMigrations: []*models.Migration{
- {Version: "20060102150405"},
- {Version: "20070102150405"},
- {Version: "20080102150405"},
- {Version: "20080502150405"},
- {Version: "20080509150405"},
- {Version: "20080509220405"},
- {Version: "20080509220905"},
- },
- },
- // Ensure that migrations are sorted in desc order for timestamp migrations
- {
- localFilesystemMigrations: []*models.Migration{
- {Version: "20060102150405"},
- {Version: "20070102150405"},
- {Version: "20080102150405"},
- {Version: "20080502150405"},
- {Version: "20080509150405"},
- {Version: "20080509220405"},
- {Version: "20080509220905"},
- },
- remoteAppliedMigrations: []*models.Migration{},
- cfg: configloader.Config{
- Migrations: configloader.MigrationsConfig{
- VersionStyle: configloader.VersionStyleTimestamp,
- },
- },
- sortOrder: SortOrderDesc,
- expectedMigrations: []*models.Migration{
- {Version: "20080509220905"},
- {Version: "20080509220405"},
- {Version: "20080509150405"},
- {Version: "20080502150405"},
- {Version: "20080102150405"},
- {Version: "20070102150405"},
- {Version: "20060102150405"},
+ {Version: "003", Dependencies: []string{"001", "002"}},
+ {Version: "002", Dependencies: []string{"001"}},
+ {Version: "001", Dependencies: []string{}},
},
},
}
@@ -235,127 +163,6 @@ func TestListMigrations(t *testing.T) {
}
}
-func TestListMigrations_FsRepoListError(t *testing.T) {
- expectedErr := errors.New("fs repo error")
- migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ListReturnValue: bolttest.ListReturnValue{
- Migrations: nil,
- Err: expectedErr,
- },
- }
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- ListReturnValue: bolttest.ListReturnValue{
- Migrations: nil,
- Err: nil,
- },
- }
-
- svc := NewMigrationService(
- migrationDbRepo,
- migrationFsRepo,
- configloader.Config{},
- bolttest.NullOutputter{},
- )
- migrations, err := svc.ListMigrations(SortOrderAsc)
-
- assert.ErrorIs(t, err, expectedErr)
- var expectedMigrations []*models.Migration
- assert.DeepEqual(t, migrations, expectedMigrations)
-}
-
-func TestListMigrations_DbRepoListError(t *testing.T) {
- expectedErr := errors.New("db repo error")
- migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ListReturnValue: bolttest.ListReturnValue{
- Migrations: nil,
- Err: nil,
- },
- }
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- ListReturnValue: bolttest.ListReturnValue{
- Migrations: nil,
- Err: expectedErr,
- },
- }
-
- svc := NewMigrationService(
- migrationDbRepo,
- migrationFsRepo,
- configloader.Config{},
- bolttest.NullOutputter{},
- )
- migrations, err := svc.ListMigrations(SortOrderAsc)
-
- assert.ErrorIs(t, err, expectedErr)
- var expectedMigrations []*models.Migration
- assert.DeepEqual(t, migrations, expectedMigrations)
-}
-
-func TestListMigrations_ParseErrDuringSort(t *testing.T) {
- type test struct {
- m1 models.Migration
- m2 models.Migration
- versionStyle configloader.VersionStyle
- }
-
- tests := []test{
- {
- m1: models.Migration{Version: "abc"},
- m2: models.Migration{Version: "123"},
- versionStyle: configloader.VersionStyleSequential,
- },
- {
- m1: models.Migration{Version: "123"},
- m2: models.Migration{Version: "abc"},
- versionStyle: configloader.VersionStyleSequential,
- },
- {
- m1: models.Migration{Version: "20060102150405"},
- m2: models.Migration{Version: "abc"},
- versionStyle: configloader.VersionStyleTimestamp,
- },
- {
- m1: models.Migration{Version: "abc"},
- m2: models.Migration{Version: "20060102150405"},
- versionStyle: configloader.VersionStyleTimestamp,
- },
- }
-
- for _, tc := range tests {
- migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ListReturnValue: bolttest.ListReturnValue{
- Migrations: map[string]*models.Migration{
- tc.m1.Version: {Version: tc.m1.Version},
- tc.m2.Version: {Version: tc.m2.Version},
- },
- Err: nil,
- },
- }
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- ListReturnValue: bolttest.ListReturnValue{
- Migrations: nil,
- Err: nil,
- },
- }
-
- svc := NewMigrationService(
- migrationDbRepo,
- migrationFsRepo,
- configloader.Config{
- Migrations: configloader.MigrationsConfig{
- VersionStyle: tc.versionStyle,
- },
- },
- bolttest.NullOutputter{},
- )
- migrations, err := svc.ListMigrations(SortOrderAsc)
-
- assert.ErrorContains(t, err, "unable to sort migrations")
- var expectedMigrations []*models.Migration
- assert.DeepEqual(t, migrations, expectedMigrations)
- }
-}
-
func TestCreateMigration_VersionStyleTimestamp(t *testing.T) {
migrationFsRepo := &bolttest.MockMigrationFsRepo{
CreateReturnValue: bolttest.CreateReturnValue{
@@ -580,140 +387,169 @@ func TestCreateMigration_SequentialVersionIncrementsParsingErr(t *testing.T) {
assert.Nil(t, migration)
}
-func TestApplyMigration_WithTransaction(t *testing.T) {
+func TestCreateMigration_FirstMigrationNoDependencies(t *testing.T) {
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadUpgradeScriptReturnValue: bolttest.ReadUpgradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Contents: "CREATE TABLE tmp(id INT PRIMARY KEY, id2 INT, id3 INT);",
- Options: sqlparse.ExecutionOptions{UseTransaction: true},
- },
- Err: nil,
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{},
+ Err: nil,
},
- }
-
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- ApplyWithTxReturnValue: bolttest.ApplyWithTxReturnValue{
+ CreateReturnValue: bolttest.CreateReturnValue{
Err: nil,
},
}
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.ApplyMigration(&models.Migration{})
+ migration, err := svc.CreateMigration("first migration")
assert.Nil(t, err)
- assert.Equal(t, migrationDbRepo.ApplyWithTxCallCount, 1)
- assert.Equal(t, migrationDbRepo.ApplyCallCount, 0)
+ assert.Equal(t, len(migration.Dependencies), 0)
}
-func TestApplyMigration_WithoutTransaction(t *testing.T) {
+func TestCreateMigration_SecondMigrationDependsOnFirst(t *testing.T) {
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadUpgradeScriptReturnValue: bolttest.ReadUpgradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Contents: "CREATE TABLE tmp(id INT PRIMARY KEY, id2 INT, id3 INT);",
- Options: sqlparse.ExecutionOptions{UseTransaction: false},
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{
+ "001": {Version: "001", Dependencies: []string{}},
},
Err: nil,
},
- }
-
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- ApplyReturnValue: bolttest.ApplyReturnValue{
+ CreateReturnValue: bolttest.CreateReturnValue{
Err: nil,
},
}
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.ApplyMigration(&models.Migration{})
+ migration, err := svc.CreateMigration("second migration")
assert.Nil(t, err)
- assert.Equal(t, migrationDbRepo.ApplyWithTxCallCount, 0)
- assert.Equal(t, migrationDbRepo.ApplyCallCount, 1)
+ assert.Equal(t, len(migration.Dependencies), 1)
+ assert.Contains(t, migration.Dependencies, "001")
}
-func TestApplyMigration_ReadUpgradeScriptErr(t *testing.T) {
- expectedErr := errors.New("error!")
+func TestCreateMigration_LinearChainDependsOnLatest(t *testing.T) {
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadUpgradeScriptReturnValue: bolttest.ReadUpgradeScriptReturnValue{
- Script: sqlparse.MigrationScript{},
- Err: expectedErr,
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{
+ "001": {Version: "001", Dependencies: []string{}},
+ "002": {Version: "002", Dependencies: []string{"001"}},
+ "003": {Version: "003", Dependencies: []string{"002"}},
+ },
+ Err: nil,
+ },
+ CreateReturnValue: bolttest.CreateReturnValue{
+ Err: nil,
},
}
-
migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.ApplyMigration(&models.Migration{})
+ migration, err := svc.CreateMigration("fourth migration")
- assert.ErrorIs(t, err, expectedErr)
+ assert.Nil(t, err)
+ assert.Equal(t, len(migration.Dependencies), 1)
+ assert.Contains(t, migration.Dependencies, "003")
}
-func TestApplyMigration_ApplyWithTxErr(t *testing.T) {
+func TestCreateMigration_ParallelBranchesDependsOnBoth(t *testing.T) {
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadUpgradeScriptReturnValue: bolttest.ReadUpgradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Options: sqlparse.ExecutionOptions{
- UseTransaction: true,
- },
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{
+ "001": {Version: "001", Dependencies: []string{}},
+ "002": {Version: "002", Dependencies: []string{"001"}},
+ "003": {Version: "003", Dependencies: []string{"001"}},
},
Err: nil,
},
+ CreateReturnValue: bolttest.CreateReturnValue{
+ Err: nil,
+ },
}
- expectedErr := errors.New("error!")
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- ApplyWithTxReturnValue: bolttest.ApplyWithTxReturnValue{Err: expectedErr},
- }
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.ApplyMigration(&models.Migration{})
+ migration, err := svc.CreateMigration("merge migration")
- assert.ErrorIs(t, err, expectedErr)
+ assert.Nil(t, err)
+ assert.Equal(t, len(migration.Dependencies), 2)
+ assert.Contains(t, migration.Dependencies, "002")
+ assert.Contains(t, migration.Dependencies, "003")
}
-func TestApplyMigration_ApplyErr(t *testing.T) {
+func TestCreateMigration_ComplexGraphMultipleLeaves(t *testing.T) {
+ // Diamond shape: 001 -> 002, 001 -> 003, 002 -> 004, 003 -> 004
+ // Plus independent branch: 005
+ // Leaf nodes are 004 and 005
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadUpgradeScriptReturnValue: bolttest.ReadUpgradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Options: sqlparse.ExecutionOptions{
- UseTransaction: false,
- },
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{
+ "001": {Version: "001", Dependencies: []string{}},
+ "002": {Version: "002", Dependencies: []string{"001"}},
+ "003": {Version: "003", Dependencies: []string{"001"}},
+ "004": {Version: "004", Dependencies: []string{"002", "003"}},
+ "005": {Version: "005", Dependencies: []string{}},
},
Err: nil,
},
+ CreateReturnValue: bolttest.CreateReturnValue{
+ Err: nil,
+ },
}
- expectedErr := errors.New("error!")
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- ApplyReturnValue: bolttest.ApplyReturnValue{Err: expectedErr},
- }
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.ApplyMigration(&models.Migration{})
+ migration, err := svc.CreateMigration("new migration")
- assert.ErrorIs(t, err, expectedErr)
+ assert.Nil(t, err)
+ assert.Equal(t, len(migration.Dependencies), 2)
+ assert.Contains(t, migration.Dependencies, "004")
+ assert.Contains(t, migration.Dependencies, "005")
}
func TestApplyAllMigrations_ListMigrationsErr(t *testing.T) {
@@ -918,163 +754,242 @@ func TestApplyUpToVersion_AppliesMigrations(t *testing.T) {
assert.Equal(t, migrationFsRepo.ReadUpgradeScriptCallCount, 2)
}
-func TestRevertMigration_WithTransaction(t *testing.T) {
+func TestRevertDownToVersion_ListMigrationsErr(t *testing.T) {
+ expectedErr := errors.New("error!")
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Contents: "DROP TABLE tmp;",
- Options: sqlparse.ExecutionOptions{UseTransaction: true},
- },
- Err: nil,
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: nil,
+ Err: expectedErr,
},
}
+ svc := NewMigrationService(
+ &bolttest.MockMigrationDBRepo{},
+ migrationFsRepo,
+ configloader.Config{},
+ bolttest.NullOutputter{},
+ )
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- RevertWithTxReturnValue: bolttest.RevertWithTxReturnValue{
- Err: nil,
+ err := svc.RevertDownToVersion("001")
+
+ assert.ErrorIs(t, err, expectedErr)
+}
+
+func TestRevertDownToVersion_TargetMigrationNotFound(t *testing.T) {
+ migrations := map[string]*models.Migration{
+ "001": {Version: "001", Applied: true},
+ }
+ migrationFsRepo := &bolttest.MockMigrationFsRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: migrations,
+ Err: nil,
},
}
svc := NewMigrationService(
- migrationDbRepo,
+ &bolttest.MockMigrationDBRepo{},
migrationFsRepo,
configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertMigration(&models.Migration{})
+ err := svc.RevertDownToVersion("002")
- assert.Nil(t, err)
- assert.Equal(t, migrationDbRepo.RevertWithTxCallCount, 1)
- assert.Equal(t, migrationDbRepo.RevertCallCount, 0)
+ assert.ErrorContains(t, err, "migration with version 002 does not exist")
}
-func TestRevertMigration_WithoutTransaction(t *testing.T) {
- migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Contents: "DROP TABLE tmp;",
- Options: sqlparse.ExecutionOptions{UseTransaction: false},
- },
- Err: nil,
- },
+func TestRevertDownToVersion_TargetMigrationNotApplied(t *testing.T) {
+ migrations := map[string]*models.Migration{
+ "001": {Version: "001", Applied: false},
}
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- RevertReturnValue: bolttest.RevertReturnValue{
- Err: nil,
+ migrationFsRepo := &bolttest.MockMigrationFsRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: migrations,
+ Err: nil,
},
}
svc := NewMigrationService(
- migrationDbRepo,
+ &bolttest.MockMigrationDBRepo{},
migrationFsRepo,
configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertMigration(&models.Migration{})
+ err := svc.RevertDownToVersion("001")
- assert.Nil(t, err)
- assert.Equal(t, migrationDbRepo.RevertWithTxCallCount, 0)
- assert.Equal(t, migrationDbRepo.RevertCallCount, 1)
+ assert.ErrorContains(t, err, "migration with version 001 isn't applied")
}
-func TestRevertMigration_ReadUpgradeScriptErr(t *testing.T) {
+func TestRevertDownToVersion_RevertMigrationErr(t *testing.T) {
+ migrations := map[string]*models.Migration{
+ "001": {Version: "001", Applied: true},
+ }
expectedErr := errors.New("error!")
migrationFsRepo := &bolttest.MockMigrationFsRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: migrations,
+ Err: nil,
+ },
ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
- Script: sqlparse.MigrationScript{},
- Err: expectedErr,
+ Err: expectedErr,
},
}
- migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
- migrationDbRepo,
+ &bolttest.MockMigrationDBRepo{},
migrationFsRepo,
configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertMigration(&models.Migration{})
+ err := svc.RevertDownToVersion("001")
assert.ErrorIs(t, err, expectedErr)
}
-func TestRevertMigration_RevertWithTxErr(t *testing.T) {
+func TestRevertDownToVersion_RevertsMigrations(t *testing.T) {
+ migrations := map[string]*models.Migration{
+ "001": {Version: "001", Applied: true},
+ "002": {Version: "002", Applied: true},
+ "003": {Version: "003", Applied: false},
+ }
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Options: sqlparse.ExecutionOptions{
- UseTransaction: true,
- },
- },
- Err: nil,
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: migrations,
+ Err: nil,
},
}
+ svc := NewMigrationService(
+ &bolttest.MockMigrationDBRepo{},
+ migrationFsRepo,
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
+ },
+ },
+ bolttest.NullOutputter{},
+ )
+
+ err := svc.RevertDownToVersion("001")
+
+ assert.Nil(t, err)
+ assert.Equal(t, migrationFsRepo.ReadDowngradeScriptCallCount, 2)
+}
+
+func TestRevertAllMigrations_ListMigrationsErr(t *testing.T) {
expectedErr := errors.New("error!")
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- RevertWithTxReturnValue: bolttest.RevertWithTxReturnValue{Err: expectedErr},
+ migrationFsRepo := &bolttest.MockMigrationFsRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: nil,
+ Err: expectedErr,
+ },
}
svc := NewMigrationService(
- migrationDbRepo,
+ &bolttest.MockMigrationDBRepo{},
migrationFsRepo,
configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertMigration(&models.Migration{})
+ err := svc.RevertAllMigrations()
assert.ErrorIs(t, err, expectedErr)
}
-func TestRevertMigration_RevertErr(t *testing.T) {
+func TestRevertAllMigrations_RevertsNothingIfNoneApplied(t *testing.T) {
+ migrations := map[string]*models.Migration{
+ "001": {Version: "001", Applied: false},
+ "002": {Version: "002", Applied: false},
+ }
migrationFsRepo := &bolttest.MockMigrationFsRepo{
- ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
- Script: sqlparse.MigrationScript{
- Options: sqlparse.ExecutionOptions{
- UseTransaction: false,
- },
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: migrations,
+ Err: nil,
+ },
+ }
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{}
+ svc := NewMigrationService(
+ migrationDbRepo,
+ migrationFsRepo,
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
},
- Err: nil,
},
+ bolttest.NullOutputter{},
+ )
+
+ err := svc.RevertAllMigrations()
+
+ assert.Nil(t, err)
+ assert.Equal(t, migrationDbRepo.RevertCallCount, 0)
+ assert.Equal(t, migrationDbRepo.RevertWithTxCallCount, 0)
+}
+
+func TestRevertAllMigrations_RevertMigrationErr(t *testing.T) {
+ migrations := map[string]*models.Migration{
+ "001": {Version: "001", Applied: true},
}
expectedErr := errors.New("error!")
- migrationDbRepo := &bolttest.MockMigrationDBRepo{
- RevertReturnValue: bolttest.RevertReturnValue{Err: expectedErr},
+ migrationFsRepo := &bolttest.MockMigrationFsRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: migrations,
+ Err: nil,
+ },
+ ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
+ Err: expectedErr,
+ },
}
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleSequential,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.RevertMigration(&models.Migration{})
+ err := svc.RevertAllMigrations()
assert.ErrorIs(t, err, expectedErr)
+ assert.Equal(t, migrationDbRepo.RevertCallCount, 0)
+ assert.Equal(t, migrationDbRepo.RevertWithTxCallCount, 0)
}
-func TestRevertDownToVersion_ListMigrationsErr(t *testing.T) {
- expectedErr := errors.New("error!")
+func TestCreateMigration_FsRepoListErrForLeafNodes(t *testing.T) {
+ // Test fsRepo.List error when finding leaf nodes (line 280)
+ // Using timestamp version style so we only call List once (for leaf nodes)
+ expectedErr := errors.New("fs error finding leaf nodes")
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
Migrations: nil,
Err: expectedErr,
},
}
+
svc := NewMigrationService(
&bolttest.MockMigrationDBRepo{},
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleTimestamp,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.RevertDownToVersion("001")
+ migration, err := svc.CreateMigration("new migration")
assert.ErrorIs(t, err, expectedErr)
+ assert.ErrorContains(t, err, "unable to list migrations for finding leaf nodes")
+ assert.Nil(t, migration)
}
-func TestRevertDownToVersion_TargetMigrationNotFound(t *testing.T) {
+func TestApplyAllMigrations_CheckDependenciesAppliedErr(t *testing.T) {
+ // Test CheckDependenciesApplied error (line 66)
+ // Migration 002 depends on 001, but 001 doesn't exist
migrations := map[string]*models.Migration{
- "001": {Version: "001", Applied: true},
+ "002": {Version: "002", Dependencies: []string{"001"}, Applied: false},
}
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
@@ -1082,21 +997,29 @@ func TestRevertDownToVersion_TargetMigrationNotFound(t *testing.T) {
Err: nil,
},
}
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{},
+ Err: nil,
+ },
+ }
svc := NewMigrationService(
- &bolttest.MockMigrationDBRepo{},
+ migrationDbRepo,
migrationFsRepo,
configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertDownToVersion("002")
+ err := svc.ApplyAllMigrations()
- assert.ErrorContains(t, err, "migration with version 002 does not exist")
+ assert.ErrorContains(t, err, "non-existent migration 001")
}
-func TestRevertDownToVersion_TargetMigrationNotApplied(t *testing.T) {
+func TestApplyUpToVersion_CheckDependenciesAppliedErr(t *testing.T) {
+ // Test CheckDependenciesApplied error in ApplyUpToVersion (line 116)
+ // Migration 002 depends on 001, but 001 doesn't exist
migrations := map[string]*models.Migration{
- "001": {Version: "001", Applied: false},
+ "002": {Version: "002", Dependencies: []string{"001"}, Applied: false},
}
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
@@ -1104,49 +1027,62 @@ func TestRevertDownToVersion_TargetMigrationNotApplied(t *testing.T) {
Err: nil,
},
}
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{},
+ Err: nil,
+ },
+ }
svc := NewMigrationService(
- &bolttest.MockMigrationDBRepo{},
+ migrationDbRepo,
migrationFsRepo,
configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertDownToVersion("001")
+ err := svc.ApplyUpToVersion("002")
- assert.ErrorContains(t, err, "migration with version 001 isn't applied")
+ assert.ErrorContains(t, err, "non-existent migration 001")
}
-func TestRevertDownToVersion_RevertMigrationErr(t *testing.T) {
+func TestRevertAllMigrations_CheckNoDependentsAppliedErr(t *testing.T) {
+ // Test CheckNoDependentsApplied error (line 173)
migrations := map[string]*models.Migration{
- "001": {Version: "001", Applied: true},
+ "001": {Version: "001", Dependencies: []string{}, Applied: true},
+ "002": {Version: "002", Dependencies: []string{"001"}, Applied: true},
}
- expectedErr := errors.New("error!")
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
Migrations: migrations,
Err: nil,
},
- ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
- Err: expectedErr,
+ }
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{
+ "001": {Version: "001", Applied: true},
+ "002": {Version: "002", Applied: true},
+ },
+ Err: nil,
},
}
svc := NewMigrationService(
- &bolttest.MockMigrationDBRepo{},
+ migrationDbRepo,
migrationFsRepo,
configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertDownToVersion("001")
+ err := svc.RevertAllMigrations()
- assert.ErrorIs(t, err, expectedErr)
+ assert.ErrorContains(t, err, "cannot revert migration")
}
-func TestRevertDownToVersion_RevertsMigrations(t *testing.T) {
+func TestRevertDownToVersion_CheckNoDependentsAppliedErr(t *testing.T) {
+ // Test CheckNoDependentsApplied error in RevertDownToVersion (line 223)
migrations := map[string]*models.Migration{
- "001": {Version: "001", Applied: true},
- "002": {Version: "002", Applied: true},
- "003": {Version: "003", Applied: false},
+ "001": {Version: "001", Dependencies: []string{}, Applied: true},
+ "002": {Version: "002", Dependencies: []string{"001"}, Applied: true},
}
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
@@ -1154,102 +1090,135 @@ func TestRevertDownToVersion_RevertsMigrations(t *testing.T) {
Err: nil,
},
}
- svc := NewMigrationService(
- &bolttest.MockMigrationDBRepo{},
- migrationFsRepo,
- configloader.Config{
- Migrations: configloader.MigrationsConfig{
- VersionStyle: configloader.VersionStyleSequential,
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{
+ "001": {Version: "001", Applied: true},
+ "002": {Version: "002", Applied: true},
},
+ Err: nil,
},
+ }
+ svc := NewMigrationService(
+ migrationDbRepo,
+ migrationFsRepo,
+ configloader.Config{},
bolttest.NullOutputter{},
)
err := svc.RevertDownToVersion("001")
- assert.Nil(t, err)
- assert.Equal(t, migrationFsRepo.ReadDowngradeScriptCallCount, 2)
+ assert.ErrorContains(t, err, "cannot revert migration")
}
-func TestRevertAllMigrations_ListMigrationsErr(t *testing.T) {
- expectedErr := errors.New("error!")
+func TestCreateMigration_FindLeafNodesErr(t *testing.T) {
+ // Test FindLeafNodes error when existing migrations have circular dependency (line 285)
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
- Migrations: nil,
- Err: expectedErr,
+ Migrations: map[string]*models.Migration{
+ "001": {Version: "001", Dependencies: []string{"002"}},
+ "002": {Version: "002", Dependencies: []string{"001"}},
+ },
+ Err: nil,
},
}
svc := NewMigrationService(
&bolttest.MockMigrationDBRepo{},
migrationFsRepo,
- configloader.Config{},
+ configloader.Config{
+ Migrations: configloader.MigrationsConfig{
+ VersionStyle: configloader.VersionStyleTimestamp,
+ },
+ },
bolttest.NullOutputter{},
)
- err := svc.RevertAllMigrations()
+ migration, err := svc.CreateMigration("new migration")
- assert.ErrorIs(t, err, expectedErr)
+ assert.NotNil(t, err)
+ assert.ErrorContains(t, err, "circular dependency")
+ assert.Nil(t, migration)
}
-func TestRevertAllMigrations_RevertsNothingIfNoneApplied(t *testing.T) {
+func TestApplyAllMigrations_DependencyNotYetAppliedInLoop(t *testing.T) {
+ // Test that CheckDependenciesApplied fails when a dependency was applied earlier
+ // in the same ApplyAllMigrations call but the Applied field wasn't updated
migrations := map[string]*models.Migration{
- "001": {Version: "001", Applied: false},
- "002": {Version: "002", Applied: false},
+ "001": {Version: "001", Dependencies: []string{}, Applied: false},
+ "002": {Version: "002", Dependencies: []string{"001"}, Applied: false},
}
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
Migrations: migrations,
Err: nil,
},
+ ReadUpgradeScriptReturnValue: bolttest.ReadUpgradeScriptReturnValue{
+ Script: sqlparse.MigrationScript{
+ Contents: "CREATE TABLE test (id INT);",
+ Options: sqlparse.ExecutionOptions{UseTransaction: true},
+ },
+ Err: nil,
+ },
+ }
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{},
+ Err: nil,
+ },
+ ApplyWithTxReturnValue: bolttest.ApplyWithTxReturnValue{
+ Err: nil,
+ },
}
- migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{
- Migrations: configloader.MigrationsConfig{
- VersionStyle: configloader.VersionStyleSequential,
- },
- },
+ configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertAllMigrations()
+ err := svc.ApplyAllMigrations()
- assert.Nil(t, err)
- assert.Equal(t, migrationDbRepo.RevertCallCount, 0)
- assert.Equal(t, migrationDbRepo.RevertWithTxCallCount, 0)
+ // This should fail because after applying 001, its Applied field in the list
+ // is still false, so CheckDependenciesApplied for 002 will fail
+ assert.ErrorContains(t, err, "dependency 001 has not been applied")
}
-func TestRevertAllMigrations_RevertMigrationErr(t *testing.T) {
+func TestApplyUpToVersion_DependencyNotYetAppliedInLoop(t *testing.T) {
+ // Same test for ApplyUpToVersion
migrations := map[string]*models.Migration{
- "001": {Version: "001", Applied: true},
+ "001": {Version: "001", Dependencies: []string{}, Applied: false},
+ "002": {Version: "002", Dependencies: []string{"001"}, Applied: false},
}
- expectedErr := errors.New("error!")
migrationFsRepo := &bolttest.MockMigrationFsRepo{
ListReturnValue: bolttest.ListReturnValue{
Migrations: migrations,
Err: nil,
},
- ReadDowngradeScriptReturnValue: bolttest.ReadDowngradeScriptReturnValue{
- Err: expectedErr,
+ ReadUpgradeScriptReturnValue: bolttest.ReadUpgradeScriptReturnValue{
+ Script: sqlparse.MigrationScript{
+ Contents: "CREATE TABLE test (id INT);",
+ Options: sqlparse.ExecutionOptions{UseTransaction: true},
+ },
+ Err: nil,
+ },
+ }
+ migrationDbRepo := &bolttest.MockMigrationDBRepo{
+ ListReturnValue: bolttest.ListReturnValue{
+ Migrations: map[string]*models.Migration{},
+ Err: nil,
+ },
+ ApplyWithTxReturnValue: bolttest.ApplyWithTxReturnValue{
+ Err: nil,
},
}
- migrationDbRepo := &bolttest.MockMigrationDBRepo{}
svc := NewMigrationService(
migrationDbRepo,
migrationFsRepo,
- configloader.Config{
- Migrations: configloader.MigrationsConfig{
- VersionStyle: configloader.VersionStyleSequential,
- },
- },
+ configloader.Config{},
bolttest.NullOutputter{},
)
- err := svc.RevertAllMigrations()
+ err := svc.ApplyUpToVersion("002")
- assert.ErrorIs(t, err, expectedErr)
- assert.Equal(t, migrationDbRepo.RevertCallCount, 0)
- assert.Equal(t, migrationDbRepo.RevertWithTxCallCount, 0)
+ assert.ErrorContains(t, err, "dependency 001 has not been applied")
}