migrations_test.go

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
}

migrationutil_test.go

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)
	}
}