Skip to content

Commit 6f356d1

Browse files
Aeneas Rekkas (arekkas)arekkas
Aeneas Rekkas (arekkas)
authored and
arekkas
committed
all: migrate to dockertest v3 and resolve broken tests
1 parent 3d61a70 commit 6f356d1

File tree

5 files changed

+228
-302
lines changed

5 files changed

+228
-302
lines changed

‎client/manager_test.go‎

Lines changed: 23 additions & 95 deletions
Original file line numberDiff line numberDiff line change
@@ -4,19 +4,16 @@ import (
44
"net/http/httptest"
55
"net/url"
66
"testing"
7-
87
r "gopkg.in/dancannon/gorethink.v2"
9-
108
"log"
119
"os"
1210
"time"
1311

1412
"fmt"
15-
"github.com/jmoiron/sqlx"
1613
"github.com/julienschmidt/httprouter"
17-
"github.com/ory-am/dockertest"
1814
"github.com/ory-am/fosite"
1915
. "github.com/ory-am/hydra/client"
16+
_ "github.com/lib/pq"
2017
"github.com/ory-am/hydra/compose"
2118
"github.com/ory-am/hydra/herodot"
2219
"github.com/ory-am/hydra/pkg"
@@ -25,7 +22,8 @@ import (
2522
"github.com/stretchr/testify/assert"
2623
"github.com/stretchr/testify/require"
2724
"golang.org/x/net/context"
28-
"gopkg.in/redis.v5"
25+
"gopkg.in/ory-am/dockertest.v3"
26+
"github.com/ory-am/hydra/integration"
2927
)
3028

3129
var clientManagers = map[string]Storage{}
@@ -66,130 +64,60 @@ func init() {
6664
}
6765
}
6866

67+
var resources []*dockertest.Resource
68+
var pool *dockertest.Pool
6969
var rethinkManager *RethinkManager
70-
var containers = []dockertest.ContainerID{}
7170

7271
func TestMain(m *testing.M) {
73-
defer func() {
74-
for _, c := range containers {
75-
c.KillRemove()
76-
}
77-
}()
78-
7972
connectToPG()
8073
connectToRethinkDB()
8174
connectToMySQL()
8275
connectToRedis()
8376

84-
os.Exit(m.Run())
77+
s := m.Run()
78+
integration.KillAll()
79+
os.Exit(s)
8580
}
8681

8782
func connectToMySQL() {
88-
var db *sqlx.DB
89-
c, err := dockertest.ConnectToMySQL(15, time.Second, func(url string) bool {
90-
var err error
91-
db, err = sqlx.Open("mysql", url)
92-
if err != nil {
93-
log.Printf("Got error in mysql connector: %s", err)
94-
return false
95-
}
96-
return db.Ping() == nil
97-
})
98-
99-
if err != nil {
100-
log.Fatalf("Could not connect to database: %s", err)
101-
}
102-
103-
containers = append(containers, c)
83+
var db = integration.ConnectToMySQL()
10484
s := &SQLManager{DB: db, Hasher: &fosite.BCrypt{WorkFactor: 4}}
105-
106-
if err = s.CreateSchemas(); err != nil {
85+
if err := s.CreateSchemas(); err != nil {
10786
log.Fatalf("Could not create postgres schema: %v", err)
10887
}
10988

11089
clientManagers["mysql"] = s
111-
containers = append(containers, c)
11290
}
11391

11492
func connectToPG() {
115-
var db *sqlx.DB
116-
c, err := dockertest.ConnectToPostgreSQL(15, time.Second, func(url string) bool {
117-
var err error
118-
db, err = sqlx.Open("postgres", url)
119-
if err != nil {
120-
log.Printf("Got error in postgres connector: %s", err)
121-
return false
122-
}
123-
return db.Ping() == nil
124-
})
125-
126-
if err != nil {
127-
log.Fatalf("Could not connect to database: %s", err)
128-
}
129-
130-
containers = append(containers, c)
93+
var db = integration.ConnectToPostgres()
13194
s := &SQLManager{DB: db, Hasher: &fosite.BCrypt{WorkFactor: 4}}
13295

133-
if err = s.CreateSchemas(); err != nil {
96+
if err := s.CreateSchemas(); err != nil {
13497
log.Fatalf("Could not create postgres schema: %v", err)
13598
}
13699

137100
clientManagers["postgres"] = s
138-
containers = append(containers, c)
139101
}
140102

141103
func connectToRethinkDB() {
142-
var session *r.Session
143-
var err error
144-
145-
c, err := dockertest.ConnectToRethinkDB(20, time.Second, func(url string) bool {
146-
if session, err = r.Connect(r.ConnectOpts{Address: url, Database: "hydra"}); err != nil {
147-
return false
148-
} else if _, err = r.DBCreate("hydra").RunWrite(session); err != nil {
149-
log.Printf("Database exists: %s", err)
150-
return false
151-
} else if _, err = r.TableCreate("hydra_clients").RunWrite(session); err != nil {
152-
log.Printf("Could not create table: %s", err)
153-
return false
154-
}
155-
156-
rethinkManager = &RethinkManager{
157-
Session: session,
158-
Table: r.Table("hydra_clients"),
159-
Clients: make(map[string]Client),
160-
Hasher: &fosite.BCrypt{
161-
// Low workfactor reduces test time
162-
WorkFactor: 4,
163-
},
164-
}
165-
rethinkManager.Watch(context.Background())
166-
time.Sleep(100 * time.Millisecond)
167-
return true
168-
})
169-
170-
if err != nil {
171-
log.Fatalf("Could not connect to database: %s", err)
104+
var session = integration.ConnectToRethinkDB("hydra", "hydra_clients")
105+
rethinkManager = &RethinkManager{
106+
Session: session,
107+
Table: r.Table("hydra_clients"),
108+
Clients: make(map[string]Client),
109+
Hasher: &fosite.BCrypt{
110+
// Low workfactor reduces test time
111+
WorkFactor: 4,
112+
},
172113
}
173114

174-
containers = append(containers, c)
115+
rethinkManager.Watch(context.Background())
175116
clientManagers["rethink"] = rethinkManager
176117
}
177118

178119
func connectToRedis() {
179-
var db *redis.Client
180-
c, err := dockertest.ConnectToRedis(15, time.Second, func(url string) bool {
181-
db = redis.NewClient(&redis.Options{
182-
Addr: url,
183-
})
184-
185-
return db.Ping().Err() == nil
186-
})
187-
188-
if err != nil {
189-
log.Fatalf("Could not connect to database: %s", err)
190-
}
191-
192-
containers = append(containers, c)
120+
var db = integration.ConnectToRedis()
193121
clientManagers["redis"] = &RedisManager{
194122
DB: db,
195123
Hasher: &fosite.BCrypt{WorkFactor: 4},

‎integration/docker.go‎

Lines changed: 146 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,146 @@
1+
package integration
2+
3+
import (
4+
r "gopkg.in/dancannon/gorethink.v2"
5+
"log"
6+
"time"
7+
8+
"fmt"
9+
"github.com/jmoiron/sqlx"
10+
_ "github.com/lib/pq"
11+
_ "github.com/go-sql-driver/mysql"
12+
"gopkg.in/ory-am/dockertest.v3"
13+
"gopkg.in/redis.v5"
14+
)
15+
16+
var resources []*dockertest.Resource
17+
var pool *dockertest.Pool
18+
19+
func KillAll() {
20+
for _, resource := range resources {
21+
pool.Purge(resource)
22+
}
23+
resources = []*dockertest.Resource{}
24+
}
25+
26+
func ConnectToMySQL() *sqlx.DB {
27+
var db *sqlx.DB
28+
var err error
29+
pool, err = dockertest.NewPool("")
30+
pool.MaxWait = time.Minute * 2
31+
if err != nil {
32+
log.Fatalf("Could not connect to docker: %s", err)
33+
}
34+
35+
resource, err := pool.Run("mysql", "5.7", []string{"MYSQL_ROOT_PASSWORD=secret"})
36+
if err != nil {
37+
log.Fatalf("Could not start resource: %s", err)
38+
}
39+
40+
if err = pool.Retry(func() error {
41+
var err error
42+
db, err = sqlx.Open("mysql", fmt.Sprintf("root:secret@(localhost:%s)/mysql?parseTime=true", resource.GetPort("3306/tcp")))
43+
if err != nil {
44+
return err
45+
}
46+
return db.Ping()
47+
}); err != nil {
48+
log.Fatalf("Could not connect to docker: %s", err)
49+
}
50+
51+
resources = append(resources, resource)
52+
return db
53+
}
54+
55+
func ConnectToPostgres() *sqlx.DB {
56+
var db *sqlx.DB
57+
var err error
58+
pool, err = dockertest.NewPool("")
59+
if err != nil {
60+
log.Fatalf("Could not connect to docker: %s", err)
61+
}
62+
63+
resource, err := pool.Run("postgres", "9.6", []string{"POSTGRES_PASSWORD=secret", "POSTGRES_DB=hydra"})
64+
if err != nil {
65+
log.Fatalf("Could not start resource: %s", err)
66+
}
67+
68+
if err = pool.Retry(func() error {
69+
var err error
70+
db, err = sqlx.Open("postgres", fmt.Sprintf("postgres://postgres:secret@localhost:%s/hydra?sslmode=disable", resource.GetPort("5432/tcp")))
71+
if err != nil {
72+
return err
73+
}
74+
return db.Ping()
75+
}); err != nil {
76+
log.Fatalf("Could not connect to docker: %s", err)
77+
}
78+
79+
resources = append(resources, resource)
80+
return db
81+
}
82+
83+
func ConnectToRethinkDB(database string, tables ...string) *r.Session {
84+
var session *r.Session
85+
var err error
86+
pool, err = dockertest.NewPool("")
87+
if err != nil {
88+
log.Fatalf("Could not connect to docker: %s", err)
89+
}
90+
91+
resource, err := pool.Run("rethinkdb", "2.3", []string{""})
92+
if err != nil {
93+
log.Fatalf("Could not start resource: %s", err)
94+
}
95+
96+
if err = pool.Retry(func() error {
97+
if session, err = r.Connect(r.ConnectOpts{Address: fmt.Sprintf("localhost:%s", resource.GetPort("28015/tcp")), Database: "hydra"}); err != nil {
98+
return err
99+
} else if _, err = r.DBCreate(database).RunWrite(session); err != nil {
100+
log.Printf("Database exists: %s", err)
101+
return err
102+
}
103+
104+
for _, table := range tables {
105+
if _, err = r.TableCreate(table).RunWrite(session); err != nil {
106+
log.Printf("Could not create table: %s", err)
107+
return err
108+
}
109+
}
110+
111+
time.Sleep(100 * time.Millisecond)
112+
return nil
113+
}); err != nil {
114+
log.Fatalf("Could not connect to docker: %s", err)
115+
}
116+
117+
resources = append(resources, resource)
118+
return session
119+
}
120+
121+
func ConnectToRedis() *redis.Client {
122+
var db *redis.Client
123+
var err error
124+
pool, err = dockertest.NewPool("")
125+
if err != nil {
126+
log.Fatalf("Could not connect to docker: %s", err)
127+
}
128+
129+
resource, err := pool.Run("redis", "3.2", nil)
130+
if err != nil {
131+
log.Fatalf("Could not start resource: %s", err)
132+
}
133+
134+
if err = pool.Retry(func() error {
135+
db = redis.NewClient(&redis.Options{
136+
Addr: fmt.Sprintf("localhost:%s", resource.GetPort("6379/tcp")),
137+
})
138+
139+
return db.Ping().Err()
140+
}); err != nil {
141+
log.Fatalf("Could not connect to docker: %s", err)
142+
}
143+
144+
resources = append(resources, resource)
145+
return db
146+
}

0 commit comments

Comments
 (0)