sqlboiler/templates_test/main_test/postgres_main.tpl

276 lines
7.8 KiB
Smarty
Raw Normal View History

type PostgresCfg struct {
2016-07-12 00:17:49 +02:00
User string `toml:"user"`
Pass string `toml:"pass"`
Host string `toml:"host"`
Port int `toml:"port"`
DBName string `toml:"dbname"`
SSLMode string `toml:"sslmode"`
}
type Config struct {
Postgres PostgresCfg `toml:"postgres"`
}
2016-07-15 07:44:52 +02:00
var flagDebugMode = flag.Bool("test.sqldebug", false, "Turns on debug mode for SQL statements")
2016-04-09 01:45:44 +02:00
func TestMain(m *testing.M) {
2016-06-27 02:44:01 +02:00
rand.Seed(time.Now().UnixNano())
// Set DebugMode so we can see generated sql statements
2016-08-04 06:37:50 +02:00
flag.Parse()
2016-07-15 07:44:52 +02:00
boil.DebugMode = *flagDebugMode
2016-07-15 17:21:09 +02:00
var err error
2016-06-27 02:44:01 +02:00
if err = setup(); err != nil {
fmt.Println("Unable to execute setup:", err)
os.Exit(-2)
2016-04-09 01:45:44 +02:00
}
2016-06-27 02:44:01 +02:00
var code int
if err = disableTriggers(); err != nil {
fmt.Println("Unable to disable triggers:", err)
} else {
boil.SetDB(dbConn)
code = m.Run()
}
2016-06-27 02:44:01 +02:00
if err = teardown(); err != nil {
fmt.Println("Unable to execute teardown:", err)
os.Exit(-3)
2016-04-09 01:45:44 +02:00
}
os.Exit(code)
}
// disableTriggers is used to disable foreign key constraints for every table.
// If this is not used we cannot test inserts due to foreign key constraint errors.
func disableTriggers() error {
var stmts []string
{{range .Tables}}
stmts = append(stmts, `ALTER TABLE {{.Name}} DISABLE TRIGGER ALL;`)
{{- end}}
if len(stmts) == 0 {
return nil
2016-04-09 01:45:44 +02:00
}
var err error
for _, s := range stmts {
_, err = dbConn.Exec(s)
if err != nil {
return err
}
}
return nil
}
// teardown executes cleanup tasks when the tests finish running
func teardown() error {
err := dropTestDB()
return err
}
// dropTestDB switches its connection to the template1 database temporarily
// so that it can drop the test database without causing "in use" conflicts.
// The template1 database should be present on all default postgres installations.
func dropTestDB() error {
var err error
if dbConn != nil {
if err = dbConn.Close(); err != nil {
return err
}
}
2016-07-12 00:17:49 +02:00
dbConn, err = DBConnect(testCfg.Postgres.User, testCfg.Postgres.Pass, "template1", testCfg.Postgres.Host, testCfg.Postgres.Port, testCfg.Postgres.SSLMode)
if err != nil {
2016-04-09 01:45:44 +02:00
return err
}
_, err = dbConn.Exec(fmt.Sprintf(`DROP DATABASE IF EXISTS %s;`, testCfg.Postgres.DBName))
2016-04-09 01:45:44 +02:00
if err != nil {
return err
}
2016-04-09 01:45:44 +02:00
return dbConn.Close()
}
2016-04-09 01:45:44 +02:00
// DBConnect connects to a database and returns the handle.
2016-07-12 00:17:49 +02:00
func DBConnect(user, pass, dbname, host string, port int, sslmode string) (*sql.DB, error) {
2016-08-01 06:24:33 +02:00
connStr := drivers.BuildQueryString(user, pass, dbname, host, port, sslmode)
2016-04-09 01:45:44 +02:00
return sql.Open("postgres", connStr)
}
2016-04-09 01:45:44 +02:00
// setup dumps the database schema and imports it into a temporary randomly
// generated test database so that tests can be run against it using the
// generated sqlboiler ORM package.
func setup() error {
var err error
// Initialize Viper and load the config file
err = InitViper()
if err != nil {
return fmt.Errorf("Unable to load config file: %s", err)
}
viper.SetDefault("postgres.sslmode", "require")
viper.SetDefault("postgres.port", "5432")
2016-07-12 00:17:49 +02:00
2016-04-09 01:45:44 +02:00
// Create a randomized test configuration object.
testCfg.Postgres.Host = viper.GetString("postgres.host")
testCfg.Postgres.Port = viper.GetInt("postgres.port")
testCfg.Postgres.User = viper.GetString("postgres.user")
testCfg.Postgres.Pass = viper.GetString("postgres.pass")
testCfg.Postgres.DBName = getDBNameHash(viper.GetString("postgres.dbname"))
2016-07-12 00:17:49 +02:00
testCfg.Postgres.SSLMode = viper.GetString("postgres.sslmode")
// Set the default SSLMode value
if testCfg.Postgres.SSLMode == "" {
viper.Set("postgres.sslmode", "require")
testCfg.Postgres.SSLMode = viper.GetString("postgres.sslmode")
}
err = vala.BeginValidation().Validate(
vala.StringNotEmpty(testCfg.Postgres.User, "postgres.user"),
vala.StringNotEmpty(testCfg.Postgres.Host, "postgres.host"),
vala.Not(vala.Equals(testCfg.Postgres.Port, 0, "postgres.port")),
vala.StringNotEmpty(testCfg.Postgres.DBName, "postgres.dbname"),
2016-07-12 00:17:49 +02:00
vala.StringNotEmpty(testCfg.Postgres.SSLMode, "postgres.sslmode"),
).Check()
if err != nil {
return fmt.Errorf("Unable to load testCfg: %s", err.Error())
}
err = dropTestDB()
if err != nil {
fmt.Printf("%#v\n", err)
return err
}
2016-04-09 01:45:44 +02:00
fhSchema, err := ioutil.TempFile(os.TempDir(), "sqlboilerschema")
if err != nil {
return fmt.Errorf("Unable to create sqlboiler schema tmp file: %s", err)
}
defer os.Remove(fhSchema.Name())
passDir, err := ioutil.TempDir(os.TempDir(), "sqlboiler")
if err != nil {
return fmt.Errorf("Unable to create sqlboiler tmp dir for postgres pw file: %s", err)
}
defer os.RemoveAll(passDir)
// Write the postgres user password to a tmp file for pg_dump
2016-08-01 06:24:33 +02:00
pwBytes := []byte(fmt.Sprintf("%s:%d:%s:%s",
viper.GetString("postgres.host"),
viper.GetInt("postgres.port"),
viper.GetString("postgres.dbname"),
viper.GetString("postgres.user"),
2016-04-09 01:45:44 +02:00
))
2016-08-01 06:24:33 +02:00
if pw := viper.GetString("postgres.pass"); len(pw) > 0 {
pwBytes = []byte(fmt.Sprintf("%s:%s", pwBytes, pw))
}
passFilePath := filepath.Join(passDir, "pwfile")
err = ioutil.WriteFile(passFilePath, pwBytes, 0600)
if err != nil {
return fmt.Errorf("Unable to create pwfile in passDir: %s", err)
}
2016-04-09 01:45:44 +02:00
// The params for the pg_dump command to dump the database schema
params := []string{
fmt.Sprintf(`--host=%s`, viper.GetString("postgres.host")),
fmt.Sprintf(`--port=%d`, viper.GetInt("postgres.port")),
fmt.Sprintf(`--username=%s`, viper.GetString("postgres.user")),
"--schema-only",
viper.GetString("postgres.dbname"),
}
2016-04-09 01:45:44 +02:00
// Dump the database schema into the sqlboilerschema tmp file
errBuf := bytes.Buffer{}
cmd := exec.Command("pg_dump", params...)
cmd.Stderr = &errBuf
cmd.Stdout = fhSchema
cmd.Env = append(os.Environ(), fmt.Sprintf(`PGPASSFILE=%s`, passFilePath))
if err := cmd.Run(); err != nil {
fmt.Printf("pg_dump exec failed: %s\n\n%s\n", err, errBuf.String())
2016-06-27 02:44:01 +02:00
return err
}
dbConn, err = DBConnect(
viper.GetString("postgres.user"),
viper.GetString("postgres.pass"),
viper.GetString("postgres.dbname"),
viper.GetString("postgres.host"),
viper.GetInt("postgres.port"),
2016-07-12 00:17:49 +02:00
viper.GetString("postgres.sslmode"),
)
2016-04-09 01:45:44 +02:00
if err != nil {
return err
}
// Create the randomly generated database
_, err = dbConn.Exec(fmt.Sprintf(`CREATE DATABASE %s WITH ENCODING 'UTF8'`, testCfg.Postgres.DBName))
if err != nil {
return err
}
// Close the old connection so we can reconnect to the test database
2016-04-09 01:45:44 +02:00
if err = dbConn.Close(); err != nil {
return err
}
// Connect to the generated test db
2016-07-12 00:17:49 +02:00
dbConn, err = DBConnect(testCfg.Postgres.User, testCfg.Postgres.Pass, testCfg.Postgres.DBName, testCfg.Postgres.Host, testCfg.Postgres.Port, testCfg.Postgres.SSLMode)
2016-04-09 01:45:44 +02:00
if err != nil {
return err
}
// Write the test config credentials to a tmp file for pg_dump
2016-08-01 06:24:33 +02:00
testPwBytes := []byte(fmt.Sprintf("%s:%d:%s:%s",
2016-04-09 01:45:44 +02:00
testCfg.Postgres.Host,
testCfg.Postgres.Port,
testCfg.Postgres.DBName,
testCfg.Postgres.User,
))
2016-08-01 06:24:33 +02:00
if len(testCfg.Postgres.Pass) > 0 {
testPwBytes = []byte(fmt.Sprintf("%s:%s", testPwBytes, testCfg.Postgres.Pass))
}
2016-04-09 01:45:44 +02:00
testPassFilePath := passDir + "/testpwfile"
err = ioutil.WriteFile(testPassFilePath, testPwBytes, 0600)
if err != nil {
return fmt.Errorf("Unable to create testpwfile in passDir: %s", err)
}
// The params for the psql schema import command
params = []string{
fmt.Sprintf(`--dbname=%s`, testCfg.Postgres.DBName),
fmt.Sprintf(`--host=%s`, testCfg.Postgres.Host),
fmt.Sprintf(`--port=%d`, testCfg.Postgres.Port),
fmt.Sprintf(`--username=%s`, testCfg.Postgres.User),
fmt.Sprintf(`--file=%s`, fhSchema.Name()),
}
// Import the database schema into the generated database.
// It is now ready to be used by the generated ORM package for testing.
outBuf := bytes.Buffer{}
cmd = exec.Command("psql", params...)
cmd.Stderr = &errBuf
cmd.Stdout = &outBuf
cmd.Env = append(os.Environ(), fmt.Sprintf(`PGPASSFILE=%s`, testPassFilePath))
if err = cmd.Run(); err != nil {
fmt.Printf("psql schema import exec failed: %s\n\n%s\n", err, errBuf.String())
}
return nil
}