package migrate_test import ( "database/sql" "fmt" "log" "os" "strings" "testing" . "github.com/drone/drone/pkg/database/migrate" _ "github.com/go-sql-driver/mysql" _ "github.com/mattn/go-sqlite3" "github.com/russross/meddler" ) type Sample struct { ID int64 `meddler:"id,pk"` Imel string `meddler:"imel"` Name string `meddler:"name"` } type RenameSample struct { ID int64 `meddler:"id,pk"` Email string `meddler:"email"` Name string `meddler:"name"` } type AddColumnSample struct { ID int64 `meddler:"id,pk"` Imel string `meddler:"imel"` Name string `meddler:"name"` Url string `meddler:"url"` Num int64 `meddler:"num"` } // ---------- revision 1 type revision1 struct{} func (r *revision1) Up(mg *MigrationDriver) error { _, err := mg.CreateTable("samples", []string{ mg.T.Integer("id", PRIMARYKEY, AUTOINCREMENT), mg.T.String("imel", UNIQUE), mg.T.String("name"), }) return err } func (r *revision1) Down(mg *MigrationDriver) error { _, err := mg.DropTable("samples") return err } func (r *revision1) Revision() int64 { return 1 } // ---------- end of revision 1 // ---------- revision 2 type revision2 struct{} func (r *revision2) Up(mg *MigrationDriver) error { _, err := mg.RenameTable("samples", "examples") return err } func (r *revision2) Down(mg *MigrationDriver) error { _, err := mg.RenameTable("examples", "samples") return err } func (r *revision2) Revision() int64 { return 2 } // ---------- end of revision 2 // ---------- revision 3 type revision3 struct{} func (r *revision3) Up(mg *MigrationDriver) error { if _, err := mg.AddColumn("samples", "url VARCHAR(255)"); err != nil { return err } _, err := mg.AddColumn("samples", "num INTEGER") return err } func (r *revision3) Down(mg *MigrationDriver) error { _, err := mg.DropColumns("samples", "num", "url") return err } func (r *revision3) Revision() int64 { return 3 } // ---------- end of revision 3 // ---------- revision 4 type revision4 struct{} func (r *revision4) Up(mg *MigrationDriver) error { _, err := mg.RenameColumns("samples", map[string]string{ "imel": "email", }) return err } func (r *revision4) Down(mg *MigrationDriver) error { _, err := mg.RenameColumns("samples", map[string]string{ "email": "imel", }) return err } func (r *revision4) Revision() int64 { return 4 } // ---------- end of revision 4 // ---------- revision 5 type revision5 struct{} func (r *revision5) Up(mg *MigrationDriver) error { _, err := mg.AddIndex("samples", []string{"url", "name"}) return err } func (r *revision5) Down(mg *MigrationDriver) error { _, err := mg.DropIndex("samples", []string{"url", "name"}) return err } func (r *revision5) Revision() int64 { return 5 } // ---------- end of revision 5 // ---------- revision 6 type revision6 struct{} func (r *revision6) Up(mg *MigrationDriver) error { _, err := mg.RenameColumns("samples", map[string]string{ "url": "host", }) return err } func (r *revision6) Down(mg *MigrationDriver) error { _, err := mg.RenameColumns("samples", map[string]string{ "host": "url", }) return err } func (r *revision6) Revision() int64 { return 6 } // ---------- end of revision 6 // ---------- revision 7 type revision7 struct{} func (r *revision7) Up(mg *MigrationDriver) error { _, err := mg.DropColumns("samples", "host", "num") return err } func (r *revision7) Down(mg *MigrationDriver) error { if _, err := mg.AddColumn("samples", "host VARCHAR(255)"); err != nil { return err } _, err := mg.AddColumn("samples", "num INSTEGER") return err } func (r *revision7) Revision() int64 { return 7 } // ---------- end of revision 7 // ---------- revision 8 type revision8 struct{} func (r *revision8) Up(mg *MigrationDriver) error { if _, err := mg.AddColumn("samples", "repo_id INTEGER"); err != nil { return err } _, err := mg.AddColumn("samples", "repo VARCHAR(255)") return err } func (r *revision8) Down(mg *MigrationDriver) error { _, err := mg.DropColumns("samples", "repo", "repo_id") return err } func (r *revision8) Revision() int64 { return 8 } // ---------- end of revision 8 // ---------- revision 9 type revision9 struct{} func (r *revision9) Up(mg *MigrationDriver) error { _, err := mg.RenameColumns("samples", map[string]string{ "repo": "repository", }) return err } func (r *revision9) Down(mg *MigrationDriver) error { _, err := mg.RenameColumns("samples", map[string]string{ "repository": "repo", }) return err } func (r *revision9) Revision() int64 { return 9 } // ---------- end of revision 9 // ---------- revision 10 type revision10 struct{} func (r *revision10) Revision() int64 { return 10 } func (r *revision10) Up(mg *MigrationDriver) error { _, err := mg.ChangeColumn("samples", "email", "varchar(512) UNIQUE") return err } func (r *revision10) Down(mg *MigrationDriver) error { _, err := mg.ChangeColumn("samples", "email", "varchar(255) unique") return err } // ---------- end of revision 10 var ( db *sql.DB driver, dsn string dbname = "drone_test" ) var testSchema = ` CREATE TABLE samples ( id INTEGER PRIMARY KEY AUTOINCREMENT, imel VARCHAR(255) UNIQUE, name VARCHAR(255) ); ` var dataDump = []string{ `INSERT INTO samples (imel, name) VALUES ('test@example.com', 'Test Tester');`, `INSERT INTO samples (imel, name) VALUES ('foo@bar.com', 'Foo Bar');`, `INSERT INTO samples (imel, name) VALUES ('crash@bandicoot.io', 'Crash Bandicoot');`, } func TestMigrateCreateTable(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } mgr := New(db) if err := mgr.Add(&revision1{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } sample := Sample{ ID: 1, Imel: "test@example.com", Name: "Test Tester", } if err := meddler.Save(db, "samples", &sample); err != nil { t.Fatalf("Can not save data: %q", err) } } func TestMigrateExistingCreateTable(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } if _, err := db.Exec(testSchema); err != nil { t.Fatalf("Can not create database: %q", err) } mgr := New(db) rev := &revision1{} if err := mgr.Add(rev).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var current int64 db.QueryRow("SELECT max(revision) FROM migration").Scan(¤t) if current != rev.Revision() { t.Fatalf("Did not successfully migrate") } } func TestMigrateRenameTable(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } mgr := New(db) if err := mgr.Add(&revision1{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } loadFixture(t) if err := mgr.Add(&revision2{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } sample := Sample{} if err := meddler.QueryRow(db, &sample, `SELECT * FROM examples WHERE id = ?`, 2); err != nil { t.Fatalf("Can not fetch data: %q", err) } if sample.Imel != "foo@bar.com" { t.Errorf("Column doesn't match. Expect: %s, got: %s", "foo@bar.com", sample.Imel) } } type TableInfo struct { CID int64 `meddler:"cid,pk"` Name string `meddler:"name"` Type string `meddler:"type"` Notnull bool `meddler:"notnull"` DfltValue interface{} `meddler:"dflt_value"` PK bool `meddler:"pk"` } func TestMigrateAddRemoveColumns(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } mgr := New(db) if err := mgr.Add(&revision1{}, &revision3{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var columns []*TableInfo if err := meddler.QueryAll(db, &columns, `PRAGMA table_info(samples);`); err != nil { t.Fatalf("Can not access table info: %q", err) } if len(columns) < 5 { t.Errorf("Expect length columns: %d\nGot: %d", 5, len(columns)) } var row = AddColumnSample{ ID: 33, Name: "Foo", Imel: "foo@bar.com", Url: "http://example.com", Num: 42, } if err := meddler.Save(db, "samples", &row); err != nil { t.Fatalf("Can not save into database: %q", err) } if err := mgr.MigrateTo(1); err != nil { t.Fatalf("Can not migrate: %q", err) } var another_columns []*TableInfo if err := meddler.QueryAll(db, &another_columns, `PRAGMA table_info(samples);`); err != nil { t.Fatalf("Can not access table info: %q", err) } if len(another_columns) != 3 { t.Errorf("Expect length columns = %d, got: %d", 3, len(columns)) } } func TestRenameColumn(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } mgr := New(db) if err := mgr.Add(&revision1{}, &revision4{}).MigrateTo(1); err != nil { t.Fatalf("Can not migrate: %q", err) } loadFixture(t) if err := mgr.MigrateTo(4); err != nil { t.Fatalf("Can not migrate: %q", err) } row := RenameSample{} if err := meddler.QueryRow(db, &row, `SELECT * FROM samples WHERE id = 3;`); err != nil { t.Fatalf("Can not query database: %q", err) } if row.Email != "crash@bandicoot.io" { t.Errorf("Expect %s, got %s", "crash@bandicoot.io", row.Email) } } func TestMigrateExistingTable(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } if _, err := db.Exec(testSchema); err != nil { t.Fatalf("Can not create database: %q", err) } loadFixture(t) mgr := New(db) if err := mgr.Add(&revision4{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var rows []*RenameSample if err := meddler.QueryAll(db, &rows, `SELECT * from samples;`); err != nil { t.Fatalf("Can not query database: %q", err) } if len(rows) != 3 { t.Errorf("Expect rows length = %d, got %d", 3, len(rows)) } if rows[1].Email != "foo@bar.com" { t.Errorf("Expect email = %s, got %s", "foo@bar.com", rows[1].Email) } } type sqliteMaster struct { Sql interface{} `meddler:"sql"` } func TestIndexOperations(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } mgr := New(db) // Migrate, create index if err := mgr.Add(&revision1{}, &revision3{}, &revision5{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var esquel []*sqliteMaster switch { case driver == "mysql": default: // Query sqlite_master, check if index is exists. query := `SELECT sql FROM sqlite_master WHERE type='index' and tbl_name='samples'` if err := meddler.QueryAll(db, &esquel, query); err != nil { t.Fatalf("Can not find index: %q", err) } indexStatement := `CREATE INDEX idx_samples_on_url_and_name ON samples (url, name)` if string(esquel[1].Sql.([]byte)) != indexStatement { t.Errorf("Can not find index, got: %q", esquel[1]) } // Migrate, rename indexed columns if err := mgr.Add(&revision6{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var esquel1 []*sqliteMaster if err := meddler.QueryAll(db, &esquel1, query); err != nil { t.Fatalf("Can not find index: %q", err) } indexStatement = `CREATE INDEX idx_samples_on_host_and_name ON samples (host, name)` if string(esquel1[1].Sql.([]byte)) != indexStatement { t.Errorf("Can not find index, got: %q", esquel1[1]) } if err := mgr.Add(&revision7{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var esquel2 []*sqliteMaster if err := meddler.QueryAll(db, &esquel2, query); err != nil { t.Fatalf("Can not find index: %q", err) } if len(esquel2) != 1 { t.Errorf("Expect row length equal to %d, got %d", 1, len(esquel2)) } } } func TestColumnRedundancy(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } migr := New(db) if err := migr.Add(&revision1{}, &revision8{}, &revision9{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var dummy, query, tableSql string switch { case driver == "mysql": query = `SHOW CREATE TABLE samples` if err := db.QueryRow(query).Scan(&dummy, &tableSql); err != nil { t.Fatalf("Can not query table's definition: %q", err) } if !strings.Contains(tableSql, "`repository`") { t.Errorf("Expect column with name repository") } default: query = `SELECT sql FROM sqlite_master where type='table' and name='samples'` if err := db.QueryRow(query).Scan(&tableSql); err != nil { t.Fatalf("Can not query sqlite_master: %q", err) } if !strings.Contains(tableSql, "repository ") { t.Errorf("Expect column with name repository") } } } func TestChangeColumnType(t *testing.T) { defer tearDown() if err := setUp(); err != nil { t.Fatalf("Error preparing database: %q", err) } migr := New(db) if err := migr.Add(&revision1{}, &revision4{}, &revision10{}).Migrate(); err != nil { t.Fatalf("Can not migrate: %q", err) } var dummy, tableSql, query string switch { case driver == "mysql": query = `SHOW CREATE TABLE samples` if err := db.QueryRow(query).Scan(&dummy, &tableSql); err != nil { t.Fatalf("Can not query table's definition: %q", err) } if !strings.Contains(tableSql, "`email` varchar(512)") { t.Errorf("Expect email type to changed: %q", tableSql) } default: query = `SELECT sql FROM sqlite_master where type='table' and name='samples'` if err := db.QueryRow(query).Scan(&tableSql); err != nil { t.Fatalf("Can not query sqlite_master: %q", err) } if !strings.Contains(tableSql, "email varchar(512) UNIQUE") { t.Errorf("Expect email type to changed: %q", tableSql) } } } func init() { if driver = os.Getenv("DB_ENV"); len(driver) == 0 { driver = "sqlite3" } if dsn = os.Getenv("MYSQL_LOGIN"); len(dsn) == 0 { dsn = ":memory:" } } func setUp() error { var err error Driver = SQLite if db, err = sql.Open(driver, dsn); err != nil { log.Fatalf("Can't connect to database: %q", err) } if driver == "mysql" { Driver = MySQL if _, err := db.Exec(fmt.Sprintf("CREATE DATABASE %s", dbname)); err != nil { panic("Can't create database") } if _, err := db.Exec(fmt.Sprintf("USE %s", dbname)); err != nil { panic("Can't use database") } } return err } func tearDown() { if driver == "mysql" { db.Exec(fmt.Sprintf("DROP DATABASE %s", dbname)) } db.Close() } func loadFixture(t *testing.T) { for _, sql := range dataDump { if _, err := db.Exec(sql); err != nil { t.Fatalf("Can not insert into database: %q", err) } } }