github.com/qdentity/migrate@v3.3.0+incompatible/database/postgres/postgres_test.go (about)

     1  package postgres
     2  
     3  // error codes https://github.com/lib/pq/blob/master/error.go
     4  
     5  import (
     6  	"bytes"
     7  	"database/sql"
     8  	sqldriver "database/sql/driver"
     9  	"fmt"
    10  	"io"
    11  	"testing"
    12  
    13  	"context"
    14  	dt "github.com/golang-migrate/migrate/database/testing"
    15  	mt "github.com/golang-migrate/migrate/testing"
    16  	// "github.com/lib/pq"
    17  )
    18  
    19  var versions = []mt.Version{
    20  	{Image: "postgres:9.6"},
    21  	{Image: "postgres:9.5"},
    22  	{Image: "postgres:9.4"},
    23  	{Image: "postgres:9.3"},
    24  	{Image: "postgres:9.2"},
    25  }
    26  
    27  func isReady(i mt.Instance) bool {
    28  	db, err := sql.Open("postgres", fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port()))
    29  	if err != nil {
    30  		return false
    31  	}
    32  	defer db.Close()
    33  	if err = db.Ping(); err != nil {
    34  		switch err {
    35  		case sqldriver.ErrBadConn, io.EOF:
    36  			return false
    37  		default:
    38  			fmt.Println(err)
    39  		}
    40  		return false
    41  	}
    42  
    43  	return true
    44  }
    45  
    46  func Test(t *testing.T) {
    47  	mt.ParallelTest(t, versions, isReady,
    48  		func(t *testing.T, i mt.Instance) {
    49  			p := &Postgres{}
    50  			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port())
    51  			d, err := p.Open(addr)
    52  			if err != nil {
    53  				t.Fatalf("%v", err)
    54  			}
    55  			defer d.Close()
    56  			dt.Test(t, d, []byte("SELECT 1"))
    57  		})
    58  }
    59  
    60  func TestMultiStatement(t *testing.T) {
    61  	mt.ParallelTest(t, versions, isReady,
    62  		func(t *testing.T, i mt.Instance) {
    63  			p := &Postgres{}
    64  			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port())
    65  			d, err := p.Open(addr)
    66  			if err != nil {
    67  				t.Fatalf("%v", err)
    68  			}
    69  			defer d.Close()
    70  			if err := d.Run(bytes.NewReader([]byte("CREATE TABLE foo (foo text); CREATE TABLE bar (bar text);"))); err != nil {
    71  				t.Fatalf("expected err to be nil, got %v", err)
    72  			}
    73  
    74  			// make sure second table exists
    75  			var exists bool
    76  			if err := d.(*Postgres).conn.QueryRowContext(context.Background(), "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'bar' AND table_schema = (SELECT current_schema()))").Scan(&exists); err != nil {
    77  				t.Fatal(err)
    78  			}
    79  			if !exists {
    80  				t.Fatalf("expected table bar to exist")
    81  			}
    82  		})
    83  }
    84  
    85  func TestFilterCustomQuery(t *testing.T) {
    86  	mt.ParallelTest(t, versions, isReady,
    87  		func(t *testing.T, i mt.Instance) {
    88  			p := &Postgres{}
    89  			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable&x-custom=foobar", i.Host(), i.Port())
    90  			d, err := p.Open(addr)
    91  			if err != nil {
    92  				t.Fatalf("%v", err)
    93  			}
    94  			defer d.Close()
    95  		})
    96  }
    97  
    98  func TestWithSchema(t *testing.T) {
    99  	mt.ParallelTest(t, versions, isReady,
   100  		func(t *testing.T, i mt.Instance) {
   101  			p := &Postgres{}
   102  			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port())
   103  			d, err := p.Open(addr)
   104  			if err != nil {
   105  				t.Fatalf("%v", err)
   106  			}
   107  			defer d.Close()
   108  
   109  			// create foobar schema
   110  			if err := d.Run(bytes.NewReader([]byte("CREATE SCHEMA foobar AUTHORIZATION postgres"))); err != nil {
   111  				t.Fatal(err)
   112  			}
   113  			if err := d.SetVersion(1, false); err != nil {
   114  				t.Fatal(err)
   115  			}
   116  
   117  			// re-connect using that schema
   118  			d2, err := p.Open(fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable&search_path=foobar", i.Host(), i.Port()))
   119  			if err != nil {
   120  				t.Fatalf("%v", err)
   121  			}
   122  			defer d2.Close()
   123  
   124  			version, _, err := d2.Version()
   125  			if err != nil {
   126  				t.Fatal(err)
   127  			}
   128  			if version != -1 {
   129  				t.Fatal("expected NilVersion")
   130  			}
   131  
   132  			// now update version and compare
   133  			if err := d2.SetVersion(2, false); err != nil {
   134  				t.Fatal(err)
   135  			}
   136  			version, _, err = d2.Version()
   137  			if err != nil {
   138  				t.Fatal(err)
   139  			}
   140  			if version != 2 {
   141  				t.Fatal("expected version 2")
   142  			}
   143  
   144  			// meanwhile, the public schema still has the other version
   145  			version, _, err = d.Version()
   146  			if err != nil {
   147  				t.Fatal(err)
   148  			}
   149  			if version != 1 {
   150  				t.Fatal("expected version 2")
   151  			}
   152  		})
   153  }
   154  
   155  func TestWithInstance(t *testing.T) {
   156  
   157  }
   158  
   159  func TestPostgres_Lock(t *testing.T) {
   160  	mt.ParallelTest(t, versions, isReady,
   161  		func(t *testing.T, i mt.Instance) {
   162  			p := &Postgres{}
   163  			addr := fmt.Sprintf("postgres://postgres@%v:%v/postgres?sslmode=disable", i.Host(), i.Port())
   164  			d, err := p.Open(addr)
   165  			if err != nil {
   166  				t.Fatalf("%v", err)
   167  			}
   168  
   169  			dt.Test(t, d, []byte("SELECT 1"))
   170  
   171  			ps := d.(*Postgres)
   172  
   173  			err = ps.Lock()
   174  			if err != nil {
   175  				t.Fatal(err)
   176  			}
   177  
   178  			err = ps.Unlock()
   179  			if err != nil {
   180  				t.Fatal(err)
   181  			}
   182  
   183  			err = ps.Lock()
   184  			if err != nil {
   185  				t.Fatal(err)
   186  			}
   187  
   188  			err = ps.Unlock()
   189  			if err != nil {
   190  				t.Fatal(err)
   191  			}
   192  		})
   193  }