filter enhancements

tools/migrate/runner_test.go

@@ -3,6 +3,7 @@ package migrate
 import (
 	"context"
 	"database/sql"
+	"encoding/json"
 	"testing"
 	"time"
 
@@ -52,73 +53,88 @@ func TestRunnerUpAndDown(t *testing.T) {
 	}
 	defer testDB.Close()
 
-	var test1UpCalled bool
-	var test1DownCalled bool
-	var test2UpCalled bool
-	var test2DownCalled bool
+	callsOrder := []string{}
 
 	l := MigrationsList{}
 	l.Register(func(db dbx.Builder) error {
-		test1UpCalled = true
+		callsOrder = append(callsOrder, "up2")
 		return nil
 	}, func(db dbx.Builder) error {
-		test1DownCalled = true
-		return nil
-	}, "1_test")
-	l.Register(func(db dbx.Builder) error {
-		test2UpCalled = true
-		return nil
-	}, func(db dbx.Builder) error {
-		test2DownCalled = true
+		callsOrder = append(callsOrder, "down2")
 		return nil
 	}, "2_test")
+	l.Register(func(db dbx.Builder) error {
+		callsOrder = append(callsOrder, "up3")
+		return nil
+	}, func(db dbx.Builder) error {
+		callsOrder = append(callsOrder, "down3")
+		return nil
+	}, "3_test")
+	l.Register(func(db dbx.Builder) error {
+		callsOrder = append(callsOrder, "up1")
+		return nil
+	}, func(db dbx.Builder) error {
+		callsOrder = append(callsOrder, "down1")
+		return nil
+	}, "1_test")
 
 	r, err := NewRunner(testDB.DB, l)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	// simulate partially run migration
-	r.saveAppliedMigration(testDB, r.migrationsList.Item(0).File)
+	// simulate partially out-of-order run migration
+	r.saveAppliedMigration(testDB, "2_test")
 
+	// ---------------------------------------------------------------
 	// Up()
-	// ---
+	// ---------------------------------------------------------------
+
 	if _, err := r.Up(); err != nil {
 		t.Fatal(err)
 	}
 
-	if test1UpCalled {
-		t.Fatalf("Didn't expect 1_test to be called")
-	}
+	expectedUpCallsOrder := `["up1","up3"]` // skip up2 since it was applied previously
 
-	if !test2UpCalled {
-		t.Fatalf("Expected 2_test to be called")
-	}
-
-	// simulate unrun migration
-	var test3DownCalled bool
-	r.migrationsList.Register(nil, func(db dbx.Builder) error {
-		test3DownCalled = true
-		return nil
-	}, "3_test")
-
-	// Down()
-	// ---
-	// revert one migration
-	if _, err := r.Down(1); err != nil {
+	upCallsOrder, err := json.Marshal(callsOrder)
+	if err != nil {
 		t.Fatal(err)
 	}
 
-	if test3DownCalled {
-		t.Fatal("Didn't expect 3_test to be reverted.")
+	if v := string(upCallsOrder); v != expectedUpCallsOrder {
+		t.Fatalf("Expected Up() calls order %s, got %s", expectedUpCallsOrder, upCallsOrder)
 	}
 
-	if !test2DownCalled {
-		t.Fatal("Expected 2_test to be reverted.")
+	// ---------------------------------------------------------------
+
+	// reset callsOrder
+	callsOrder = []string{}
+
+	// simulate unrun migration
+	r.migrationsList.Register(nil, func(db dbx.Builder) error {
+		callsOrder = append(callsOrder, "down4")
+		return nil
+	}, "4_test")
+
+	// ---------------------------------------------------------------
+
+	// ---------------------------------------------------------------
+	// Down()
+	// ---------------------------------------------------------------
+
+	if _, err := r.Down(2); err != nil {
+		t.Fatal(err)
 	}
 
-	if test1DownCalled {
-		t.Fatal("Didn't expect 1_test to be reverted.")
+	expectedDownCallsOrder := `["down3","down1"]` // revert in the applied order
+
+	downCallsOrder, err := json.Marshal(callsOrder)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if v := string(downCallsOrder); v != expectedDownCallsOrder {
+		t.Fatalf("Expected Down() calls order %s, got %s", expectedDownCallsOrder, downCallsOrder)
 	}
 }