Make migrate safe

database/rqlite/rqlite_test.go

@@ -156,102 +156,6 @@ func TestNoConfig(t *testing.T) {
 	})
 }
 
-func TestWithInstanceEmptyConfig(t *testing.T) {
-	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
-		ip, port, err := c.Port(defaultPort)
-		assert.NoError(t, err)
-
-		// gorqlite expects http(s) schemes
-		connectString := fmt.Sprintf("http://%s:%s?level=strong&disableClusterDiscovery=true", ip, port)
-		t.Logf("DB connect string : %s\n", connectString)
-		db, err := gorqlite.Open(connectString)
-		assert.NoError(t, err)
-
-		driver, err := WithInstance(db, &Config{})
-		assert.NoError(t, err)
-
-		defer func() {
-			if err := driver.Close(); err != nil {
-				t.Fatal(err)
-			}
-		}()
-
-		m, err := migrate.NewWithDatabaseInstance(
-			"file://./examples/migrations",
-			"ql", driver)
-		assert.NoError(t, err)
-
-		t.Log("UP")
-		err = m.Up()
-		assert.NoError(t, err)
-
-		_, err = db.QueryOne(fmt.Sprintf("SELECT * FROM %s", DefaultMigrationsTable))
-		assert.NoError(t, err)
-
-		t.Log("DOWN")
-		err = m.Down()
-		assert.NoError(t, err)
-	})
-}
-
-func TestMigrationTable(t *testing.T) {
-	dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) {
-		ip, port, err := c.Port(defaultPort)
-		assert.NoError(t, err)
-
-		// gorqlite expects http(s) schemes
-		connectString := fmt.Sprintf("http://%s:%s?level=strong&disableClusterDiscovery=true", ip, port)
-		t.Logf("DB connect string : %s\n", connectString)
-		db, err := gorqlite.Open(connectString)
-		assert.NoError(t, err)
-
-		config := Config{MigrationsTable: "my_migration_table"}
-		driver, err := WithInstance(db, &config)
-		assert.NoError(t, err)
-
-		defer func() {
-			if err := driver.Close(); err != nil {
-				t.Fatal(err)
-			}
-		}()
-
-		m, err := migrate.NewWithDatabaseInstance(
-			"file://./examples/migrations",
-			"ql", driver)
-		assert.NoError(t, err)
-
-		t.Log("UP")
-		err = m.Up()
-		assert.NoError(t, err)
-
-		_, err = db.QueryOne(fmt.Sprintf("SELECT * FROM %s", config.MigrationsTable))
-		assert.NoError(t, err)
-
-		_, err = db.WriteOne(`INSERT INTO pets (name, predator) VALUES ("franklin", true)`)
-		assert.NoError(t, err)
-
-		res, err := db.QueryOne(`SELECT name, predator FROM pets LIMIT 1`)
-		assert.NoError(t, err)
-
-		_ = res.Next()
-
-		// make sure we can use the migrated table
-		var petName string
-		var petPredator int
-		err = res.Scan(&petName, &petPredator)
-		assert.NoError(t, err)
-		assert.Equal(t, petName, "franklin")
-		assert.Equal(t, petPredator, 1)
-
-		t.Log("DOWN")
-		err = m.Down()
-		assert.NoError(t, err)
-
-		_, err = db.QueryOne(fmt.Sprintf("SELECT * FROM %s", config.MigrationsTable))
-		assert.NoError(t, err)
-	})
-}
-
 func TestParseUrl(t *testing.T) {
 	tests := []struct {
 		name           string

database/testing/migrate_testing.go

@@ -5,25 +5,13 @@ package testing
 
 import (
 	"testing"
-)
 
-import (
 	"github.com/golang-migrate/migrate/v4"
 )
 
 // TestMigrate runs integration-tests between the Migrate layer and database implementations.
 func TestMigrate(t *testing.T, m *migrate.Migrate) {
 	TestMigrateUp(t, m)
-	TestMigrateDrop(t, m)
-}
-
-// Regression test for preventing a regression for #164 https://github.com/golang-migrate/migrate/pull/173
-// Similar to TestDrop(), but tests the dropping mechanism through the Migrate logic instead, to check for
-// double-locking during the Drop logic.
-func TestMigrateDrop(t *testing.T, m *migrate.Migrate) {
-	if err := m.Drop(); err != nil {
-		t.Fatal(err)
-	}
 }
 
 func TestMigrateUp(t *testing.T, m *migrate.Migrate) {

internal/cli/commands.go

@@ -185,19 +185,7 @@ func downCmd(m *migrate.Migrate, limit int) error {
 			log.Println(err)
 		}
 	} else {
-		if err := m.Down(); err != nil {
-			if err != migrate.ErrNoChange {
-				return err
-			}
-			log.Println(err)
-		}
-	}
-	return nil
-}
-
-func dropCmd(m *migrate.Migrate) error {
-	if err := m.Drop(); err != nil {
-		return err
+		log.Println("With migrate-safe you can not apply all down migrations. Please specify a number of migrations to apply.")
 	}
 	return nil
 }
@@ -221,28 +209,3 @@ func versionCmd(m *migrate.Migrate) error {
 	}
 	return nil
 }
-
-// numDownMigrationsFromArgs returns an int for number of migrations to apply
-// and a bool indicating if we need a confirm before applying
-func numDownMigrationsFromArgs(applyAll bool, args []string) (int, bool, error) {
-	if applyAll {
-		if len(args) > 0 {
-			return 0, false, errors.New("-all cannot be used with other arguments")
-		}
-		return -1, false, nil
-	}
-
-	switch len(args) {
-	case 0:
-		return -1, true, nil
-	case 1:
-		downValue := args[0]
-		n, err := strconv.ParseUint(downValue, 10, 64)
-		if err != nil {
-			return 0, false, errors.New("can't read limit argument N")
-		}
-		return int(n), false, nil
-	default:
-		return 0, false, errors.New("too many arguments")
-	}
-}

internal/cli/commands_test.go

@@ -252,41 +252,3 @@ func (s *CreateCmdSuite) TestCreateCmd() {
 		})
 	}
 }
-
-func TestNumDownFromArgs(t *testing.T) {
-	cases := []struct {
-		name                string
-		args                []string
-		applyAll            bool
-		expectedNeedConfirm bool
-		expectedNum         int
-		expectedErrStr      string
-	}{
-		{"no args", []string{}, false, true, -1, ""},
-		{"down all", []string{}, true, false, -1, ""},
-		{"down 5", []string{"5"}, false, false, 5, ""},
-		{"down N", []string{"N"}, false, false, 0, "can't read limit argument N"},
-		{"extra arg after -all", []string{"5"}, true, false, 0, "-all cannot be used with other arguments"},
-		{"extra arg before -all", []string{"5", "-all"}, false, false, 0, "too many arguments"},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			num, needsConfirm, err := numDownMigrationsFromArgs(c.applyAll, c.args)
-			if needsConfirm != c.expectedNeedConfirm {
-				t.Errorf("Incorrect needsConfirm was: %v wanted %v", needsConfirm, c.expectedNeedConfirm)
-			}
-
-			if num != c.expectedNum {
-				t.Errorf("Incorrect num was: %v wanted %v", num, c.expectedNum)
-			}
-
-			if err != nil {
-				if err.Error() != c.expectedErrStr {
-					t.Error("Incorrect error: " + err.Error() + " != " + c.expectedErrStr)
-				}
-			} else if c.expectedErrStr != "" {
-				t.Error("Expected error: " + c.expectedErrStr + " but got nil instead")
-			}
-		})
-	}
-}

internal/cli/main.go

@@ -254,38 +254,7 @@ Database drivers: `+strings.Join(database.List(), ", ")+"\n", createUsage, gotoU
 		}
 
 	case "down":
-		downFlagSet, helpPtr := newFlagSetWithHelp("down")
-		applyAll := downFlagSet.Bool("all", false, "Apply all down migrations")
-
-		if err := downFlagSet.Parse(args); err != nil {
-			log.fatalErr(err)
-		}
-
-		handleSubCmdHelp(*helpPtr, downUsage, downFlagSet)
-
-		if migraterErr != nil {
-			log.fatalErr(migraterErr)
-		}
-
-		downArgs := downFlagSet.Args()
-		num, needsConfirm, err := numDownMigrationsFromArgs(*applyAll, downArgs)
-		if err != nil {
-			log.fatalErr(err)
-		}
-		if needsConfirm {
-			log.Println("Are you sure you want to apply all down migrations? [y/N]")
-			var response string
-			_, _ = fmt.Scanln(&response)
-			response = strings.ToLower(strings.TrimSpace(response))
-
-			if response == "y" {
-				log.Println("Applying all down migrations")
-			} else {
-				log.fatal("Not applying all down migrations")
-			}
-		}
-
-		if err := downCmd(migrater, num); err != nil {
+		if err := downCmd(migrater, 1); err != nil {
 			log.fatalErr(err)
 		}
 
@@ -295,38 +264,15 @@ Database drivers: `+strings.Join(database.List(), ", ")+"\n", createUsage, gotoU
 
 	case "drop":
 		dropFlagSet, help := newFlagSetWithHelp("drop")
-		forceDrop := dropFlagSet.Bool("f", false, "Force the drop command by bypassing the confirmation prompt")
+		_ = dropFlagSet.Bool("f", false, "Force the drop command by bypassing the confirmation prompt")
 
 		if err := dropFlagSet.Parse(args); err != nil {
 			log.fatalErr(err)
 		}
 
 		handleSubCmdHelp(*help, dropUsage, dropFlagSet)
 
-		if !*forceDrop {
-			log.Println("Are you sure you want to drop the entire database schema? [y/N]")
-			var response string
-			_, _ = fmt.Scanln(&response)
-			response = strings.ToLower(strings.TrimSpace(response))
-
-			if response == "y" {
-				log.Println("Dropping the entire database schema")
-			} else {
-				log.fatal("Aborted dropping the entire database schema")
-			}
-		}
-
-		if migraterErr != nil {
-			log.fatalErr(migraterErr)
-		}
-
-		if err := dropCmd(migrater); err != nil {
-			log.fatalErr(err)
-		}
-
-		if log.verbose {
-			log.Println("Finished after", time.Since(startTime))
-		}
+		log.fatal("With migrate-safe you can not drop the entire database schema. Please specify a number of migrations to apply.")
 
 	case "force":
 		forceSet, helpPtr := newFlagSetWithHelp("force")

migrate.go

@@ -284,38 +284,6 @@ func (m *Migrate) Up() error {
 	return m.unlockErr(m.runMigrations(ret))
 }
 
-// Down looks at the currently active migration version
-// and will migrate all the way down (applying all down migrations).
-func (m *Migrate) Down() error {
-	if err := m.lock(); err != nil {
-		return err
-	}
-
-	curVersion, dirty, err := m.databaseDrv.Version()
-	if err != nil {
-		return m.unlockErr(err)
-	}
-
-	if dirty {
-		return m.unlockErr(ErrDirty{curVersion})
-	}
-
-	ret := make(chan interface{}, m.PrefetchMigrations)
-	go m.readDown(curVersion, -1, ret)
-	return m.unlockErr(m.runMigrations(ret))
-}
-
-// Drop deletes everything in the database.
-func (m *Migrate) Drop() error {
-	if err := m.lock(); err != nil {
-		return err
-	}
-	if err := m.databaseDrv.Drop(); err != nil {
-		return m.unlockErr(err)
-	}
-	return m.unlock()
-}
-
 // Run runs any migration provided by you against the database.
 // It does not check any currently active version in database.
 // Usually you don't need this function at all. Use Migrate,