package migrate_test import ( . "gopkg.in/check.v1" ) /* type MigrateSuite struct { conn *pgx.Conn } func Test(t *testing.T) { TestingT(t) } var _ = Suite(&MigrateSuite{}) var versionTable string = "schema_version_non_default" func (s *MigrateSuite) SetUpTest(c *C) { var err error s.conn, err = pgx.Connect(*defaultConnectionParameters) c.Assert(err, IsNil) s.cleanupSampleMigrator(c) } func (s *MigrateSuite) currentVersion(c *C) int32 { var n int32 err := s.conn.QueryRow("select version from " + versionTable).Scan(&n) c.Assert(err, IsNil) return n } func (s *MigrateSuite) Exec(c *C, sql string, arguments ...interface{}) pgx.CommandTag { commandTag, err := s.conn.Exec(sql, arguments...) c.Assert(err, IsNil) return commandTag } func (s *MigrateSuite) tableExists(c *C, tableName string) bool { var exists bool err := s.conn.QueryRow( "select exists(select 1 from information_schema.tables where table_catalog=$1 and table_name=$2)", defaultConnectionParameters.Database, tableName, ).Scan(&exists) c.Assert(err, IsNil) return exists } func (s *MigrateSuite) createEmptyMigrator(c *C) *migrate.Migrator { var err error m, err := migrate.NewMigrator(s.conn, versionTable) c.Assert(err, IsNil) return m } func (s *MigrateSuite) createSampleMigrator(c *C) *migrate.Migrator { m := s.createEmptyMigrator(c) m.AppendMigration("Create t1", "create table t1(id serial);", "drop table t1;") m.AppendMigration("Create t2", "create table t2(id serial);", "drop table t2;") m.AppendMigration("Create t3", "create table t3(id serial);", "drop table t3;") return m } func (s *MigrateSuite) cleanupSampleMigrator(c *C) { tables := []string{versionTable, "t1", "t2", "t3"} for _, table := range tables { s.Exec(c, "drop table if exists "+table) } } func (s *MigrateSuite) TestNewMigrator(c *C) { var m *migrate.Migrator var err error // Initial run m, err = migrate.NewMigrator(s.conn, versionTable) c.Assert(err, IsNil) // Creates version table schemaVersionExists := s.tableExists(c, versionTable) c.Assert(schemaVersionExists, Equals, true) // Succeeds when version table is already created m, err = migrate.NewMigrator(s.conn, versionTable) c.Assert(err, IsNil) initialVersion, err := m.GetCurrentVersion() c.Assert(err, IsNil) c.Assert(initialVersion, Equals, int32(0)) } func (s *MigrateSuite) TestAppendMigration(c *C) { m := s.createEmptyMigrator(c) name := "Create t" upSQL := "create t..." downSQL := "drop t..." m.AppendMigration(name, upSQL, downSQL) c.Assert(len(m.Migrations), Equals, 1) c.Assert(m.Migrations[0].Name, Equals, name) c.Assert(m.Migrations[0].UpSQL, Equals, upSQL) c.Assert(m.Migrations[0].DownSQL, Equals, downSQL) } func (s *MigrateSuite) TestLoadMigrationsMissingDirectory(c *C) { m := s.createEmptyMigrator(c) err := m.LoadMigrations("testdata/missing") c.Assert(err, ErrorMatches, "open testdata/missing: no such file or directory") } func (s *MigrateSuite) TestLoadMigrationsEmptyDirectory(c *C) { m := s.createEmptyMigrator(c) err := m.LoadMigrations("testdata/empty") c.Assert(err, ErrorMatches, "No migrations found at testdata/empty") } func (s *MigrateSuite) TestFindMigrationsWithGaps(c *C) { _, err := migrate.FindMigrations("testdata/gap") c.Assert(err, ErrorMatches, "Missing migration 2") } func (s *MigrateSuite) TestFindMigrationsWithDuplicate(c *C) { _, err := migrate.FindMigrations("testdata/duplicate") c.Assert(err, ErrorMatches, "Duplicate migration 2") } func (s *MigrateSuite) TestLoadMigrations(c *C) { m := s.createEmptyMigrator(c) m.Data = map[string]interface{}{"prefix": "foo"} err := m.LoadMigrations("testdata/sample") c.Assert(err, IsNil) c.Assert(m.Migrations, HasLen, 5) c.Check(m.Migrations[0].Name, Equals, "001_create_t1.sql") c.Check(m.Migrations[0].UpSQL, Equals, `create table t1( id serial primary key );`) c.Check(m.Migrations[0].DownSQL, Equals, "drop table t1;") c.Check(m.Migrations[1].Name, Equals, "002_create_t2.sql") c.Check(m.Migrations[1].UpSQL, Equals, `create table t2( id serial primary key );`) c.Check(m.Migrations[1].DownSQL, Equals, "drop table t2;") c.Check(m.Migrations[2].Name, Equals, "003_irreversible.sql") c.Check(m.Migrations[2].UpSQL, Equals, "drop table t2;") c.Check(m.Migrations[2].DownSQL, Equals, "") c.Check(m.Migrations[3].Name, Equals, "004_data_interpolation.sql") c.Check(m.Migrations[3].UpSQL, Equals, "create table foo_bar(id serial primary key);") c.Check(m.Migrations[3].DownSQL, Equals, "drop table foo_bar;") } func (s *MigrateSuite) TestLoadMigrationsNoForward(c *C) { var err error m, err := migrate.NewMigrator(s.conn, versionTable) c.Assert(err, IsNil) m.Data = map[string]interface{}{"prefix": "foo"} err = m.LoadMigrations("testdata/noforward") c.Assert(err, Equals, migrate.ErrNoFwMigration) } func (s *MigrateSuite) TestMigrate(c *C) { m := s.createSampleMigrator(c) err := m.Migrate() c.Assert(err, IsNil) currentVersion := s.currentVersion(c) c.Assert(currentVersion, Equals, int32(3)) } func (s *MigrateSuite) TestMigrateToLifeCycle(c *C) { m := s.createSampleMigrator(c) var onStartCallUpCount int var onStartCallDownCount int m.OnStart = func(_ int32, _, direction, _ string) { switch direction { case "up": onStartCallUpCount++ case "down": onStartCallDownCount++ default: c.Fatalf("Unexpected direction: %s", direction) } } // Migrate from 0 up to 1 err := m.MigrateTo(1) c.Assert(err, IsNil) currentVersion := s.currentVersion(c) c.Assert(currentVersion, Equals, int32(1)) c.Assert(s.tableExists(c, "t1"), Equals, true) c.Assert(s.tableExists(c, "t2"), Equals, false) c.Assert(s.tableExists(c, "t3"), Equals, false) c.Assert(onStartCallUpCount, Equals, 1) c.Assert(onStartCallDownCount, Equals, 0) // Migrate from 1 up to 3 err = m.MigrateTo(3) c.Assert(err, IsNil) currentVersion = s.currentVersion(c) c.Assert(currentVersion, Equals, int32(3)) c.Assert(s.tableExists(c, "t1"), Equals, true) c.Assert(s.tableExists(c, "t2"), Equals, true) c.Assert(s.tableExists(c, "t3"), Equals, true) c.Assert(onStartCallUpCount, Equals, 3) c.Assert(onStartCallDownCount, Equals, 0) // Migrate from 3 to 3 is no-op err = m.MigrateTo(3) c.Assert(err, IsNil) currentVersion = s.currentVersion(c) c.Assert(s.tableExists(c, "t1"), Equals, true) c.Assert(s.tableExists(c, "t2"), Equals, true) c.Assert(s.tableExists(c, "t3"), Equals, true) c.Assert(onStartCallUpCount, Equals, 3) c.Assert(onStartCallDownCount, Equals, 0) // Migrate from 3 down to 1 err = m.MigrateTo(1) c.Assert(err, IsNil) currentVersion = s.currentVersion(c) c.Assert(currentVersion, Equals, int32(1)) c.Assert(s.tableExists(c, "t1"), Equals, true) c.Assert(s.tableExists(c, "t2"), Equals, false) c.Assert(s.tableExists(c, "t3"), Equals, false) c.Assert(onStartCallUpCount, Equals, 3) c.Assert(onStartCallDownCount, Equals, 2) // Migrate from 1 down to 0 err = m.MigrateTo(0) c.Assert(err, IsNil) currentVersion = s.currentVersion(c) c.Assert(currentVersion, Equals, int32(0)) c.Assert(s.tableExists(c, "t1"), Equals, false) c.Assert(s.tableExists(c, "t2"), Equals, false) c.Assert(s.tableExists(c, "t3"), Equals, false) c.Assert(onStartCallUpCount, Equals, 3) c.Assert(onStartCallDownCount, Equals, 3) // Migrate back up to 3 err = m.MigrateTo(3) c.Assert(err, IsNil) currentVersion = s.currentVersion(c) c.Assert(currentVersion, Equals, int32(3)) c.Assert(s.tableExists(c, "t1"), Equals, true) c.Assert(s.tableExists(c, "t2"), Equals, true) c.Assert(s.tableExists(c, "t3"), Equals, true) c.Assert(onStartCallUpCount, Equals, 6) c.Assert(onStartCallDownCount, Equals, 3) } func (s *MigrateSuite) TestMigrateToBoundaries(c *C) { m := s.createSampleMigrator(c) // Migrate to -1 is error err := m.MigrateTo(-1) c.Assert(err, ErrorMatches, "destination version -1 is outside the valid versions of 0 to 3") // Migrate past end is error err = m.MigrateTo(int32(len(m.Migrations)) + 1) c.Assert(err, ErrorMatches, "destination version 4 is outside the valid versions of 0 to 3") // When schema version says it is negative s.Exec(c, "update "+versionTable+" set version=-1") err = m.MigrateTo(int32(1)) c.Assert(err, ErrorMatches, "current version -1 is outside the valid versions of 0 to 3") // When schema version says it is negative s.Exec(c, "update "+versionTable+" set version=4") err = m.MigrateTo(int32(1)) c.Assert(err, ErrorMatches, "current version 4 is outside the valid versions of 0 to 3") } func (s *MigrateSuite) TestMigrateToIrreversible(c *C) { m := s.createEmptyMigrator(c) m.AppendMigration("Foo", "drop table if exists t3", "") err := m.MigrateTo(1) c.Assert(err, IsNil) err = m.MigrateTo(0) c.Assert(err, ErrorMatches, "Irreversible migration: 1 - Foo") } func (s *MigrateSuite) TestMigrateToDisableTx(c *C) { m, err := migrate.NewMigratorEx(s.conn, versionTable, &migrate.MigratorOptions{DisableTx: true}) c.Assert(err, IsNil) m.AppendMigration("Create t1", "create table t1(id serial);", "drop table t1;") m.AppendMigration("Create t2", "create table t2(id serial);", "drop table t2;") m.AppendMigration("Create t3", "create table t3(id serial);", "drop table t3;") tx, err := s.conn.Begin() c.Assert(err, IsNil) err = m.MigrateTo(3) c.Assert(err, IsNil) currentVersion := s.currentVersion(c) c.Assert(currentVersion, Equals, int32(3)) c.Assert(s.tableExists(c, "t1"), Equals, true) c.Assert(s.tableExists(c, "t2"), Equals, true) c.Assert(s.tableExists(c, "t3"), Equals, true) err = tx.Rollback() c.Assert(err, IsNil) currentVersion = s.currentVersion(c) c.Assert(currentVersion, Equals, int32(0)) c.Assert(s.tableExists(c, "t1"), Equals, false) c.Assert(s.tableExists(c, "t2"), Equals, false) c.Assert(s.tableExists(c, "t3"), Equals, false) } func Example_OnStartMigrationProgressLogging() { conn, err := pgx.Connect(*defaultConnectionParameters) if err != nil { fmt.Printf("Unable to establish connection: %v", err) return } // Clear any previous runs if _, err = conn.Exec("drop table if exists schema_version"); err != nil { fmt.Printf("Unable to drop schema_version table: %v", err) return } var m *migrate.Migrator m, err = migrate.NewMigrator(conn, "schema_version") if err != nil { fmt.Printf("Unable to create migrator: %v", err) return } m.OnStart = func(_ int32, name, direction, _ string) { fmt.Printf("Migrating %s: %s", direction, name) } m.AppendMigration("create a table", "create temporary table foo(id serial primary key)", "") if err = m.Migrate(); err != nil { fmt.Printf("Unexpected failure migrating: %v", err) return } // Output: // Migrating up: create a table } */