-
Notifications
You must be signed in to change notification settings - Fork 1.3k
/
testing.go
155 lines (138 loc) · 3.91 KB
/
testing.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
// Package testing has the database tests.
// All database drivers must pass the Test function.
// This lives in it's own package so it stays a test dependency.
package testing
import (
"bytes"
"errors"
"fmt"
"io"
"testing"
"time"
"github.com/golang-migrate/migrate/v4/database"
)
// Test runs tests against database implementations.
func Test(t *testing.T, d database.Driver, migration []byte) {
if migration == nil {
t.Fatal("test must provide migration reader")
}
TestNilVersion(t, d) // test first
TestLockAndUnlock(t, d)
TestRun(t, d, bytes.NewReader(migration))
TestSetVersion(t, d) // also tests Version()
// Drop breaks the driver, so test it last.
TestDrop(t, d)
}
func TestNilVersion(t *testing.T, d database.Driver) {
v, _, err := d.Version()
if err != nil {
t.Fatal(err)
}
if v != database.NilVersion {
t.Fatalf("Version: expected version to be NilVersion (-1), got %v", v)
}
}
func TestLockAndUnlock(t *testing.T, d database.Driver) {
// add a timeout, in case there is a deadlock
done := make(chan struct{})
errs := make(chan error)
go func() {
timeout := time.After(15 * time.Second)
for {
select {
case <-done:
return
case <-timeout:
errs <- fmt.Errorf("Timeout after 15 seconds. Looks like a deadlock in Lock/UnLock.\n%#v", d)
return
}
}
}()
// run the locking test ...
go func() {
if err := d.Lock(); err != nil {
errs <- err
return
}
// try to acquire lock again
if err := d.Lock(); err == nil {
errs <- errors.New("lock: expected err not to be nil")
return
}
// unlock
if err := d.Unlock(); err != nil {
errs <- err
return
}
// try to lock
if err := d.Lock(); err != nil {
errs <- err
return
}
if err := d.Unlock(); err != nil {
errs <- err
return
}
// notify everyone
close(done)
}()
// wait for done or any error
for {
select {
case <-done:
return
case err := <-errs:
t.Fatal(err)
}
}
}
func TestRun(t *testing.T, d database.Driver, migration io.Reader) {
if migration == nil {
t.Fatal("migration can't be nil")
}
if err := d.Run(migration); err != nil {
t.Fatal(err)
}
}
func TestDrop(t *testing.T, d database.Driver) {
if err := d.Drop(); err != nil {
t.Fatal(err)
}
}
func TestSetVersion(t *testing.T, d database.Driver) {
// nolint:maligned
testCases := []struct {
name string
version int
dirty bool
expectedErr error
expectedReadErr error
expectedVersion int
expectedDirty bool
}{
{name: "set 1 dirty", version: 1, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: 1, expectedDirty: true},
{name: "re-set 1 dirty", version: 1, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: 1, expectedDirty: true},
{name: "set 2 clean", version: 2, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: 2, expectedDirty: false},
{name: "re-set 2 clean", version: 2, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: 2, expectedDirty: false},
{name: "last migration dirty", version: database.NilVersion, dirty: true, expectedErr: nil, expectedReadErr: nil, expectedVersion: database.NilVersion, expectedDirty: true},
{name: "last migration clean", version: database.NilVersion, dirty: false, expectedErr: nil, expectedReadErr: nil, expectedVersion: database.NilVersion, expectedDirty: false},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
err := d.SetVersion(tc.version, tc.dirty)
if err != tc.expectedErr {
t.Fatal("Got unexpected error:", err, "!=", tc.expectedErr)
}
v, dirty, readErr := d.Version()
if readErr != tc.expectedReadErr {
t.Fatal("Got unexpected error:", readErr, "!=", tc.expectedReadErr)
}
if v != tc.expectedVersion {
t.Error("Got unexpected version:", v, "!=", tc.expectedVersion)
}
if dirty != tc.expectedDirty {
t.Error("Got unexpected dirty value:", dirty, "!=", tc.dirty)
}
})
}
}