From 6d8499af8ca0c83d824693c42dcf09a04dd0e907 Mon Sep 17 00:00:00 2001 From: Lukas Joergensen Date: Mon, 18 Feb 2019 10:06:48 +0100 Subject: [PATCH 01/21] Consistently lock in ensureVersionTable and do not call ensureVersionTable from Drop across all database implementations --- database/cassandra/cassandra.go | 27 ++++++++++++++++++++++----- database/clickhouse/clickhouse.go | 23 +++++++++++++++++++++-- database/cockroachdb/cockroachdb.go | 23 +++++++++++++++++++---- database/mysql/mysql.go | 23 +++++++++++++++++++---- database/postgres/postgres.go | 6 +++--- database/ql/ql.go | 23 +++++++++++++++++++---- database/redshift/redshift.go | 23 +++++++++++++++++++---- database/spanner/spanner.go | 22 ++++++++++++++++++---- database/sqlite3/sqlite3.go | 22 ++++++++++++++++++---- 9 files changed, 158 insertions(+), 34 deletions(-) diff --git a/database/cassandra/cassandra.go b/database/cassandra/cassandra.go index 48b4a693b..87abd2e66 100644 --- a/database/cassandra/cassandra.go +++ b/database/cassandra/cassandra.go @@ -12,6 +12,7 @@ import ( "github.com/gocql/gocql" "github.com/golang-migrate/migrate/v4/database" + "github.com/hashicorp/go-multierror" ) func init() { @@ -240,13 +241,29 @@ func (c *Cassandra) Drop() error { return err } } - // Re-create the version table - return c.ensureVersionTable() + + return nil } -// Ensure version table exists -func (c *Cassandra) ensureVersionTable() error { - err := c.session.Query(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (version bigint, dirty boolean, PRIMARY KEY(version))", c.config.MigrationsTable)).Exec() +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the Cassandra type. +func (c *Cassandra) ensureVersionTable() (err error) { + if err = c.Lock(); err != nil { + return err + } + + defer func() { + if e := c.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() + + err = c.session.Query(fmt.Sprintf("CREATE TABLE IF NOT EXISTS %s (version bigint, dirty boolean, PRIMARY KEY(version))", c.config.MigrationsTable)).Exec() if err != nil { return err } diff --git a/database/clickhouse/clickhouse.go b/database/clickhouse/clickhouse.go index 6f98bd181..ebf5b17d6 100644 --- a/database/clickhouse/clickhouse.go +++ b/database/clickhouse/clickhouse.go @@ -11,6 +11,7 @@ import ( "github.com/golang-migrate/migrate/v4" "github.com/golang-migrate/migrate/v4/database" + "github.com/hashicorp/go-multierror" ) var DefaultMigrationsTable = "schema_migrations" @@ -159,7 +160,25 @@ func (ch *ClickHouse) SetVersion(version int, dirty bool) error { return tx.Commit() } -func (ch *ClickHouse) ensureVersionTable() error { + +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the ClickHouse type. +func (ch *ClickHouse) ensureVersionTable() (err error) { + if err = ch.Lock(); err != nil { + return err + } + + defer func() { + if e := ch.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() + var ( table string query = "SHOW TABLES FROM " + ch.config.DatabaseName + " LIKE '" + ch.config.MigrationsTable + "'" @@ -207,7 +226,7 @@ func (ch *ClickHouse) Drop() error { return &database.Error{OrigErr: err, Query: []byte(query)} } } - return ch.ensureVersionTable() + return nil } func (ch *ClickHouse) Lock() error { return nil } diff --git a/database/cockroachdb/cockroachdb.go b/database/cockroachdb/cockroachdb.go index df32db0d8..41379384f 100644 --- a/database/cockroachdb/cockroachdb.go +++ b/database/cockroachdb/cockroachdb.go @@ -13,6 +13,7 @@ import ( import ( "github.com/cockroachdb/cockroach-go/crdb" + "github.com/hashicorp/go-multierror" "github.com/lib/pq" ) @@ -294,15 +295,29 @@ func (c *CockroachDb) Drop() error { return &database.Error{OrigErr: err, Query: []byte(query)} } } - if err := c.ensureVersionTable(); err != nil { - return err - } } return nil } -func (c *CockroachDb) ensureVersionTable() error { +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the CockroachDb type. +func (c *CockroachDb) ensureVersionTable() (err error) { + if err = c.Lock(); err != nil { + return err + } + + defer func() { + if e := c.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() + // check if migration table exists var count int query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1` diff --git a/database/mysql/mysql.go b/database/mysql/mysql.go index 20c840e02..6d6a1907b 100644 --- a/database/mysql/mysql.go +++ b/database/mysql/mysql.go @@ -17,6 +17,7 @@ import ( import ( "github.com/go-sql-driver/mysql" + "github.com/hashicorp/go-multierror" ) import ( @@ -342,15 +343,29 @@ func (m *Mysql) Drop() error { return &database.Error{OrigErr: err, Query: []byte(query)} } } - if err := m.ensureVersionTable(); err != nil { - return err - } } return nil } -func (m *Mysql) ensureVersionTable() error { +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the Mysql type. +func (m *Mysql) ensureVersionTable() (err error) { + if err = m.Lock(); err != nil { + return err + } + + defer func() { + if e := m.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() + // check if migration table exists var result string query := `SHOW TABLES LIKE "` + m.config.MigrationsTable + `"` diff --git a/database/postgres/postgres.go b/database/postgres/postgres.go index b840df84b..f5a4d49e7 100644 --- a/database/postgres/postgres.go +++ b/database/postgres/postgres.go @@ -325,14 +325,14 @@ func (p *Postgres) Drop() error { return &database.Error{OrigErr: err, Query: []byte(query)} } } - if err := p.ensureVersionTable(); err != nil { - return err - } } return nil } +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the Postgres type. func (p *Postgres) ensureVersionTable() (err error) { if err = p.Lock(); err != nil { return err diff --git a/database/ql/ql.go b/database/ql/ql.go index 86b2364dd..97a38bb25 100644 --- a/database/ql/ql.go +++ b/database/ql/ql.go @@ -3,6 +3,7 @@ package ql import ( "database/sql" "fmt" + "github.com/hashicorp/go-multierror" "io" "io/ioutil" "strings" @@ -59,7 +60,24 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { } return mx, nil } -func (m *Ql) ensureVersionTable() error { +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the Ql type. +func (m *Ql) ensureVersionTable() (err error) { + if err = m.Lock(); err != nil { + return err + } + + defer func() { + if e := m.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() + tx, err := m.db.Begin() if err != nil { return err @@ -132,9 +150,6 @@ func (m *Ql) Drop() error { return &database.Error{OrigErr: err, Query: []byte(query)} } } - if err := m.ensureVersionTable(); err != nil { - return err - } } return nil diff --git a/database/redshift/redshift.go b/database/redshift/redshift.go index 19f1b9f78..27bd8347f 100644 --- a/database/redshift/redshift.go +++ b/database/redshift/redshift.go @@ -14,6 +14,7 @@ import ( "github.com/golang-migrate/migrate/v4" "github.com/golang-migrate/migrate/v4/database" + "github.com/hashicorp/go-multierror" "github.com/lib/pq" ) @@ -282,15 +283,29 @@ func (p *Redshift) Drop() error { return &database.Error{OrigErr: err, Query: []byte(query)} } } - if err := p.ensureVersionTable(); err != nil { - return err - } } return nil } -func (p *Redshift) ensureVersionTable() error { +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the Redshift type. +func (p *Redshift) ensureVersionTable() (err error) { + if err = p.Lock(); err != nil { + return err + } + + defer func() { + if e := p.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() + // check if migration table exists var count int query := `SELECT COUNT(1) FROM information_schema.tables WHERE table_name = $1 AND table_schema = (SELECT current_schema()) LIMIT 1` diff --git a/database/spanner/spanner.go b/database/spanner/spanner.go index 84ff25224..f5983433b 100644 --- a/database/spanner/spanner.go +++ b/database/spanner/spanner.go @@ -17,6 +17,7 @@ import ( "github.com/golang-migrate/migrate/v4" "github.com/golang-migrate/migrate/v4/database" + "github.com/hashicorp/go-multierror" "google.golang.org/api/iterator" adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1" ) @@ -255,14 +256,27 @@ func (s *Spanner) Drop() error { return &database.Error{OrigErr: err, Query: []byte(strings.Join(stmts, "; "))} } - if err := s.ensureVersionTable(); err != nil { + return nil +} + +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the Spanner type. +func (s *Spanner) ensureVersionTable() (err error) { + if err = s.Lock(); err != nil { return err } - return nil -} + defer func() { + if e := s.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() -func (s *Spanner) ensureVersionTable() error { ctx := context.Background() tbl := s.config.MigrationsTable iter := s.db.data.Single().Read(ctx, tbl, spanner.AllKeys(), []string{"Version"}) diff --git a/database/sqlite3/sqlite3.go b/database/sqlite3/sqlite3.go index d65fe8070..3f33e7e17 100644 --- a/database/sqlite3/sqlite3.go +++ b/database/sqlite3/sqlite3.go @@ -10,6 +10,7 @@ import ( "github.com/golang-migrate/migrate/v4" "github.com/golang-migrate/migrate/v4/database" + "github.com/hashicorp/go-multierror" _ "github.com/mattn/go-sqlite3" ) @@ -58,7 +59,23 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return mx, nil } -func (m *Sqlite) ensureVersionTable() error { +// ensureVersionTable checks if versions table exists and, if not, creates it. +// Note that this function locks the database, which deviates from the usual +// convention of "caller locks" in the Sqlite type. +func (m *Sqlite) ensureVersionTable() (err error) { + if err = m.Lock(); err != nil { + return err + } + + defer func() { + if e := m.Unlock(); e != nil { + if err == nil { + err = e + } else { + err = multierror.Append(err, e) + } + } + }() query := fmt.Sprintf(` CREATE TABLE IF NOT EXISTS %s (version uint64,dirty bool); @@ -125,9 +142,6 @@ func (m *Sqlite) Drop() error { return &database.Error{OrigErr: err, Query: []byte(query)} } } - if err := m.ensureVersionTable(); err != nil { - return err - } query := "VACUUM" _, err = m.db.Query(query) if err != nil { From 36d865c389c8fe888c7fde919ffb229abdae4514 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Mon, 18 Feb 2019 10:28:16 +0100 Subject: [PATCH 02/21] Add test for dropping postgres databases --- database/postgres/postgres_test.go | 43 ++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index 6b9390a8b..0c266e9e7 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -307,6 +307,49 @@ func TestPostgres_Lock(t *testing.T) { }) } +func TestDrop(t *testing.T) { + dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { + ip, port, err := c.FirstPort() + if err != nil { + t.Fatal(err) + } + + addr := pgConnectionString(ip, port) + p := &Postgres{} + d, err := p.Open(addr) + if err != nil { + t.Fatalf("%v", err) + } + defer d.Close() + if err := d.Run(strings.NewReader("CREATE TABLE foo (foo text);")); err != nil { + t.Fatalf("expected err to be nil, got %v", err) + } + + // drop the table + if err := d.Drop(); err != nil { + t.Fatalf("expected err to be nil, got %v", err) + } + + // make sure table does not exist + var exists bool + if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'foo' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil { + t.Fatal(err) + } + if !exists { + t.Fatalf("expected table foo to exist") + } + + // make sure version table is dropped as well + version, _, err := d.Version() + if err != nil { + t.Fatal(err) + } + if version != -1 { + t.Fatal("expected NilVersion") + } + }) +} + func TestWithInstance_Concurrent(t *testing.T) { dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { ip, port, err := c.FirstPort() From 9d8ef5ec9d2d031aeb75c2aee4bf08db0ec97aa2 Mon Sep 17 00:00:00 2001 From: Lukas Joergensen Date: Mon, 18 Feb 2019 11:05:40 +0100 Subject: [PATCH 03/21] Fix failing database tests --- database/postgres/postgres_test.go | 4 ++-- database/testing/testing.go | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index 0c266e9e7..d9e489a39 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -335,8 +335,8 @@ func TestDrop(t *testing.T) { if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'foo' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil { t.Fatal(err) } - if !exists { - t.Fatalf("expected table foo to exist") + if exists { + t.Fatalf("expected table foo to not exist") } // make sure version table is dropped as well diff --git a/database/testing/testing.go b/database/testing/testing.go index 6d561d48e..e45b186b3 100644 --- a/database/testing/testing.go +++ b/database/testing/testing.go @@ -22,8 +22,8 @@ func Test(t *testing.T, d database.Driver, migration []byte) { TestNilVersion(t, d) // test first TestLockAndUnlock(t, d) TestRun(t, d, bytes.NewReader(migration)) - TestDrop(t, d) TestSetVersion(t, d) // also tests Version() + TestDrop(t, d) } func TestNilVersion(t *testing.T, d database.Driver) { From 45d3ba3a89e3d5d0bace50509dc9946fa47e995e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Mon, 18 Feb 2019 13:17:20 +0100 Subject: [PATCH 04/21] Fix CockroachDb test, lock table should be created before versionTable --- database/cockroachdb/cockroachdb.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/database/cockroachdb/cockroachdb.go b/database/cockroachdb/cockroachdb.go index 41379384f..c18edcd7a 100644 --- a/database/cockroachdb/cockroachdb.go +++ b/database/cockroachdb/cockroachdb.go @@ -86,11 +86,12 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config: config, } - if err := px.ensureVersionTable(); err != nil { + // ensureVersionTable is a locking operation, so we need to ensureLockTable before we ensureVersionTable. + if err := px.ensureLockTable(); err != nil { return nil, err } - if err := px.ensureLockTable(); err != nil { + if err := px.ensureVersionTable(); err != nil { return nil, err } From 3fd53140dab55fa20c4fa0fece28b25a660a9fe9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Tue, 19 Feb 2019 15:19:57 +0100 Subject: [PATCH 05/21] Add Initialize() to Driver interface, and add integration tests for Drop() between database implementations and migrate --- database/cassandra/cassandra.go | 14 +++++---- database/clickhouse/clickhouse.go | 6 ++-- database/cockroachdb/cockroachdb.go | 32 ++++++++++++-------- database/cockroachdb/cockroachdb_test.go | 16 ++++++++++ database/driver.go | 7 +++++ database/mongodb/mongodb.go | 18 +++++++---- database/mongodb/mongodb_test.go | 29 ++++++++++++++++++ database/mysql/mysql.go | 17 ++++++----- database/mysql/mysql_test.go | 10 +++++++ database/postgres/postgres.go | 14 ++++++--- database/postgres/postgres_test.go | 16 ++++++++++ database/ql/ql.go | 11 ++++--- database/ql/ql_test.go | 10 +++++++ database/redshift/redshift.go | 17 ++++++----- database/redshift/redshift_test.go | 15 ++++++++++ database/spanner/spanner.go | 15 +++++----- database/spanner/spanner_test.go | 10 +++++++ database/sqlite3/sqlite3.go | 11 +++++-- database/sqlite3/sqlite3_test.go | 12 +++++++- database/stub/stub.go | 4 +++ database/stub/stub_test.go | 1 + database/testing/migrate_testing.go | 38 ++++++++++++++++++++++++ database/testing/testing.go | 9 +++++- 23 files changed, 270 insertions(+), 62 deletions(-) create mode 100644 database/testing/migrate_testing.go diff --git a/database/cassandra/cassandra.go b/database/cassandra/cassandra.go index 87abd2e66..f0e5ec89d 100644 --- a/database/cassandra/cassandra.go +++ b/database/cassandra/cassandra.go @@ -54,22 +54,26 @@ func WithInstance(session *gocql.Session, config *Config) (database.Driver, erro return nil, ErrClosedSession } - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } - c := &Cassandra{ session: session, config: config, } - if err := c.ensureVersionTable(); err != nil { + if err := c.Initialize(); err != nil { return nil, err } return c, nil } +func (c *Cassandra) Initialize() error { + if len(c.config.MigrationsTable) == 0 { + c.config.MigrationsTable = DefaultMigrationsTable + } + + return c.ensureVersionTable() +} + func (c *Cassandra) Open(url string) (database.Driver, error) { u, err := nurl.Parse(url) if err != nil { diff --git a/database/clickhouse/clickhouse.go b/database/clickhouse/clickhouse.go index ebf5b17d6..e55a92844 100644 --- a/database/clickhouse/clickhouse.go +++ b/database/clickhouse/clickhouse.go @@ -42,7 +42,7 @@ func WithInstance(conn *sql.DB, config *Config) (database.Driver, error) { config: config, } - if err := ch.init(); err != nil { + if err := ch.Initialize(); err != nil { return nil, err } @@ -75,14 +75,14 @@ func (ch *ClickHouse) Open(dsn string) (database.Driver, error) { }, } - if err := ch.init(); err != nil { + if err := ch.Initialize(); err != nil { return nil, err } return ch, nil } -func (ch *ClickHouse) init() error { +func (ch *ClickHouse) Initialize() error { if len(ch.config.DatabaseName) == 0 { if err := ch.conn.QueryRow("SELECT currentDatabase()").Scan(&ch.config.DatabaseName); err != nil { return err diff --git a/database/cockroachdb/cockroachdb.go b/database/cockroachdb/cockroachdb.go index c18edcd7a..0c0d94ed4 100644 --- a/database/cockroachdb/cockroachdb.go +++ b/database/cockroachdb/cockroachdb.go @@ -73,29 +73,37 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config.DatabaseName = databaseName - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable + px := &CockroachDb{ + db: instance, + config: config, } - if len(config.LockTable) == 0 { - config.LockTable = DefaultLockTable + if err := px.Initialize(); err != nil { + return nil, err } - px := &CockroachDb{ - db: instance, - config: config, + return px, nil +} + +func (c *CockroachDb) Initialize() error { + if len(c.config.MigrationsTable) == 0 { + c.config.MigrationsTable = DefaultMigrationsTable + } + + if len(c.config.LockTable) == 0 { + c.config.LockTable = DefaultLockTable } // ensureVersionTable is a locking operation, so we need to ensureLockTable before we ensureVersionTable. - if err := px.ensureLockTable(); err != nil { - return nil, err + if err := c.ensureLockTable(); err != nil { + return err } - if err := px.ensureVersionTable(); err != nil { - return nil, err + if err := c.ensureVersionTable(); err != nil { + return err } - return px, nil + return nil } func (c *CockroachDb) Open(url string) (database.Driver, error) { diff --git a/database/cockroachdb/cockroachdb_test.go b/database/cockroachdb/cockroachdb_test.go index 157a6eb4a..d5aad962e 100644 --- a/database/cockroachdb/cockroachdb_test.go +++ b/database/cockroachdb/cockroachdb_test.go @@ -90,6 +90,22 @@ func Test(t *testing.T) { } dt.Test(t, d, []byte("SELECT 1")) }) + dktesting.ParallelTest(t, specs, func(t *testing.T, ci dktest.ContainerInfo) { + createDB(t, ci) + + ip, port, err := ci.Port(26257) + if err != nil { + t.Fatal(err) + } + + addr := fmt.Sprintf("cockroach://root@%v:%v/migrate?sslmode=disable", ip, port) + c := &CockroachDb{} + d, err := c.Open(addr) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, d, []byte("SELECT 1")) + }) } func TestMultiStatement(t *testing.T) { diff --git a/database/driver.go b/database/driver.go index fa914c5d0..d6940c872 100644 --- a/database/driver.go +++ b/database/driver.go @@ -44,8 +44,15 @@ type Driver interface { // Open returns a new driver instance configured with parameters // coming from the URL string. Migrate will call this function // only once per instance. + // This will also call Initialize(). Open(url string) (Driver, error) + // Initialize makes sure the database is ready for migrations, this + // might include creating some tables for migration/lock management + // or initializing some files. + // This assumes there is an open connection to a database. + Initialize() error + // Close closes the underlying database instance managed by the driver. // Migrate will call this function only once per instance. Close() error diff --git a/database/mongodb/mongodb.go b/database/mongodb/mongodb.go index 58e152e58..bd1ed45d4 100644 --- a/database/mongodb/mongodb.go +++ b/database/mongodb/mongodb.go @@ -51,17 +51,26 @@ func WithInstance(instance *mongo.Client, config *Config) (database.Driver, erro if len(config.DatabaseName) == 0 { return nil, ErrNoDatabaseName } - if len(config.MigrationsCollection) == 0 { - config.MigrationsCollection = DefaultMigrationsCollection - } mc := &Mongo{ client: instance, db: instance.Database(config.DatabaseName), config: config, } + + if err := mc.Initialize(); err != nil { + return nil, err + } + return mc, nil } +func (m *Mongo) Initialize() error { + if len(m.config.MigrationsCollection) == 0 { + m.config.MigrationsCollection = DefaultMigrationsCollection + } + return nil +} + func (m *Mongo) Open(dsn string) (database.Driver, error) { //connsting is experimental package, but it used for parse connection string in mongo.Connect function uri, err := connstring.Parse(dsn) @@ -77,9 +86,6 @@ func (m *Mongo) Open(dsn string) (database.Driver, error) { return nil, err } migrationsCollection := purl.Query().Get("x-migrations-collection") - if len(migrationsCollection) == 0 { - migrationsCollection = DefaultMigrationsCollection - } transactionMode, _ := strconv.ParseBool(purl.Query().Get("x-transaction-mode")) diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index 6acbde3b7..452fc1e0a 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -81,6 +81,35 @@ func Test(t *testing.T) { dt.TestSetVersion(t, d) dt.TestDrop(t, d) }) + dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { + ip, port, err := c.FirstPort() + if err != nil { + t.Fatal(err) + } + + addr := mongoConnectionString(ip, port) + p := &Mongo{} + d, err := p.Open(addr) + if err != nil { + t.Fatalf("%v", err) + } + defer d.Close() + dt.TestNilVersion(t, d) + //TestLockAndUnlock(t, d) driver doesn't support lock on database level + dt.TestRun(t, d, bytes.NewReader([]byte(`[{"insert":"hello","documents":[{"wild":"world"}]}]`))) + dt.TestSetVersion(t, d) + dt.TestDrop(t, d) + // Reinitialize for new round of tests + err = d.Drop() + if err != nil { + t.Fatalf("%v", err) + } + err = d.Initialize() + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, d, []byte(`[{"insert":"hello","documents":[{"wild":"world"}]}]`)) + }) } func TestWithAuth(t *testing.T) { diff --git a/database/mysql/mysql.go b/database/mysql/mysql.go index 6d6a1907b..be9aeb866 100644 --- a/database/mysql/mysql.go +++ b/database/mysql/mysql.go @@ -76,10 +76,6 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config.DatabaseName = databaseName.String - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } - conn, err := instance.Conn(context.Background()) if err != nil { return nil, err @@ -91,13 +87,21 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config: config, } - if err := mx.ensureVersionTable(); err != nil { + if err := mx.Initialize(); err != nil { return nil, err } return mx, nil } +func (m *Mysql) Initialize() error { + if len(m.config.MigrationsTable) == 0 { + m.config.MigrationsTable = DefaultMigrationsTable + } + + return m.ensureVersionTable() +} + // urlToMySQLConfig takes a net/url URL and returns a go-sql-driver/mysql Config. // Manually sets username and password to avoid net/url from url-encoding the reserved URL characters func urlToMySQLConfig(u nurl.URL) (*mysql.Config, error) { @@ -128,9 +132,6 @@ func (m *Mysql) Open(url string) (database.Driver, error) { purl.RawQuery = q.Encode() migrationsTable := purl.Query().Get("x-migrations-table") - if len(migrationsTable) == 0 { - migrationsTable = DefaultMigrationsTable - } // use custom TLS? ctls := purl.Query().Get("tls") diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index aa68a3754..d3fa38b1b 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -76,6 +76,16 @@ func Test(t *testing.T) { } defer d.Close() dt.Test(t, d, []byte("SELECT 1")) + // Reinitialize for new round of tests + err = d.Drop() + if err != nil { + t.Fatalf("%v", err) + } + err = d.Initialize() + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, d, []byte("SELECT 1")) // check ensureVersionTable if err := d.(*Mysql).ensureVersionTable(); err != nil { diff --git a/database/postgres/postgres.go b/database/postgres/postgres.go index f5a4d49e7..9614d0ede 100644 --- a/database/postgres/postgres.go +++ b/database/postgres/postgres.go @@ -98,7 +98,8 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config: config, } - if err := px.ensureVersionTable(); err != nil { + err = px.Initialize() + if err != nil { return nil, err } @@ -117,9 +118,6 @@ func (p *Postgres) Open(url string) (database.Driver, error) { } migrationsTable := purl.Query().Get("x-migrations-table") - if len(migrationsTable) == 0 { - migrationsTable = DefaultMigrationsTable - } px, err := WithInstance(db, &Config{ DatabaseName: purl.Path, @@ -132,6 +130,14 @@ func (p *Postgres) Open(url string) (database.Driver, error) { return px, nil } +func (p *Postgres) Initialize() error { + if len(p.config.MigrationsTable) == 0 { + p.config.MigrationsTable = DefaultMigrationsTable + } + + return p.ensureVersionTable() +} + func (p *Postgres) Close() error { connErr := p.conn.Close() dbErr := p.db.Close() diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index d9e489a39..4e21ffb52 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -75,6 +75,22 @@ func Test(t *testing.T) { defer d.Close() dt.Test(t, d, []byte("SELECT 1")) }) + + dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { + ip, port, err := c.FirstPort() + if err != nil { + t.Fatal(err) + } + + addr := pgConnectionString(ip, port) + p := &Postgres{} + d, err := p.Open(addr) + if err != nil { + t.Fatalf("%v", err) + } + defer d.Close() + dt.TestMigrate(t, d, []byte("SELECT 1")) + }) } func TestMultiStatement(t *testing.T) { diff --git a/database/ql/ql.go b/database/ql/ql.go index 97a38bb25..356142231 100644 --- a/database/ql/ql.go +++ b/database/ql/ql.go @@ -47,19 +47,22 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { if err := instance.Ping(); err != nil { return nil, err } - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } mx := &Ql{ db: instance, config: config, } - if err := mx.ensureVersionTable(); err != nil { + if err := mx.Initialize(); err != nil { return nil, err } return mx, nil } +func (m *Ql) Initialize() error { + if len(m.config.MigrationsTable) == 0 { + m.config.MigrationsTable = DefaultMigrationsTable + } + return m.ensureVersionTable() +} // ensureVersionTable checks if versions table exists and, if not, creates it. // Note that this function locks the database, which deviates from the usual // convention of "caller locks" in the Ql type. diff --git a/database/ql/ql_test.go b/database/ql/ql_test.go index 5a05e355e..14bb27795 100644 --- a/database/ql/ql_test.go +++ b/database/ql/ql_test.go @@ -40,6 +40,16 @@ func Test(t *testing.T) { } }() dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) + // Reinitialize for new round of tests + err = d.Drop() + if err != nil { + t.Fatalf("%v", err) + } + err = d.Initialize() + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) driver, err := WithInstance(db, &Config{}) if err != nil { t.Fatalf("%v", err) diff --git a/database/redshift/redshift.go b/database/redshift/redshift.go index 27bd8347f..2cb8e578f 100644 --- a/database/redshift/redshift.go +++ b/database/redshift/redshift.go @@ -65,10 +65,6 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config.DatabaseName = databaseName - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } - conn, err := instance.Conn(context.Background()) if err != nil { @@ -81,13 +77,21 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config: config, } - if err := px.ensureVersionTable(); err != nil { + if err := px.Initialize(); err != nil { return nil, err } return px, nil } +func (p *Redshift) Initialize() error { + if len(p.config.MigrationsTable) == 0 { + p.config.MigrationsTable = DefaultMigrationsTable + } + + return p.ensureVersionTable() +} + func (p *Redshift) Open(url string) (database.Driver, error) { purl, err := nurl.Parse(url) if err != nil { @@ -101,9 +105,6 @@ func (p *Redshift) Open(url string) (database.Driver, error) { } migrationsTable := purl.Query().Get("x-migrations-table") - if len(migrationsTable) == 0 { - migrationsTable = DefaultMigrationsTable - } px, err := WithInstance(db, &Config{ DatabaseName: purl.Path, diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go index 58c4ddd90..6946e7558 100644 --- a/database/redshift/redshift_test.go +++ b/database/redshift/redshift_test.go @@ -82,6 +82,21 @@ func Test(t *testing.T) { defer d.Close() dt.Test(t, d, []byte("SELECT 1")) }) + dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { + ip, port, err := c.FirstPort() + if err != nil { + t.Fatal(err) + } + + addr := redshiftConnectionString(ip, port) + p := &Redshift{} + d, err := p.Open(addr) + if err != nil { + t.Fatalf("%v", err) + } + defer d.Close() + dt.TestMigrate(t, d, []byte("SELECT 1")) + }) } func TestMultiStatement(t *testing.T) { diff --git a/database/spanner/spanner.go b/database/spanner/spanner.go index f5983433b..6942dfcc8 100644 --- a/database/spanner/spanner.go +++ b/database/spanner/spanner.go @@ -73,10 +73,6 @@ func WithInstance(instance *DB, config *Config) (database.Driver, error) { return nil, ErrNoDatabaseName } - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } - sx := &Spanner{ db: instance, config: config, @@ -89,6 +85,14 @@ func WithInstance(instance *DB, config *Config) (database.Driver, error) { return sx, nil } +func (s *Spanner) Initialize() error { + if len(s.config.MigrationsTable) == 0 { + s.config.MigrationsTable = DefaultMigrationsTable + } + + return s.ensureVersionTable() +} + // Open implements database.Driver func (s *Spanner) Open(url string) (database.Driver, error) { purl, err := nurl.Parse(url) @@ -109,9 +113,6 @@ func (s *Spanner) Open(url string) (database.Driver, error) { } migrationsTable := purl.Query().Get("x-migrations-table") - if len(migrationsTable) == 0 { - migrationsTable = DefaultMigrationsTable - } db := &DB{admin: adminClient, data: dataClient} return WithInstance(db, &Config{ diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index bd90d6530..e73c5118d 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -25,4 +25,14 @@ func Test(t *testing.T) { t.Fatalf("%v", err) } dt.Test(t, d, []byte("SELECT 1")) + // Reinitialize for new round of tests + err = d.Drop() + if err != nil { + t.Fatalf("%v", err) + } + err = d.Initialize() + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, d, []byte("SELECT 1")) } diff --git a/database/sqlite3/sqlite3.go b/database/sqlite3/sqlite3.go index 3f33e7e17..9b38fde0e 100644 --- a/database/sqlite3/sqlite3.go +++ b/database/sqlite3/sqlite3.go @@ -45,9 +45,6 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { if err := instance.Ping(); err != nil { return nil, err } - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } mx := &Sqlite{ db: instance, @@ -59,6 +56,14 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return mx, nil } +func (m *Sqlite) Initialize() error { + if len(m.config.MigrationsTable) == 0 { + m.config.MigrationsTable = DefaultMigrationsTable + } + + return m.ensureVersionTable() +} + // ensureVersionTable checks if versions table exists and, if not, creates it. // Note that this function locks the database, which deviates from the usual // convention of "caller locks" in the Sqlite type. diff --git a/database/sqlite3/sqlite3_test.go b/database/sqlite3/sqlite3_test.go index af2020c03..4bec7c4dd 100644 --- a/database/sqlite3/sqlite3_test.go +++ b/database/sqlite3/sqlite3_test.go @@ -29,6 +29,17 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } + dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) + // Reinitialize for new round of tests + err = d.Drop() + if err != nil { + t.Fatalf("%v", err) + } + err = d.Initialize() + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) db, err := sql.Open("sqlite3", filepath.Join(dir, "sqlite3.db")) if err != nil { @@ -39,7 +50,6 @@ func Test(t *testing.T) { return } }() - dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) driver, err := WithInstance(db, &Config{}) if err != nil { t.Fatalf("%v", err) diff --git a/database/stub/stub.go b/database/stub/stub.go index 4ad0193bd..866dec36a 100644 --- a/database/stub/stub.go +++ b/database/stub/stub.go @@ -24,6 +24,10 @@ type Stub struct { Config *Config } +func (s *Stub) Initialize() error { + return nil +} + func (s *Stub) Open(url string) (database.Driver, error) { return &Stub{ Url: url, diff --git a/database/stub/stub_test.go b/database/stub/stub_test.go index 2b966daa1..bd8b9eb1e 100644 --- a/database/stub/stub_test.go +++ b/database/stub/stub_test.go @@ -13,4 +13,5 @@ func Test(t *testing.T) { t.Fatal(err) } dt.Test(t, d, []byte("/* foobar migration */")) + dt.TestMigrate(t, d, []byte("/* foobar migration */")) } diff --git a/database/testing/migrate_testing.go b/database/testing/migrate_testing.go new file mode 100644 index 000000000..abca07f24 --- /dev/null +++ b/database/testing/migrate_testing.go @@ -0,0 +1,38 @@ +// Package testing has the database tests. +// All database drivers must pass the Test function. +// This lives in it's own package so it stays a test dependency. +package testing + +import ( + "fmt" + "testing" +) + +import ( + "github.com/golang-migrate/migrate/v4" + "github.com/golang-migrate/migrate/v4/database" + _ "github.com/golang-migrate/migrate/v4/source/stub" +) + +// TestMigrate runs integration-tests between the Migrate layer and database implementations. +// +func TestMigrate(t *testing.T, d database.Driver, migration []byte) { + if migration == nil { + panic("test must provide migration reader") + } + + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + if err != nil { + panic(fmt.Sprintf("failed to create migration, due to error: %v", err)) + } + 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) + } +} \ No newline at end of file diff --git a/database/testing/testing.go b/database/testing/testing.go index e45b186b3..16da8987c 100644 --- a/database/testing/testing.go +++ b/database/testing/testing.go @@ -23,7 +23,7 @@ func Test(t *testing.T, d database.Driver, migration []byte) { TestLockAndUnlock(t, d) TestRun(t, d, bytes.NewReader(migration)) TestSetVersion(t, d) // also tests Version() - TestDrop(t, d) + TestDrop(t, d) // also tests Initialize() } func TestNilVersion(t *testing.T, d database.Driver) { @@ -93,6 +93,13 @@ func TestDrop(t *testing.T, d database.Driver) { if err := d.Drop(); err != nil { t.Fatal(err) } + if err := d.Initialize(); err != nil { + t.Fatal(err) + } + // Verify that we are still able to perform operations on the driver. + if err := d.SetVersion(1, true); err != nil { + t.Fatal(err) + } } func TestSetVersion(t *testing.T, d database.Driver) { From b1a122ccc2ebd4645547351a35cabc1e03d8357f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Wed, 20 Feb 2019 07:54:16 +0100 Subject: [PATCH 06/21] Remove Initialize, document breaking behaviour of Drop --- database/driver.go | 9 ++------- database/mysql/mysql_test.go | 2 +- database/ql/ql_test.go | 2 +- database/spanner/spanner_test.go | 2 +- database/sqlite3/sqlite3_test.go | 3 ++- 5 files changed, 7 insertions(+), 11 deletions(-) diff --git a/database/driver.go b/database/driver.go index d6940c872..901e5dd66 100644 --- a/database/driver.go +++ b/database/driver.go @@ -44,15 +44,8 @@ type Driver interface { // Open returns a new driver instance configured with parameters // coming from the URL string. Migrate will call this function // only once per instance. - // This will also call Initialize(). Open(url string) (Driver, error) - // Initialize makes sure the database is ready for migrations, this - // might include creating some tables for migration/lock management - // or initializing some files. - // This assumes there is an open connection to a database. - Initialize() error - // Close closes the underlying database instance managed by the driver. // Migrate will call this function only once per instance. Close() error @@ -81,6 +74,8 @@ type Driver interface { Version() (version int, dirty bool, err error) // Drop deletes everything in the database. + // Note that this is a breaking action, a new call to Open() is necessary to + // ensure subsequent calls work as expected. Drop() error } diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index d3fa38b1b..bce01c96e 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -81,7 +81,7 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - err = d.Initialize() + d, err = p.Open(addr) if err != nil { t.Fatalf("%v", err) } diff --git a/database/ql/ql_test.go b/database/ql/ql_test.go index 14bb27795..268230482 100644 --- a/database/ql/ql_test.go +++ b/database/ql/ql_test.go @@ -45,7 +45,7 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - err = d.Initialize() + d, err = p.Open(addr) if err != nil { t.Fatalf("%v", err) } diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index e73c5118d..3cf68d509 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -30,7 +30,7 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - err = d.Initialize() + d, err = s.Open(addr) if err != nil { t.Fatalf("%v", err) } diff --git a/database/sqlite3/sqlite3_test.go b/database/sqlite3/sqlite3_test.go index 4bec7c4dd..15a36d706 100644 --- a/database/sqlite3/sqlite3_test.go +++ b/database/sqlite3/sqlite3_test.go @@ -30,12 +30,13 @@ func Test(t *testing.T) { t.Fatalf("%v", err) } dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) + // Reinitialize for new round of tests err = d.Drop() if err != nil { t.Fatalf("%v", err) } - err = d.Initialize() + d, err = p.Open(addr) if err != nil { t.Fatalf("%v", err) } From 65e59b333ba734c093c007b10755c007e7e88aa6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Wed, 20 Feb 2019 08:02:43 +0100 Subject: [PATCH 07/21] Revert introduction of Initialize method --- database/cassandra/cassandra.go | 14 +++++-------- database/clickhouse/clickhouse.go | 6 +++--- database/cockroachdb/cockroachdb.go | 32 +++++++++++------------------ database/mongodb/mongodb.go | 14 +++---------- database/mysql/mysql.go | 14 +++++-------- database/postgres/postgres.go | 15 ++++++-------- database/ql/ql.go | 12 +++++------ database/redshift/redshift.go | 14 +++++-------- database/spanner/spanner.go | 12 ++++------- database/sqlite3/sqlite3.go | 12 ++++------- database/testing/testing.go | 3 ++- 11 files changed, 54 insertions(+), 94 deletions(-) diff --git a/database/cassandra/cassandra.go b/database/cassandra/cassandra.go index f0e5ec89d..87abd2e66 100644 --- a/database/cassandra/cassandra.go +++ b/database/cassandra/cassandra.go @@ -54,26 +54,22 @@ func WithInstance(session *gocql.Session, config *Config) (database.Driver, erro return nil, ErrClosedSession } + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + c := &Cassandra{ session: session, config: config, } - if err := c.Initialize(); err != nil { + if err := c.ensureVersionTable(); err != nil { return nil, err } return c, nil } -func (c *Cassandra) Initialize() error { - if len(c.config.MigrationsTable) == 0 { - c.config.MigrationsTable = DefaultMigrationsTable - } - - return c.ensureVersionTable() -} - func (c *Cassandra) Open(url string) (database.Driver, error) { u, err := nurl.Parse(url) if err != nil { diff --git a/database/clickhouse/clickhouse.go b/database/clickhouse/clickhouse.go index e55a92844..ebf5b17d6 100644 --- a/database/clickhouse/clickhouse.go +++ b/database/clickhouse/clickhouse.go @@ -42,7 +42,7 @@ func WithInstance(conn *sql.DB, config *Config) (database.Driver, error) { config: config, } - if err := ch.Initialize(); err != nil { + if err := ch.init(); err != nil { return nil, err } @@ -75,14 +75,14 @@ func (ch *ClickHouse) Open(dsn string) (database.Driver, error) { }, } - if err := ch.Initialize(); err != nil { + if err := ch.init(); err != nil { return nil, err } return ch, nil } -func (ch *ClickHouse) Initialize() error { +func (ch *ClickHouse) init() error { if len(ch.config.DatabaseName) == 0 { if err := ch.conn.QueryRow("SELECT currentDatabase()").Scan(&ch.config.DatabaseName); err != nil { return err diff --git a/database/cockroachdb/cockroachdb.go b/database/cockroachdb/cockroachdb.go index 0c0d94ed4..c18edcd7a 100644 --- a/database/cockroachdb/cockroachdb.go +++ b/database/cockroachdb/cockroachdb.go @@ -73,37 +73,29 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config.DatabaseName = databaseName - px := &CockroachDb{ - db: instance, - config: config, + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable } - if err := px.Initialize(); err != nil { - return nil, err - } - - return px, nil -} - -func (c *CockroachDb) Initialize() error { - if len(c.config.MigrationsTable) == 0 { - c.config.MigrationsTable = DefaultMigrationsTable + if len(config.LockTable) == 0 { + config.LockTable = DefaultLockTable } - if len(c.config.LockTable) == 0 { - c.config.LockTable = DefaultLockTable + px := &CockroachDb{ + db: instance, + config: config, } // ensureVersionTable is a locking operation, so we need to ensureLockTable before we ensureVersionTable. - if err := c.ensureLockTable(); err != nil { - return err + if err := px.ensureLockTable(); err != nil { + return nil, err } - if err := c.ensureVersionTable(); err != nil { - return err + if err := px.ensureVersionTable(); err != nil { + return nil, err } - return nil + return px, nil } func (c *CockroachDb) Open(url string) (database.Driver, error) { diff --git a/database/mongodb/mongodb.go b/database/mongodb/mongodb.go index bd1ed45d4..d6986ee23 100644 --- a/database/mongodb/mongodb.go +++ b/database/mongodb/mongodb.go @@ -51,26 +51,18 @@ func WithInstance(instance *mongo.Client, config *Config) (database.Driver, erro if len(config.DatabaseName) == 0 { return nil, ErrNoDatabaseName } + if len(config.MigrationsCollection) == 0 { + config.MigrationsCollection = DefaultMigrationsCollection + } mc := &Mongo{ client: instance, db: instance.Database(config.DatabaseName), config: config, } - if err := mc.Initialize(); err != nil { - return nil, err - } - return mc, nil } -func (m *Mongo) Initialize() error { - if len(m.config.MigrationsCollection) == 0 { - m.config.MigrationsCollection = DefaultMigrationsCollection - } - return nil -} - func (m *Mongo) Open(dsn string) (database.Driver, error) { //connsting is experimental package, but it used for parse connection string in mongo.Connect function uri, err := connstring.Parse(dsn) diff --git a/database/mysql/mysql.go b/database/mysql/mysql.go index be9aeb866..da8ed54bc 100644 --- a/database/mysql/mysql.go +++ b/database/mysql/mysql.go @@ -81,27 +81,23 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return nil, err } + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + mx := &Mysql{ conn: conn, db: instance, config: config, } - if err := mx.Initialize(); err != nil { + if err := mx.ensureVersionTable(); err != nil { return nil, err } return mx, nil } -func (m *Mysql) Initialize() error { - if len(m.config.MigrationsTable) == 0 { - m.config.MigrationsTable = DefaultMigrationsTable - } - - return m.ensureVersionTable() -} - // urlToMySQLConfig takes a net/url URL and returns a go-sql-driver/mysql Config. // Manually sets username and password to avoid net/url from url-encoding the reserved URL characters func urlToMySQLConfig(u nurl.URL) (*mysql.Config, error) { diff --git a/database/postgres/postgres.go b/database/postgres/postgres.go index 9614d0ede..a9b2dd23e 100644 --- a/database/postgres/postgres.go +++ b/database/postgres/postgres.go @@ -92,13 +92,17 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return nil, err } + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + px := &Postgres{ conn: conn, db: instance, config: config, } - err = px.Initialize() + err = px.ensureVersionTable() if err != nil { return nil, err } @@ -123,6 +127,7 @@ func (p *Postgres) Open(url string) (database.Driver, error) { DatabaseName: purl.Path, MigrationsTable: migrationsTable, }) + if err != nil { return nil, err } @@ -130,14 +135,6 @@ func (p *Postgres) Open(url string) (database.Driver, error) { return px, nil } -func (p *Postgres) Initialize() error { - if len(p.config.MigrationsTable) == 0 { - p.config.MigrationsTable = DefaultMigrationsTable - } - - return p.ensureVersionTable() -} - func (p *Postgres) Close() error { connErr := p.conn.Close() dbErr := p.db.Close() diff --git a/database/ql/ql.go b/database/ql/ql.go index 356142231..6dfd202a1 100644 --- a/database/ql/ql.go +++ b/database/ql/ql.go @@ -48,21 +48,19 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return nil, err } + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + mx := &Ql{ db: instance, config: config, } - if err := mx.Initialize(); err != nil { + if err := mx.ensureVersionTable(); err != nil { return nil, err } return mx, nil } -func (m *Ql) Initialize() error { - if len(m.config.MigrationsTable) == 0 { - m.config.MigrationsTable = DefaultMigrationsTable - } - return m.ensureVersionTable() -} // ensureVersionTable checks if versions table exists and, if not, creates it. // Note that this function locks the database, which deviates from the usual // convention of "caller locks" in the Ql type. diff --git a/database/redshift/redshift.go b/database/redshift/redshift.go index 2cb8e578f..eb834cb4b 100644 --- a/database/redshift/redshift.go +++ b/database/redshift/redshift.go @@ -71,27 +71,23 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return nil, err } + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + px := &Redshift{ conn: conn, db: instance, config: config, } - if err := px.Initialize(); err != nil { + if err := px.ensureVersionTable(); err != nil { return nil, err } return px, nil } -func (p *Redshift) Initialize() error { - if len(p.config.MigrationsTable) == 0 { - p.config.MigrationsTable = DefaultMigrationsTable - } - - return p.ensureVersionTable() -} - func (p *Redshift) Open(url string) (database.Driver, error) { purl, err := nurl.Parse(url) if err != nil { diff --git a/database/spanner/spanner.go b/database/spanner/spanner.go index 6942dfcc8..7b5a42b8d 100644 --- a/database/spanner/spanner.go +++ b/database/spanner/spanner.go @@ -73,6 +73,10 @@ func WithInstance(instance *DB, config *Config) (database.Driver, error) { return nil, ErrNoDatabaseName } + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + sx := &Spanner{ db: instance, config: config, @@ -85,14 +89,6 @@ func WithInstance(instance *DB, config *Config) (database.Driver, error) { return sx, nil } -func (s *Spanner) Initialize() error { - if len(s.config.MigrationsTable) == 0 { - s.config.MigrationsTable = DefaultMigrationsTable - } - - return s.ensureVersionTable() -} - // Open implements database.Driver func (s *Spanner) Open(url string) (database.Driver, error) { purl, err := nurl.Parse(url) diff --git a/database/sqlite3/sqlite3.go b/database/sqlite3/sqlite3.go index 9b38fde0e..4826448a5 100644 --- a/database/sqlite3/sqlite3.go +++ b/database/sqlite3/sqlite3.go @@ -46,6 +46,10 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return nil, err } + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + mx := &Sqlite{ db: instance, config: config, @@ -56,14 +60,6 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return mx, nil } -func (m *Sqlite) Initialize() error { - if len(m.config.MigrationsTable) == 0 { - m.config.MigrationsTable = DefaultMigrationsTable - } - - return m.ensureVersionTable() -} - // ensureVersionTable checks if versions table exists and, if not, creates it. // Note that this function locks the database, which deviates from the usual // convention of "caller locks" in the Sqlite type. diff --git a/database/testing/testing.go b/database/testing/testing.go index 16da8987c..b7c610f1e 100644 --- a/database/testing/testing.go +++ b/database/testing/testing.go @@ -23,7 +23,8 @@ func Test(t *testing.T, d database.Driver, migration []byte) { TestLockAndUnlock(t, d) TestRun(t, d, bytes.NewReader(migration)) TestSetVersion(t, d) // also tests Version() - TestDrop(t, d) // also tests Initialize() + // Drop breaks the driver, so test it last. + TestDrop(t, d) } func TestNilVersion(t *testing.T, d database.Driver) { From 4f62649a9d6bb86b131784db73d1a55a2c19efe0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Wed, 20 Feb 2019 08:09:00 +0100 Subject: [PATCH 08/21] Removed Initialize in Stub as well --- database/stub/stub.go | 4 ---- 1 file changed, 4 deletions(-) diff --git a/database/stub/stub.go b/database/stub/stub.go index 866dec36a..4ad0193bd 100644 --- a/database/stub/stub.go +++ b/database/stub/stub.go @@ -24,10 +24,6 @@ type Stub struct { Config *Config } -func (s *Stub) Initialize() error { - return nil -} - func (s *Stub) Open(url string) (database.Driver, error) { return &Stub{ Url: url, From dc96daa997de4a244907e33161f8748f612dd265 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Wed, 20 Feb 2019 08:16:15 +0100 Subject: [PATCH 09/21] Remove call to non-existent Initialize and make sure to close re-initialized database connections --- database/mongodb/mongodb_test.go | 3 ++- database/mysql/mysql_test.go | 1 + database/ql/ql_test.go | 1 + database/spanner/spanner_test.go | 1 + database/sqlite3/sqlite3_test.go | 1 + 5 files changed, 6 insertions(+), 1 deletion(-) diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index 452fc1e0a..cafda1acc 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -104,10 +104,11 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - err = d.Initialize() + d, err = p.Open(addr) if err != nil { t.Fatalf("%v", err) } + defer d.Close() dt.TestMigrate(t, d, []byte(`[{"insert":"hello","documents":[{"wild":"world"}]}]`)) }) } diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index bce01c96e..57409c95b 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -85,6 +85,7 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } + defer d.Close() dt.TestMigrate(t, d, []byte("SELECT 1")) // check ensureVersionTable diff --git a/database/ql/ql_test.go b/database/ql/ql_test.go index 268230482..f8232a424 100644 --- a/database/ql/ql_test.go +++ b/database/ql/ql_test.go @@ -49,6 +49,7 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } + defer d.Close() dt.TestMigrate(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) driver, err := WithInstance(db, &Config{}) if err != nil { diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index 3cf68d509..0b2ed63a2 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -34,5 +34,6 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } + defer d.Close() dt.TestMigrate(t, d, []byte("SELECT 1")) } diff --git a/database/sqlite3/sqlite3_test.go b/database/sqlite3/sqlite3_test.go index 15a36d706..4cbe2813b 100644 --- a/database/sqlite3/sqlite3_test.go +++ b/database/sqlite3/sqlite3_test.go @@ -40,6 +40,7 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } + defer d.Close() dt.TestMigrate(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) db, err := sql.Open("sqlite3", filepath.Join(dir, "sqlite3.db")) From d8df31cd46ed0c98ce190f003b586417c27582ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Wed, 20 Feb 2019 08:20:58 +0100 Subject: [PATCH 10/21] Revert changes to TestDrop in database/testing --- database/testing/testing.go | 7 ------- 1 file changed, 7 deletions(-) diff --git a/database/testing/testing.go b/database/testing/testing.go index b7c610f1e..b227c6088 100644 --- a/database/testing/testing.go +++ b/database/testing/testing.go @@ -94,13 +94,6 @@ func TestDrop(t *testing.T, d database.Driver) { if err := d.Drop(); err != nil { t.Fatal(err) } - if err := d.Initialize(); err != nil { - t.Fatal(err) - } - // Verify that we are still able to perform operations on the driver. - if err := d.SetVersion(1, true); err != nil { - t.Fatal(err) - } } func TestSetVersion(t *testing.T, d database.Driver) { From 7e74b8ec2a0d67b087d47b97e9c060714a523d5a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 09:21:15 +0100 Subject: [PATCH 11/21] Split Test and TestMigrate into different test entrypoints --- database/cassandra/cassandra_test.go | 23 +++++++++++ database/cockroachdb/cockroachdb_test.go | 11 ++++- database/mongodb/mongodb_test.go | 19 +++------ database/mysql/mysql_test.go | 34 +++++++++++++--- database/postgres/postgres_test.go | 52 ++++-------------------- database/ql/ql_test.go | 34 +++++++++------- database/redshift/redshift_test.go | 10 ++++- database/spanner/spanner_test.go | 23 ++++++++--- database/sqlite3/sqlite3_test.go | 23 ++++++----- database/stub/stub_test.go | 16 +++++++- database/testing/migrate_testing.go | 10 ++++- 11 files changed, 158 insertions(+), 97 deletions(-) diff --git a/database/cassandra/cassandra_test.go b/database/cassandra/cassandra_test.go index 3e60c489c..3d64e81c0 100644 --- a/database/cassandra/cassandra_test.go +++ b/database/cassandra/cassandra_test.go @@ -3,6 +3,7 @@ package cassandra import ( "context" "fmt" + "github.com/golang-migrate/migrate/v4" "strconv" "testing" ) @@ -72,3 +73,25 @@ func Test(t *testing.T) { dt.Test(t, d, []byte("SELECT table_name from system_schema.tables")) }) } + +func TestMigrate(t *testing.T) { + dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { + ip, port, err := c.Port(9042) + if err != nil { + t.Fatal("Unable to get mapped port:", err) + } + addr := fmt.Sprintf("cassandra://%v:%v/testks", ip, port) + p := &Cassandra{} + d, err := p.Open(addr) + if err != nil { + t.Fatalf("%v", err) + } + defer d.Close() + + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, m, []byte("SELECT table_name from system_schema.tables")) + }) +} diff --git a/database/cockroachdb/cockroachdb_test.go b/database/cockroachdb/cockroachdb_test.go index d5aad962e..f1d093749 100644 --- a/database/cockroachdb/cockroachdb_test.go +++ b/database/cockroachdb/cockroachdb_test.go @@ -6,6 +6,7 @@ import ( "context" "database/sql" "fmt" + "github.com/golang-migrate/migrate/v4" "strings" "testing" ) @@ -90,6 +91,9 @@ func Test(t *testing.T) { } dt.Test(t, d, []byte("SELECT 1")) }) +} + +func TestMigrate(t *testing.T) { dktesting.ParallelTest(t, specs, func(t *testing.T, ci dktest.ContainerInfo) { createDB(t, ci) @@ -104,7 +108,12 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - dt.TestMigrate(t, d, []byte("SELECT 1")) + + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, m, []byte("SELECT 1")) }) } diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index cafda1acc..78af27c86 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -4,6 +4,7 @@ import ( "bytes" "context" "fmt" + "github.com/golang-migrate/migrate/v4" "io" "os" "strconv" @@ -81,6 +82,9 @@ func Test(t *testing.T) { dt.TestSetVersion(t, d) dt.TestDrop(t, d) }) +} + +func TestMigrate(t *testing.T) { dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { ip, port, err := c.FirstPort() if err != nil { @@ -94,22 +98,11 @@ func Test(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - dt.TestNilVersion(t, d) - //TestLockAndUnlock(t, d) driver doesn't support lock on database level - dt.TestRun(t, d, bytes.NewReader([]byte(`[{"insert":"hello","documents":[{"wild":"world"}]}]`))) - dt.TestSetVersion(t, d) - dt.TestDrop(t, d) - // Reinitialize for new round of tests - err = d.Drop() + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) if err != nil { t.Fatalf("%v", err) } - d, err = p.Open(addr) - if err != nil { - t.Fatalf("%v", err) - } - defer d.Close() - dt.TestMigrate(t, d, []byte(`[{"insert":"hello","documents":[{"wild":"world"}]}]`)) + dt.TestMigrate(t, m, []byte(`[{"insert":"hello","documents":[{"wild":"world"}]}]`)) }) } diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index 57409c95b..5e3310054 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -5,6 +5,7 @@ import ( "database/sql" sqldriver "database/sql/driver" "fmt" + "github.com/golang-migrate/migrate/v4" "net/url" "testing" ) @@ -76,17 +77,40 @@ func Test(t *testing.T) { } defer d.Close() dt.Test(t, d, []byte("SELECT 1")) - // Reinitialize for new round of tests - err = d.Drop() + + // check ensureVersionTable + if err := d.(*Mysql).ensureVersionTable(); err != nil { + t.Fatal(err) + } + // check again + if err := d.(*Mysql).ensureVersionTable(); err != nil { + t.Fatal(err) + } + }) +} + +func TestMigrate(t *testing.T) { + // mysql.SetLogger(mysql.Logger(log.New(ioutil.Discard, "", log.Ltime))) + + dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { + ip, port, err := c.Port(defaultPort) if err != nil { - t.Fatalf("%v", err) + t.Fatal(err) } - d, err = p.Open(addr) + + addr := fmt.Sprintf("mysql://root:root@tcp(%v:%v)/public", ip, port) + p := &Mysql{} + d, err := p.Open(addr) if err != nil { t.Fatalf("%v", err) } defer d.Close() - dt.TestMigrate(t, d, []byte("SELECT 1")) + + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, m, []byte("SELECT 1")) // check ensureVersionTable if err := d.(*Mysql).ensureVersionTable(); err != nil { diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index 4e21ffb52..166a17cf9 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -7,6 +7,7 @@ import ( "database/sql" sqldriver "database/sql/driver" "fmt" + "github.com/golang-migrate/migrate/v4" "io" "strconv" "strings" @@ -75,7 +76,9 @@ func Test(t *testing.T) { defer d.Close() dt.Test(t, d, []byte("SELECT 1")) }) +} +func TestMigrate(t *testing.T) { dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { ip, port, err := c.FirstPort() if err != nil { @@ -89,7 +92,11 @@ func Test(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - dt.TestMigrate(t, d, []byte("SELECT 1")) + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, m, []byte("SELECT 1")) }) } @@ -323,49 +330,6 @@ func TestPostgres_Lock(t *testing.T) { }) } -func TestDrop(t *testing.T) { - dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { - ip, port, err := c.FirstPort() - if err != nil { - t.Fatal(err) - } - - addr := pgConnectionString(ip, port) - p := &Postgres{} - d, err := p.Open(addr) - if err != nil { - t.Fatalf("%v", err) - } - defer d.Close() - if err := d.Run(strings.NewReader("CREATE TABLE foo (foo text);")); err != nil { - t.Fatalf("expected err to be nil, got %v", err) - } - - // drop the table - if err := d.Drop(); err != nil { - t.Fatalf("expected err to be nil, got %v", err) - } - - // make sure table does not exist - var exists bool - if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'foo' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil { - t.Fatal(err) - } - if exists { - t.Fatalf("expected table foo to not exist") - } - - // make sure version table is dropped as well - version, _, err := d.Version() - if err != nil { - t.Fatal(err) - } - if version != -1 { - t.Fatal("expected NilVersion") - } - }) -} - func TestWithInstance_Concurrent(t *testing.T) { dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { ip, port, err := c.FirstPort() diff --git a/database/ql/ql_test.go b/database/ql/ql_test.go index f8232a424..7b875b09f 100644 --- a/database/ql/ql_test.go +++ b/database/ql/ql_test.go @@ -40,24 +40,32 @@ func Test(t *testing.T) { } }() dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) - // Reinitialize for new round of tests - err = d.Drop() +} + +func TestMigrate(t *testing.T) { + dir, err := ioutil.TempDir("", "ql-driver-test") if err != nil { - t.Fatalf("%v", err) + return } - d, err = p.Open(addr) + defer func() { + os.RemoveAll(dir) + }() + fmt.Printf("DB path : %s\n", filepath.Join(dir, "ql.db")) + + db, err := sql.Open("ql", filepath.Join(dir, "ql.db")) if err != nil { - t.Fatalf("%v", err) + return } - defer d.Close() - dt.TestMigrate(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) + defer func() { + if err := db.Close(); err != nil { + return + } + }() + driver, err := WithInstance(db, &Config{}) if err != nil { t.Fatalf("%v", err) } - if err := d.Drop(); err != nil { - t.Fatal(err) - } m, err := migrate.NewWithDatabaseInstance( "file://./migration", @@ -65,9 +73,5 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - fmt.Println("UP") - err = m.Up() - if err != nil { - t.Fatalf("%v", err) - } + dt.TestMigrate(t, m, []byte("CREATE TABLE t (Qty int, Name string);")) } diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go index 6946e7558..409122e22 100644 --- a/database/redshift/redshift_test.go +++ b/database/redshift/redshift_test.go @@ -8,6 +8,7 @@ import ( "database/sql" sqldriver "database/sql/driver" "fmt" + "github.com/golang-migrate/migrate/v4" "io" "strconv" "strings" @@ -82,6 +83,9 @@ func Test(t *testing.T) { defer d.Close() dt.Test(t, d, []byte("SELECT 1")) }) +} + +func TestMigrate(t *testing.T) { dktesting.ParallelTest(t, specs, func(t *testing.T, c dktest.ContainerInfo) { ip, port, err := c.FirstPort() if err != nil { @@ -95,7 +99,11 @@ func Test(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - dt.TestMigrate(t, d, []byte("SELECT 1")) + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, m, []byte("SELECT 1")) }) } diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index 0b2ed63a2..545b9e2f0 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -2,6 +2,7 @@ package spanner import ( "fmt" + "github.com/golang-migrate/migrate/v4" "os" "testing" @@ -25,15 +26,27 @@ func Test(t *testing.T) { t.Fatalf("%v", err) } dt.Test(t, d, []byte("SELECT 1")) - // Reinitialize for new round of tests - err = d.Drop() +} + +func TestMigrate(t *testing.T) { + if testing.Short() { + t.Skip("skipping test in short mode.") + } + + db, ok := os.LookupEnv("SPANNER_DATABASE") + if !ok { + t.Skip("SPANNER_DATABASE not set, skipping test.") + } + + s := &Spanner{} + addr := fmt.Sprintf("spanner://%v", db) + d, err := s.Open(addr) if err != nil { t.Fatalf("%v", err) } - d, err = s.Open(addr) + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) if err != nil { t.Fatalf("%v", err) } - defer d.Close() - dt.TestMigrate(t, d, []byte("SELECT 1")) + dt.TestMigrate(t, m, []byte("SELECT 1")) } diff --git a/database/sqlite3/sqlite3_test.go b/database/sqlite3/sqlite3_test.go index 4cbe2813b..2ccb33d1e 100644 --- a/database/sqlite3/sqlite3_test.go +++ b/database/sqlite3/sqlite3_test.go @@ -30,18 +30,23 @@ func Test(t *testing.T) { t.Fatalf("%v", err) } dt.Test(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) +} - // Reinitialize for new round of tests - err = d.Drop() +func TestMigrate(t *testing.T) { + dir, err := ioutil.TempDir("", "sqlite3-driver-test") if err != nil { - t.Fatalf("%v", err) + return } - d, err = p.Open(addr) + defer func() { + os.RemoveAll(dir) + }() + t.Logf("DB path : %s\n", filepath.Join(dir, "sqlite3.db")) + p := &Sqlite{} + addr := fmt.Sprintf("sqlite3://%s", filepath.Join(dir, "sqlite3.db")) + d, err := p.Open(addr) if err != nil { t.Fatalf("%v", err) } - defer d.Close() - dt.TestMigrate(t, d, []byte("CREATE TABLE t (Qty int, Name string);")) db, err := sql.Open("sqlite3", filepath.Join(dir, "sqlite3.db")) if err != nil { @@ -66,11 +71,7 @@ func Test(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - t.Log("UP") - err = m.Up() - if err != nil { - t.Fatalf("%v", err) - } + dt.TestMigrate(t, m, []byte("CREATE TABLE t (Qty int, Name string);")) } func TestMigrationTable(t *testing.T) { diff --git a/database/stub/stub_test.go b/database/stub/stub_test.go index bd8b9eb1e..6d2390a81 100644 --- a/database/stub/stub_test.go +++ b/database/stub/stub_test.go @@ -1,6 +1,7 @@ package stub import ( + "github.com/golang-migrate/migrate/v4" "testing" dt "github.com/golang-migrate/migrate/v4/database/testing" @@ -13,5 +14,18 @@ func Test(t *testing.T) { t.Fatal(err) } dt.Test(t, d, []byte("/* foobar migration */")) - dt.TestMigrate(t, d, []byte("/* foobar migration */")) +} + +func TestMigrate(t *testing.T) { + s := &Stub{} + d, err := s.Open("") + if err != nil { + t.Fatal(err) + } + + m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, m, []byte("/* foobar migration */")) } diff --git a/database/testing/migrate_testing.go b/database/testing/migrate_testing.go index abca07f24..0e4c695ac 100644 --- a/database/testing/migrate_testing.go +++ b/database/testing/migrate_testing.go @@ -16,7 +16,7 @@ import ( // TestMigrate runs integration-tests between the Migrate layer and database implementations. // -func TestMigrate(t *testing.T, d database.Driver, migration []byte) { +func TestMigrate(t *testing.T, m *migrate.Migrate, migration []byte) { if migration == nil { panic("test must provide migration reader") } @@ -25,6 +25,7 @@ func TestMigrate(t *testing.T, d database.Driver, migration []byte) { if err != nil { panic(fmt.Sprintf("failed to create migration, due to error: %v", err)) } + TestMigrateUp(t, m) TestMigrateDrop(t, m) } @@ -35,4 +36,11 @@ 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) { + t.Log("UP") + if err := m.Up(); err != nil { + t.Fatalf("%v", err) + } } \ No newline at end of file From 9aaa8757130cce9bac6d14fba62036c5faa897c7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 09:26:15 +0100 Subject: [PATCH 12/21] Remove unused import in migrate_testing --- database/testing/migrate_testing.go | 1 - 1 file changed, 1 deletion(-) diff --git a/database/testing/migrate_testing.go b/database/testing/migrate_testing.go index 0e4c695ac..436aaceba 100644 --- a/database/testing/migrate_testing.go +++ b/database/testing/migrate_testing.go @@ -10,7 +10,6 @@ import ( import ( "github.com/golang-migrate/migrate/v4" - "github.com/golang-migrate/migrate/v4/database" _ "github.com/golang-migrate/migrate/v4/source/stub" ) From 5d8e5e92f778304fbfa2c5fa767244bfd7ac99e2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 09:30:16 +0100 Subject: [PATCH 13/21] Remove erroneous code to fix tests --- database/testing/migrate_testing.go | 5 ----- 1 file changed, 5 deletions(-) diff --git a/database/testing/migrate_testing.go b/database/testing/migrate_testing.go index 436aaceba..1d5d5f597 100644 --- a/database/testing/migrate_testing.go +++ b/database/testing/migrate_testing.go @@ -4,7 +4,6 @@ package testing import ( - "fmt" "testing" ) @@ -20,10 +19,6 @@ func TestMigrate(t *testing.T, m *migrate.Migrate, migration []byte) { panic("test must provide migration reader") } - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) - if err != nil { - panic(fmt.Sprintf("failed to create migration, due to error: %v", err)) - } TestMigrateUp(t, m) TestMigrateDrop(t, m) } From 499415a66985f496e6269ef4eb5db7d653a410b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 09:42:59 +0100 Subject: [PATCH 14/21] Add stub source imports to database tests --- database/cassandra/cassandra_test.go | 1 + database/cockroachdb/cockroachdb_test.go | 1 + database/mongodb/mongodb_test.go | 1 + database/mysql/mysql_test.go | 1 + database/postgres/postgres_test.go | 1 + database/redshift/redshift_test.go | 1 + database/spanner/spanner_test.go | 1 + database/stub/stub_test.go | 1 + database/testing/migrate_testing.go | 1 - 9 files changed, 8 insertions(+), 1 deletion(-) diff --git a/database/cassandra/cassandra_test.go b/database/cassandra/cassandra_test.go index 3d64e81c0..efcb32890 100644 --- a/database/cassandra/cassandra_test.go +++ b/database/cassandra/cassandra_test.go @@ -16,6 +16,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) var ( diff --git a/database/cockroachdb/cockroachdb_test.go b/database/cockroachdb/cockroachdb_test.go index f1d093749..0d76e2324 100644 --- a/database/cockroachdb/cockroachdb_test.go +++ b/database/cockroachdb/cockroachdb_test.go @@ -19,6 +19,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) const defaultPort = 26257 diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index 78af27c86..54bd1d4bd 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -21,6 +21,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) var ( diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index 5e3310054..47bdc3492 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -18,6 +18,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) const defaultPort = 3306 diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index 166a17cf9..f43fbb455 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -18,6 +18,7 @@ import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) var ( diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go index 409122e22..49c6a64bc 100644 --- a/database/redshift/redshift_test.go +++ b/database/redshift/redshift_test.go @@ -22,6 +22,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) var ( diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index 545b9e2f0..122465094 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -7,6 +7,7 @@ import ( "testing" dt "github.com/golang-migrate/migrate/v4/database/testing" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) func Test(t *testing.T) { diff --git a/database/stub/stub_test.go b/database/stub/stub_test.go index 6d2390a81..f0be9c910 100644 --- a/database/stub/stub_test.go +++ b/database/stub/stub_test.go @@ -5,6 +5,7 @@ import ( "testing" dt "github.com/golang-migrate/migrate/v4/database/testing" + _ "github.com/golang-migrate/migrate/v4/source/stub" ) func Test(t *testing.T) { diff --git a/database/testing/migrate_testing.go b/database/testing/migrate_testing.go index 1d5d5f597..5b328a715 100644 --- a/database/testing/migrate_testing.go +++ b/database/testing/migrate_testing.go @@ -9,7 +9,6 @@ import ( import ( "github.com/golang-migrate/migrate/v4" - _ "github.com/golang-migrate/migrate/v4/source/stub" ) // TestMigrate runs integration-tests between the Migrate layer and database implementations. From 2b491b94ca0779c17e6265cb27afeb950b4b8468 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 10:15:23 +0100 Subject: [PATCH 15/21] Add Stub source to migrate tests --- database/cassandra/cassandra_test.go | 6 +++++- database/cockroachdb/cockroachdb_test.go | 6 +++++- database/mongodb/mongodb_test.go | 6 +++++- database/mysql/mysql_test.go | 6 +++++- database/postgres/postgres_test.go | 6 +++++- database/redshift/redshift_test.go | 6 +++++- database/spanner/spanner_test.go | 6 +++++- database/stub/stub_test.go | 7 ++++++- database/testing/migrate_testing.go | 19 +++++++++++++++++++ 9 files changed, 60 insertions(+), 8 deletions(-) diff --git a/database/cassandra/cassandra_test.go b/database/cassandra/cassandra_test.go index efcb32890..9843ca83a 100644 --- a/database/cassandra/cassandra_test.go +++ b/database/cassandra/cassandra_test.go @@ -89,7 +89,11 @@ func TestMigrate(t *testing.T) { } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() + if err != nil { + t.Fatalf("%v", err) + } + m, err := migrate.NewWithInstance("stub", src, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/cockroachdb/cockroachdb_test.go b/database/cockroachdb/cockroachdb_test.go index 0d76e2324..e2adf253a 100644 --- a/database/cockroachdb/cockroachdb_test.go +++ b/database/cockroachdb/cockroachdb_test.go @@ -110,7 +110,11 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() + if err != nil { + t.Fatalf("%v", err) + } + m, err := migrate.NewWithInstance("stub", src, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index 54bd1d4bd..0451553e7 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -99,7 +99,11 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() + if err != nil { + t.Fatalf("%v", err) + } + m, err := migrate.NewWithInstance("stub", src, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index 47bdc3492..b89efbb75 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -107,7 +107,11 @@ func TestMigrate(t *testing.T) { } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() + if err != nil { + t.Fatalf("%v", err) + } + m, err := migrate.NewWithInstance("stub", src, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index f43fbb455..4ca44a58a 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -93,7 +93,11 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() + if err != nil { + t.Fatalf("%v", err) + } + m, err := migrate.NewWithInstance("stub", src, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go index 49c6a64bc..a923d469a 100644 --- a/database/redshift/redshift_test.go +++ b/database/redshift/redshift_test.go @@ -100,7 +100,11 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() + if err != nil { + t.Fatalf("%v", err) + } + m, err := migrate.NewWithInstance("stub", src, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index 122465094..f549f45ba 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -45,7 +45,11 @@ func TestMigrate(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() + if err != nil { + t.Fatalf("%v", err) + } + m, err := migrate.NewWithInstance("stub", src, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/stub/stub_test.go b/database/stub/stub_test.go index f0be9c910..5dadb39aa 100644 --- a/database/stub/stub_test.go +++ b/database/stub/stub_test.go @@ -24,9 +24,14 @@ func TestMigrate(t *testing.T) { t.Fatal(err) } - m, err := migrate.NewWithDatabaseInstance("stub://", "", d) + src, err := dt.GetStubSource() if err != nil { t.Fatalf("%v", err) } + m, err := migrate.NewWithInstance("stub", src, "", d) + if err != nil { + t.Fatalf("%v", err) + } + dt.TestMigrate(t, m, []byte("/* foobar migration */")) } diff --git a/database/testing/migrate_testing.go b/database/testing/migrate_testing.go index 5b328a715..b6f34b1da 100644 --- a/database/testing/migrate_testing.go +++ b/database/testing/migrate_testing.go @@ -9,6 +9,8 @@ import ( import ( "github.com/golang-migrate/migrate/v4" + "github.com/golang-migrate/migrate/v4/source" + "github.com/golang-migrate/migrate/v4/source/stub" ) // TestMigrate runs integration-tests between the Migrate layer and database implementations. @@ -36,4 +38,21 @@ func TestMigrateUp(t *testing.T, m *migrate.Migrate) { if err := m.Up(); err != nil { t.Fatalf("%v", err) } +} + +func GetStubSource() (source.Driver, error) { + stubMigrations := source.NewMigrations() + stubMigrations.Append(&source.Migration{Version: 1, Direction: source.Up, Identifier: "CREATE 1"}) + stubMigrations.Append(&source.Migration{Version: 1, Direction: source.Down, Identifier: "DROP 1"}) + stubMigrations.Append(&source.Migration{Version: 3, Direction: source.Up, Identifier: "CREATE 3"}) + stubMigrations.Append(&source.Migration{Version: 4, Direction: source.Up, Identifier: "CREATE 4"}) + stubMigrations.Append(&source.Migration{Version: 4, Direction: source.Down, Identifier: "DROP 4"}) + stubMigrations.Append(&source.Migration{Version: 5, Direction: source.Down, Identifier: "DROP 5"}) + stubMigrations.Append(&source.Migration{Version: 7, Direction: source.Up, Identifier: "CREATE 7"}) + stubMigrations.Append(&source.Migration{Version: 7, Direction: source.Down, Identifier: "DROP 7"}) + s := &stub.Stub{} + + d, err := s.Open("") + d.(*stub.Stub).Migrations = stubMigrations + return d, err } \ No newline at end of file From d8bff44dc4953150df11ce5ade7b170fe48ff72c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 10:46:11 +0100 Subject: [PATCH 16/21] Use example migrations for tests --- database/cassandra/cassandra_test.go | 6 +----- .../migration/1_simple_select.down.sql | 1 + .../examples/migration/1_simple_select.up.sql | 1 + database/cockroachdb/cockroachdb_test.go | 6 +----- database/mongodb/mongodb_test.go | 6 +----- .../mysql/examples/migration/1_init.down.sql | 1 + .../mysql/examples/migration/1_init.up.sql | 3 +++ database/mysql/mysql_test.go | 6 +----- database/postgres/postgres_test.go | 6 +----- database/redshift/redshift_test.go | 6 +----- database/spanner/spanner_test.go | 6 +----- database/stub/stub_test.go | 14 +++++++++----- database/testing/migrate_testing.go | 19 ------------------- 13 files changed, 22 insertions(+), 59 deletions(-) create mode 100644 database/cassandra/examples/migration/1_simple_select.down.sql create mode 100644 database/cassandra/examples/migration/1_simple_select.up.sql create mode 100644 database/mysql/examples/migration/1_init.down.sql create mode 100644 database/mysql/examples/migration/1_init.up.sql diff --git a/database/cassandra/cassandra_test.go b/database/cassandra/cassandra_test.go index 9843ca83a..4beb9a00f 100644 --- a/database/cassandra/cassandra_test.go +++ b/database/cassandra/cassandra_test.go @@ -89,11 +89,7 @@ func TestMigrate(t *testing.T) { } defer d.Close() - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "testks", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/cassandra/examples/migration/1_simple_select.down.sql b/database/cassandra/examples/migration/1_simple_select.down.sql new file mode 100644 index 000000000..29787f084 --- /dev/null +++ b/database/cassandra/examples/migration/1_simple_select.down.sql @@ -0,0 +1 @@ +SELECT table_name from system_schema.tables \ No newline at end of file diff --git a/database/cassandra/examples/migration/1_simple_select.up.sql b/database/cassandra/examples/migration/1_simple_select.up.sql new file mode 100644 index 000000000..29787f084 --- /dev/null +++ b/database/cassandra/examples/migration/1_simple_select.up.sql @@ -0,0 +1 @@ +SELECT table_name from system_schema.tables \ No newline at end of file diff --git a/database/cockroachdb/cockroachdb_test.go b/database/cockroachdb/cockroachdb_test.go index e2adf253a..05289fd62 100644 --- a/database/cockroachdb/cockroachdb_test.go +++ b/database/cockroachdb/cockroachdb_test.go @@ -110,11 +110,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "migrate", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index 0451553e7..13911e218 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -99,11 +99,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/mysql/examples/migration/1_init.down.sql b/database/mysql/examples/migration/1_init.down.sql new file mode 100644 index 000000000..1b10e6fc0 --- /dev/null +++ b/database/mysql/examples/migration/1_init.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS test; \ No newline at end of file diff --git a/database/mysql/examples/migration/1_init.up.sql b/database/mysql/examples/migration/1_init.up.sql new file mode 100644 index 000000000..2c3d7a1f2 --- /dev/null +++ b/database/mysql/examples/migration/1_init.up.sql @@ -0,0 +1,3 @@ +CREATE TABLE IF NOT EXISTS test ( + firstname VARCHAR(16) +); \ No newline at end of file diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index b89efbb75..5628025b7 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -107,11 +107,7 @@ func TestMigrate(t *testing.T) { } defer d.Close() - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "public", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index 4ca44a58a..bd9e9359c 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -93,11 +93,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "postgres", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go index a923d469a..32e014869 100644 --- a/database/redshift/redshift_test.go +++ b/database/redshift/redshift_test.go @@ -100,11 +100,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "postgres", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index f549f45ba..b4d8fafbd 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -45,11 +45,7 @@ func TestMigrate(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", db, d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/stub/stub_test.go b/database/stub/stub_test.go index 5dadb39aa..218a933ac 100644 --- a/database/stub/stub_test.go +++ b/database/stub/stub_test.go @@ -2,6 +2,8 @@ package stub import ( "github.com/golang-migrate/migrate/v4" + "github.com/golang-migrate/migrate/v4/source" + "github.com/golang-migrate/migrate/v4/source/stub" "testing" dt "github.com/golang-migrate/migrate/v4/database/testing" @@ -24,11 +26,13 @@ func TestMigrate(t *testing.T) { t.Fatal(err) } - src, err := dt.GetStubSource() - if err != nil { - t.Fatalf("%v", err) - } - m, err := migrate.NewWithInstance("stub", src, "", d) + stubMigrations := source.NewMigrations() + stubMigrations.Append(&source.Migration{Version: 1, Direction: source.Up, Identifier: "CREATE 1"}) + stubMigrations.Append(&source.Migration{Version: 1, Direction: source.Down, Identifier: "DROP 1"}) + src := &stub.Stub{} + srcDrv, err := src.Open("") + srcDrv.(*stub.Stub).Migrations = stubMigrations + m, err := migrate.NewWithInstance("stub", srcDrv, "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/testing/migrate_testing.go b/database/testing/migrate_testing.go index b6f34b1da..5b328a715 100644 --- a/database/testing/migrate_testing.go +++ b/database/testing/migrate_testing.go @@ -9,8 +9,6 @@ import ( import ( "github.com/golang-migrate/migrate/v4" - "github.com/golang-migrate/migrate/v4/source" - "github.com/golang-migrate/migrate/v4/source/stub" ) // TestMigrate runs integration-tests between the Migrate layer and database implementations. @@ -38,21 +36,4 @@ func TestMigrateUp(t *testing.T, m *migrate.Migrate) { if err := m.Up(); err != nil { t.Fatalf("%v", err) } -} - -func GetStubSource() (source.Driver, error) { - stubMigrations := source.NewMigrations() - stubMigrations.Append(&source.Migration{Version: 1, Direction: source.Up, Identifier: "CREATE 1"}) - stubMigrations.Append(&source.Migration{Version: 1, Direction: source.Down, Identifier: "DROP 1"}) - stubMigrations.Append(&source.Migration{Version: 3, Direction: source.Up, Identifier: "CREATE 3"}) - stubMigrations.Append(&source.Migration{Version: 4, Direction: source.Up, Identifier: "CREATE 4"}) - stubMigrations.Append(&source.Migration{Version: 4, Direction: source.Down, Identifier: "DROP 4"}) - stubMigrations.Append(&source.Migration{Version: 5, Direction: source.Down, Identifier: "DROP 5"}) - stubMigrations.Append(&source.Migration{Version: 7, Direction: source.Up, Identifier: "CREATE 7"}) - stubMigrations.Append(&source.Migration{Version: 7, Direction: source.Down, Identifier: "DROP 7"}) - s := &stub.Stub{} - - d, err := s.Open("") - d.(*stub.Stub).Migrations = stubMigrations - return d, err } \ No newline at end of file From 27a85dda68963dbb9cafc56a508d9d83eb3f4b9a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 10:59:05 +0100 Subject: [PATCH 17/21] Add file driver to database tests --- database/cockroachdb/cockroachdb_test.go | 2 +- database/mongodb/mongodb_test.go | 2 +- database/mysql/mysql_test.go | 2 +- database/postgres/postgres_test.go | 2 +- database/redshift/redshift_test.go | 2 +- database/spanner/spanner_test.go | 2 +- database/stub/stub_test.go | 1 - 7 files changed, 6 insertions(+), 7 deletions(-) diff --git a/database/cockroachdb/cockroachdb_test.go b/database/cockroachdb/cockroachdb_test.go index 05289fd62..2e09503cf 100644 --- a/database/cockroachdb/cockroachdb_test.go +++ b/database/cockroachdb/cockroachdb_test.go @@ -19,7 +19,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" - _ "github.com/golang-migrate/migrate/v4/source/stub" + _ "github.com/golang-migrate/migrate/v4/source/file" ) const defaultPort = 26257 diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index 13911e218..47b155d1f 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -21,7 +21,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" - _ "github.com/golang-migrate/migrate/v4/source/stub" + _ "github.com/golang-migrate/migrate/v4/source/file" ) var ( diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index 5628025b7..0e09220af 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -18,7 +18,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" - _ "github.com/golang-migrate/migrate/v4/source/stub" + _ "github.com/golang-migrate/migrate/v4/source/file" ) const defaultPort = 3306 diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index bd9e9359c..2dc1c53af 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -18,7 +18,7 @@ import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" - _ "github.com/golang-migrate/migrate/v4/source/stub" + _ "github.com/golang-migrate/migrate/v4/source/file" ) var ( diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go index 32e014869..08d48dedc 100644 --- a/database/redshift/redshift_test.go +++ b/database/redshift/redshift_test.go @@ -22,7 +22,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" - _ "github.com/golang-migrate/migrate/v4/source/stub" + _ "github.com/golang-migrate/migrate/v4/source/file" ) var ( diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index b4d8fafbd..1d07acb15 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -7,7 +7,7 @@ import ( "testing" dt "github.com/golang-migrate/migrate/v4/database/testing" - _ "github.com/golang-migrate/migrate/v4/source/stub" + _ "github.com/golang-migrate/migrate/v4/source/file" ) func Test(t *testing.T) { diff --git a/database/stub/stub_test.go b/database/stub/stub_test.go index 218a933ac..f755be65c 100644 --- a/database/stub/stub_test.go +++ b/database/stub/stub_test.go @@ -7,7 +7,6 @@ import ( "testing" dt "github.com/golang-migrate/migrate/v4/database/testing" - _ "github.com/golang-migrate/migrate/v4/source/stub" ) func Test(t *testing.T) { From 28d69a05d9a5ba2af0ef3c5333b04817a2694db0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 11:44:51 +0100 Subject: [PATCH 18/21] Align database directory layout --- database/cassandra/cassandra_test.go | 2 +- .../{migration => migrations}/1_simple_select.down.sql | 0 .../examples/{migration => migrations}/1_simple_select.up.sql | 0 database/cockroachdb/cockroachdb_test.go | 2 +- .../examples/{ => migrations}/001_create_user.down.json | 0 .../mongodb/examples/{ => migrations}/001_create_user.up.json | 0 .../examples/{ => migrations}/002_create_indexes.down.json | 0 .../examples/{ => migrations}/002_create_indexes.up.json | 0 database/mongodb/mongodb_test.go | 2 +- .../mysql/examples/{migration => migrations}/1_init.down.sql | 0 .../mysql/examples/{migration => migrations}/1_init.up.sql | 0 database/mysql/mysql_test.go | 2 +- database/postgres/postgres_test.go | 2 +- .../migrations}/33_create_table.down.sql | 0 .../{migration => examples/migrations}/33_create_table.up.sql | 0 .../migrations}/44_alter_table.down.sql | 0 .../{migration => examples/migrations}/44_alter_table.up.sql | 0 database/ql/ql_test.go | 2 +- database/redshift/redshift_test.go | 2 +- database/spanner/spanner_test.go | 2 +- .../migrations}/33_create_table.down.sql | 0 .../{migration => examples/migrations}/33_create_table.up.sql | 0 .../migrations}/44_alter_table.down.sql | 0 .../{migration => examples/migrations}/44_alter_table.up.sql | 0 database/sqlite3/sqlite3_test.go | 4 ++-- 25 files changed, 10 insertions(+), 10 deletions(-) rename database/cassandra/examples/{migration => migrations}/1_simple_select.down.sql (100%) rename database/cassandra/examples/{migration => migrations}/1_simple_select.up.sql (100%) rename database/mongodb/examples/{ => migrations}/001_create_user.down.json (100%) rename database/mongodb/examples/{ => migrations}/001_create_user.up.json (100%) rename database/mongodb/examples/{ => migrations}/002_create_indexes.down.json (100%) rename database/mongodb/examples/{ => migrations}/002_create_indexes.up.json (100%) rename database/mysql/examples/{migration => migrations}/1_init.down.sql (100%) rename database/mysql/examples/{migration => migrations}/1_init.up.sql (100%) rename database/ql/{migration => examples/migrations}/33_create_table.down.sql (100%) rename database/ql/{migration => examples/migrations}/33_create_table.up.sql (100%) rename database/ql/{migration => examples/migrations}/44_alter_table.down.sql (100%) rename database/ql/{migration => examples/migrations}/44_alter_table.up.sql (100%) rename database/sqlite3/{migration => examples/migrations}/33_create_table.down.sql (100%) rename database/sqlite3/{migration => examples/migrations}/33_create_table.up.sql (100%) rename database/sqlite3/{migration => examples/migrations}/44_alter_table.down.sql (100%) rename database/sqlite3/{migration => examples/migrations}/44_alter_table.up.sql (100%) diff --git a/database/cassandra/cassandra_test.go b/database/cassandra/cassandra_test.go index 4beb9a00f..369b37ac9 100644 --- a/database/cassandra/cassandra_test.go +++ b/database/cassandra/cassandra_test.go @@ -89,7 +89,7 @@ func TestMigrate(t *testing.T) { } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "testks", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "testks", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/cassandra/examples/migration/1_simple_select.down.sql b/database/cassandra/examples/migrations/1_simple_select.down.sql similarity index 100% rename from database/cassandra/examples/migration/1_simple_select.down.sql rename to database/cassandra/examples/migrations/1_simple_select.down.sql diff --git a/database/cassandra/examples/migration/1_simple_select.up.sql b/database/cassandra/examples/migrations/1_simple_select.up.sql similarity index 100% rename from database/cassandra/examples/migration/1_simple_select.up.sql rename to database/cassandra/examples/migrations/1_simple_select.up.sql diff --git a/database/cockroachdb/cockroachdb_test.go b/database/cockroachdb/cockroachdb_test.go index 2e09503cf..4f5570e0b 100644 --- a/database/cockroachdb/cockroachdb_test.go +++ b/database/cockroachdb/cockroachdb_test.go @@ -110,7 +110,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } - m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "migrate", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "migrate", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/mongodb/examples/001_create_user.down.json b/database/mongodb/examples/migrations/001_create_user.down.json similarity index 100% rename from database/mongodb/examples/001_create_user.down.json rename to database/mongodb/examples/migrations/001_create_user.down.json diff --git a/database/mongodb/examples/001_create_user.up.json b/database/mongodb/examples/migrations/001_create_user.up.json similarity index 100% rename from database/mongodb/examples/001_create_user.up.json rename to database/mongodb/examples/migrations/001_create_user.up.json diff --git a/database/mongodb/examples/002_create_indexes.down.json b/database/mongodb/examples/migrations/002_create_indexes.down.json similarity index 100% rename from database/mongodb/examples/002_create_indexes.down.json rename to database/mongodb/examples/migrations/002_create_indexes.down.json diff --git a/database/mongodb/examples/002_create_indexes.up.json b/database/mongodb/examples/migrations/002_create_indexes.up.json similarity index 100% rename from database/mongodb/examples/002_create_indexes.up.json rename to database/mongodb/examples/migrations/002_create_indexes.up.json diff --git a/database/mongodb/mongodb_test.go b/database/mongodb/mongodb_test.go index 47b155d1f..260fd1c18 100644 --- a/database/mongodb/mongodb_test.go +++ b/database/mongodb/mongodb_test.go @@ -99,7 +99,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/mysql/examples/migration/1_init.down.sql b/database/mysql/examples/migrations/1_init.down.sql similarity index 100% rename from database/mysql/examples/migration/1_init.down.sql rename to database/mysql/examples/migrations/1_init.down.sql diff --git a/database/mysql/examples/migration/1_init.up.sql b/database/mysql/examples/migrations/1_init.up.sql similarity index 100% rename from database/mysql/examples/migration/1_init.up.sql rename to database/mysql/examples/migrations/1_init.up.sql diff --git a/database/mysql/mysql_test.go b/database/mysql/mysql_test.go index 0e09220af..a71383484 100644 --- a/database/mysql/mysql_test.go +++ b/database/mysql/mysql_test.go @@ -107,7 +107,7 @@ func TestMigrate(t *testing.T) { } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "public", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "public", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/postgres/postgres_test.go b/database/postgres/postgres_test.go index 2dc1c53af..ad2d91f6b 100644 --- a/database/postgres/postgres_test.go +++ b/database/postgres/postgres_test.go @@ -93,7 +93,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "postgres", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "postgres", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/ql/migration/33_create_table.down.sql b/database/ql/examples/migrations/33_create_table.down.sql similarity index 100% rename from database/ql/migration/33_create_table.down.sql rename to database/ql/examples/migrations/33_create_table.down.sql diff --git a/database/ql/migration/33_create_table.up.sql b/database/ql/examples/migrations/33_create_table.up.sql similarity index 100% rename from database/ql/migration/33_create_table.up.sql rename to database/ql/examples/migrations/33_create_table.up.sql diff --git a/database/ql/migration/44_alter_table.down.sql b/database/ql/examples/migrations/44_alter_table.down.sql similarity index 100% rename from database/ql/migration/44_alter_table.down.sql rename to database/ql/examples/migrations/44_alter_table.down.sql diff --git a/database/ql/migration/44_alter_table.up.sql b/database/ql/examples/migrations/44_alter_table.up.sql similarity index 100% rename from database/ql/migration/44_alter_table.up.sql rename to database/ql/examples/migrations/44_alter_table.up.sql diff --git a/database/ql/ql_test.go b/database/ql/ql_test.go index 7b875b09f..e1cab085c 100644 --- a/database/ql/ql_test.go +++ b/database/ql/ql_test.go @@ -68,7 +68,7 @@ func TestMigrate(t *testing.T) { } m, err := migrate.NewWithDatabaseInstance( - "file://./migration", + "file://./examples/migrations", "ql", driver) if err != nil { t.Fatalf("%v", err) diff --git a/database/redshift/redshift_test.go b/database/redshift/redshift_test.go index 08d48dedc..0fa58651d 100644 --- a/database/redshift/redshift_test.go +++ b/database/redshift/redshift_test.go @@ -100,7 +100,7 @@ func TestMigrate(t *testing.T) { t.Fatalf("%v", err) } defer d.Close() - m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", "postgres", d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", "postgres", d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index 1d07acb15..b3e5657d8 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -45,7 +45,7 @@ func TestMigrate(t *testing.T) { if err != nil { t.Fatalf("%v", err) } - m, err := migrate.NewWithDatabaseInstance("file://./examples/migration", db, d) + m, err := migrate.NewWithDatabaseInstance("file://./examples/migrations", db, d) if err != nil { t.Fatalf("%v", err) } diff --git a/database/sqlite3/migration/33_create_table.down.sql b/database/sqlite3/examples/migrations/33_create_table.down.sql similarity index 100% rename from database/sqlite3/migration/33_create_table.down.sql rename to database/sqlite3/examples/migrations/33_create_table.down.sql diff --git a/database/sqlite3/migration/33_create_table.up.sql b/database/sqlite3/examples/migrations/33_create_table.up.sql similarity index 100% rename from database/sqlite3/migration/33_create_table.up.sql rename to database/sqlite3/examples/migrations/33_create_table.up.sql diff --git a/database/sqlite3/migration/44_alter_table.down.sql b/database/sqlite3/examples/migrations/44_alter_table.down.sql similarity index 100% rename from database/sqlite3/migration/44_alter_table.down.sql rename to database/sqlite3/examples/migrations/44_alter_table.down.sql diff --git a/database/sqlite3/migration/44_alter_table.up.sql b/database/sqlite3/examples/migrations/44_alter_table.up.sql similarity index 100% rename from database/sqlite3/migration/44_alter_table.up.sql rename to database/sqlite3/examples/migrations/44_alter_table.up.sql diff --git a/database/sqlite3/sqlite3_test.go b/database/sqlite3/sqlite3_test.go index 2ccb33d1e..648141c92 100644 --- a/database/sqlite3/sqlite3_test.go +++ b/database/sqlite3/sqlite3_test.go @@ -66,7 +66,7 @@ func TestMigrate(t *testing.T) { } m, err := migrate.NewWithDatabaseInstance( - "file://./migration", + "file://./examples/migrations", "ql", driver) if err != nil { t.Fatalf("%v", err) @@ -103,7 +103,7 @@ func TestMigrationTable(t *testing.T) { t.Fatalf("%v", err) } m, err := migrate.NewWithDatabaseInstance( - "file://./migration", + "file://./examples/migrations", "ql", driver) if err != nil { t.Fatalf("%v", err) From 179720de277a4c0acee34a1acbd124521a102b0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Thu, 21 Feb 2019 12:03:25 +0100 Subject: [PATCH 19/21] Add file source driver to Cassandra --- database/cassandra/cassandra_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/database/cassandra/cassandra_test.go b/database/cassandra/cassandra_test.go index 369b37ac9..3389f109e 100644 --- a/database/cassandra/cassandra_test.go +++ b/database/cassandra/cassandra_test.go @@ -16,7 +16,7 @@ import ( import ( dt "github.com/golang-migrate/migrate/v4/database/testing" "github.com/golang-migrate/migrate/v4/dktesting" - _ "github.com/golang-migrate/migrate/v4/source/stub" + _ "github.com/golang-migrate/migrate/v4/source/file" ) var ( From 170d30918bd17fd4523c5c1a61d0b5e3b78f7839 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Tue, 26 Feb 2019 07:59:36 +0100 Subject: [PATCH 20/21] Review changes --- database/mysql/mysql.go | 8 ++++---- database/postgres/postgres.go | 7 +------ database/ql/ql_test.go | 4 ++-- database/redshift/redshift.go | 8 ++++---- database/spanner/spanner_test.go | 4 ++-- 5 files changed, 13 insertions(+), 18 deletions(-) diff --git a/database/mysql/mysql.go b/database/mysql/mysql.go index da8ed54bc..ccd6f3703 100644 --- a/database/mysql/mysql.go +++ b/database/mysql/mysql.go @@ -76,15 +76,15 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config.DatabaseName = databaseName.String + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + conn, err := instance.Conn(context.Background()) if err != nil { return nil, err } - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } - mx := &Mysql{ conn: conn, db: instance, diff --git a/database/postgres/postgres.go b/database/postgres/postgres.go index a9b2dd23e..cf7d51e28 100644 --- a/database/postgres/postgres.go +++ b/database/postgres/postgres.go @@ -92,18 +92,13 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { return nil, err } - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } - px := &Postgres{ conn: conn, db: instance, config: config, } - err = px.ensureVersionTable() - if err != nil { + if err = px.ensureVersionTable(); err != nil { return nil, err } diff --git a/database/ql/ql_test.go b/database/ql/ql_test.go index e1cab085c..49e629cce 100644 --- a/database/ql/ql_test.go +++ b/database/ql/ql_test.go @@ -22,7 +22,7 @@ func Test(t *testing.T) { defer func() { os.RemoveAll(dir) }() - fmt.Printf("DB path : %s\n", filepath.Join(dir, "ql.db")) + t.Logf("DB path : %s\n", filepath.Join(dir, "ql.db")) p := &Ql{} addr := fmt.Sprintf("ql://%s", filepath.Join(dir, "ql.db")) d, err := p.Open(addr) @@ -50,7 +50,7 @@ func TestMigrate(t *testing.T) { defer func() { os.RemoveAll(dir) }() - fmt.Printf("DB path : %s\n", filepath.Join(dir, "ql.db")) + t.Logf("DB path : %s\n", filepath.Join(dir, "ql.db")) db, err := sql.Open("ql", filepath.Join(dir, "ql.db")) if err != nil { diff --git a/database/redshift/redshift.go b/database/redshift/redshift.go index eb834cb4b..ee4dcf624 100644 --- a/database/redshift/redshift.go +++ b/database/redshift/redshift.go @@ -65,16 +65,16 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config.DatabaseName = databaseName + if len(config.MigrationsTable) == 0 { + config.MigrationsTable = DefaultMigrationsTable + } + conn, err := instance.Conn(context.Background()) if err != nil { return nil, err } - if len(config.MigrationsTable) == 0 { - config.MigrationsTable = DefaultMigrationsTable - } - px := &Redshift{ conn: conn, db: instance, diff --git a/database/spanner/spanner_test.go b/database/spanner/spanner_test.go index b3e5657d8..b9cb52b13 100644 --- a/database/spanner/spanner_test.go +++ b/database/spanner/spanner_test.go @@ -21,7 +21,7 @@ func Test(t *testing.T) { } s := &Spanner{} - addr := fmt.Sprintf("spanner://%v", db) + addr := fmt.Sprintf("spanner://%s", db) d, err := s.Open(addr) if err != nil { t.Fatalf("%v", err) @@ -40,7 +40,7 @@ func TestMigrate(t *testing.T) { } s := &Spanner{} - addr := fmt.Sprintf("spanner://%v", db) + addr := fmt.Sprintf("spanner://%s", db) d, err := s.Open(addr) if err != nil { t.Fatalf("%v", err) From 4c3f71fb625b9b5a78e00c00c191331fb60c4b20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Lukas=20J=C3=B8rgensen=20=28LUJOR=29?= Date: Tue, 26 Feb 2019 08:04:28 +0100 Subject: [PATCH 21/21] Minor syntactic change for cleaner diff --- database/postgres/postgres.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/database/postgres/postgres.go b/database/postgres/postgres.go index cf7d51e28..a9570bc72 100644 --- a/database/postgres/postgres.go +++ b/database/postgres/postgres.go @@ -98,7 +98,7 @@ func WithInstance(instance *sql.DB, config *Config) (database.Driver, error) { config: config, } - if err = px.ensureVersionTable(); err != nil { + if err := px.ensureVersionTable(); err != nil { return nil, err }