Created
September 2, 2014 14:19
-
-
Save kzaitsev/896ca181d429518b6d6d to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package migrationutil | |
import ( | |
m "github.com/drone/drone/server/database/migrationutil" | |
) | |
// Test create table | |
type Migrate_100000000001 struct{} | |
var CreateTestTable = &Migrate_100000000001{} | |
func (m *Migrate_100000000001) Revision() int64 { | |
return 100000000001 | |
} | |
func (m *Migrate_100000000001) Up(mg *m.MigrationDriver) error { | |
t := mg.T | |
_, err := mg.CreateTable("test", []string{ | |
t.Serial("test1"), | |
t.String("test2"), | |
t.Integer("test3"), | |
t.Bool("test4"), | |
t.Timestamp("test5"), | |
t.Blob("test6"), | |
t.Text("test7"), | |
t.Varchar("test8", 600), | |
}) | |
return err | |
} | |
func (m *Migrate_100000000001) Down(mg *m.MigrationDriver) error { | |
_, err := mg.DropTable("test") | |
return err | |
} | |
// Test rename table | |
type Migrate_100000000002 struct{} | |
var RenameTestTable = &Migrate_100000000002{} | |
func (m *Migrate_100000000002) Revision() int64 { | |
return 100000000002 | |
} | |
func (m *Migrate_100000000002) Up(mg *m.MigrationDriver) error { | |
_, err := mg.RenameTable("test", "test_renamed") | |
return err | |
} | |
func (m *Migrate_100000000002) Down(mg *m.MigrationDriver) error { | |
_, err := mg.RenameTable("test_renamed", "test") | |
return err | |
} | |
// Test drop table | |
type Migrate_100000000003 struct{} | |
var DropTestTable = &Migrate_100000000003{} | |
func (m *Migrate_100000000003) Revision() int64 { | |
return 100000000003 | |
} | |
func (m *Migrate_100000000003) Up(mg *m.MigrationDriver) error { | |
_, err := mg.DropTable("test") | |
return err | |
} | |
func (m *Migrate_100000000003) Down(mg *m.MigrationDriver) error { | |
t := mg.T | |
_, err := mg.CreateTable("test", []string{ | |
t.Serial("test1"), | |
t.String("test2"), | |
t.Integer("test3"), | |
t.Bool("test4"), | |
t.Timestamp("test5"), | |
t.Blob("test6"), | |
t.Text("test7"), | |
t.Varchar("test8", 600), | |
}) | |
return err | |
} | |
// Test add column to table | |
type Migrate_100000000004 struct{} | |
var AddColumnToTestTable = &Migrate_100000000004{} | |
func (m *Migrate_100000000004) Revision() int64 { | |
return 100000000004 | |
} | |
func (m *Migrate_100000000004) Up(mg *m.MigrationDriver) error { | |
_, err := mg.AddColumn("test", "test9 VARCHAR(255)") | |
return err | |
} | |
func (m *Migrate_100000000004) Down(mg *m.MigrationDriver) error { | |
_, err := mg.DropColumns("test", "test9") | |
return err | |
} | |
// Test change column | |
type Migrate_100000000005 struct{} | |
var ChangeColumnTest = &Migrate_100000000005{} | |
func (m *Migrate_100000000005) Revision() int64 { | |
return 100000000005 | |
} | |
func (m *Migrate_100000000005) Up(mg *m.MigrationDriver) error { | |
_, err := mg.ChangeColumn("test", "test2", "TEXT") | |
return err | |
} | |
func (m *Migrate_100000000005) Down(mg *m.MigrationDriver) error { | |
_, err := mg.ChangeColumn("test", "test2", "VARCHAR(255)") | |
return err | |
} | |
// Test drop columns form table | |
type Migrate_100000000006 struct{} | |
var DropColumnsFromTestTable = &Migrate_100000000006{} | |
func (m *Migrate_100000000006) Revision() int64 { | |
return 100000000006 | |
} | |
func (m *Migrate_100000000006) Up(mg *m.MigrationDriver) error { | |
_, err := mg.DropColumns("test", "test8", "test7") | |
return err | |
} | |
func (m *Migrate_100000000006) Down(mg *m.MigrationDriver) error { | |
if _, err := mg.AddColumn("test", "test8 VARCHAR(255)"); err != nil { | |
return err | |
} | |
_, err := mg.AddColumn("test", "test7 TEXT") | |
return err | |
} | |
// Test rename columns | |
type Migrate_100000000007 struct{} | |
var RenameColumnsTest = &Migrate_100000000007{} | |
func (m *Migrate_100000000007) Revision() int64 { | |
return 100000000007 | |
} | |
func (m *Migrate_100000000007) Up(mg *m.MigrationDriver) error { | |
_, err := mg.RenameColumns("test", map[string]string{ | |
"test2": "test_2", | |
"test3": "test_3", | |
}) | |
return err | |
} | |
func (m *Migrate_100000000007) Down(mg *m.MigrationDriver) error { | |
_, err := mg.RenameColumns("test", map[string]string{ | |
"test_2": "test2", | |
"test_3": "test3", | |
}) | |
return err | |
} | |
// Test add index | |
type Migrate_100000000008 struct{} | |
var AddAndDropIndexTest = &Migrate_100000000008{} | |
func (m *Migrate_100000000008) Revision() int64 { | |
return 100000000008 | |
} | |
func (m *Migrate_100000000008) Up(mg *m.MigrationDriver) error { | |
_, err := mg.AddIndex("test", []string{"test2"}, "unique") | |
return err | |
} | |
func (m *Migrate_100000000008) Down(mg *m.MigrationDriver) error { | |
_, err := mg.DropIndex("test", []string{"test2"}) | |
return err | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package migrationutil | |
import ( | |
"database/sql" | |
"os" | |
"testing" | |
"github.com/drone/drone/server/database/fixtures" | |
m "github.com/drone/drone/server/database/migrationutil" | |
_ "github.com/go-sql-driver/mysql" | |
_ "github.com/lib/pq" | |
_ "github.com/mattn/go-sqlite3" | |
) | |
var test_db *sql.DB | |
func TestCreateTable(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func TestRenameTable(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.Add(RenameTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate RenameTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000002) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func TestDropTable(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.Add(DropTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate DropTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000003) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func TestAddColumnToTable(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.Add(AddColumnToTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate AddColumnToTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000004) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func TestChangeColumn(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.Add(ChangeColumnTest).Migrate(); err != nil { | |
t.Errorf("Can not migrate ChangeColumnTest: %q", err) | |
} | |
currentRevisionEq(t, 100000000005) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func TestDropColumnFromTable(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.Add(DropColumnsFromTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate DropColumnsFromTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000006) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func TestRenameColumns(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.Add(RenameColumnsTest).Migrate(); err != nil { | |
t.Errorf("Can not migrate RenameColumnsTest: %q", err) | |
} | |
currentRevisionEq(t, 100000000007) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func TestAddAndDropIndex(t *testing.T) { | |
setup() | |
defer test_db.Close() | |
migrations := m.New(test_db) | |
if err := migrations.Add(CreateTestTable).Migrate(); err != nil { | |
t.Errorf("Can not migrate CreateTestTable: %q", err) | |
} | |
currentRevisionEq(t, 100000000001) | |
if err := migrations.Add(AddAndDropIndexTest).Migrate(); err != nil { | |
t.Errorf("Can not migrate AddAndDropIndexTest: %q", err) | |
} | |
currentRevisionEq(t, 100000000008) | |
if err := migrations.MigrateTo(0); err != nil { | |
t.Errorf("Can not downdrade migrations: %q", err) | |
} | |
checkDowngrade(t) | |
} | |
func setup() { | |
var err error | |
test_db, err = sql.Open(os.Getenv("DRONE_DRIVER"), os.Getenv("DRONE_DATASOURCE")) | |
if err != nil { | |
panic(err) | |
} | |
fixtures.CleanDatabase(test_db) | |
switch os.Getenv("DRONE_DRIVER") { | |
case "sqlite3": | |
m.Driver = m.SQLite | |
case "postgres": | |
// Recreate public schema before test, to prevent many errors. | |
test_db.Exec("DROP SCHEMA drone.public cascade") | |
test_db.Exec("CREATE SCHEMA drone.public") | |
m.Driver = m.PostgreSQL | |
case "mysql": | |
m.Driver = m.MySQL | |
} | |
} | |
func currentRevisionEq(t *testing.T, rev int) { | |
row := test_db.QueryRow("SELECT max(revision) FROM drone_migrations") | |
var result int | |
row.Scan(&result) | |
if result != rev { | |
t.Errorf("Want revision: %q, but got: %q", rev, result) | |
} | |
} | |
func checkDowngrade(t *testing.T) { | |
row := test_db.QueryRow("SELECT 0 FROM drone_migrations LIMIT 1") | |
var result int | |
row.Scan(&result) | |
if result != 0 { | |
t.Errorf("Want 0 migrations, but got: %q", result) | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment