-
Notifications
You must be signed in to change notification settings - Fork 72
/
Copy pathcockroachdb_test.go
173 lines (149 loc) · 4.21 KB
/
cockroachdb_test.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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
package cockroachdb_test
import (
"database/sql"
"log"
"testing"
"github.com/philippgille/gokv/cockroachdb"
"github.com/philippgille/gokv/encoding"
"github.com/philippgille/gokv/test"
)
// TestClient tests if reading from, writing to and deleting from the store works properly.
// A struct is used as value. See TestTypes() for a test that is simpler but tests all types.
func TestClient(t *testing.T) {
// Test with JSON
t.Run("JSON", func(t *testing.T) {
client := createClient(t, encoding.JSON)
defer client.Close()
test.TestStore(client, t)
})
// Test with gob
t.Run("gob", func(t *testing.T) {
client := createClient(t, encoding.Gob)
defer client.Close()
test.TestStore(client, t)
})
}
// TestTypes tests if setting and getting values works with all Go types.
func TestTypes(t *testing.T) {
// Test with JSON
t.Run("JSON", func(t *testing.T) {
client := createClient(t, encoding.JSON)
defer client.Close()
test.TestTypes(client, t)
})
// Test with gob
t.Run("gob", func(t *testing.T) {
client := createClient(t, encoding.Gob)
defer client.Close()
test.TestTypes(client, t)
})
}
// TestClientConcurrent launches a bunch of goroutines that concurrently work with the CockroachDB client.
func TestClientConcurrent(t *testing.T) {
client := createClient(t, encoding.JSON)
defer client.Close()
goroutineCount := 1000
test.TestConcurrentInteractions(t, goroutineCount, client)
}
// TestErrors tests some error cases.
func TestErrors(t *testing.T) {
// Test empty key
client := createClient(t, encoding.JSON)
defer client.Close()
err := client.Set("", "bar")
if err == nil {
t.Error("Expected an error")
}
_, err = client.Get("", new(string))
if err == nil {
t.Error("Expected an error")
}
err = client.Delete("")
if err == nil {
t.Error("Expected an error")
}
}
// TestNil tests the behaviour when passing nil or pointers to nil values to some methods.
func TestNil(t *testing.T) {
// Test setting nil
t.Run("set nil with JSON marshalling", func(t *testing.T) {
client := createClient(t, encoding.JSON)
defer client.Close()
err := client.Set("foo", nil)
if err == nil {
t.Error("Expected an error")
}
})
t.Run("set nil with Gob marshalling", func(t *testing.T) {
client := createClient(t, encoding.Gob)
defer client.Close()
err := client.Set("foo", nil)
if err == nil {
t.Error("Expected an error")
}
})
// Test passing nil or pointer to nil value for retrieval
createTest := func(codec encoding.Codec) func(t *testing.T) {
return func(t *testing.T) {
client := createClient(t, codec)
defer client.Close()
// Prep
err := client.Set("foo", test.Foo{Bar: "baz"})
if err != nil {
t.Error(err)
}
_, err = client.Get("foo", nil) // actually nil
if err == nil {
t.Error("An error was expected")
}
var i any // actually nil
_, err = client.Get("foo", i)
if err == nil {
t.Error("An error was expected")
}
var valPtr *test.Foo // nil value
_, err = client.Get("foo", valPtr)
if err == nil {
t.Error("An error was expected")
}
}
}
t.Run("get with nil / nil value parameter", createTest(encoding.JSON))
t.Run("get with nil / nil value parameter", createTest(encoding.Gob))
}
// TestClose tests if the close method returns any errors.
func TestClose(t *testing.T) {
client := createClient(t, encoding.JSON)
err := client.Close()
if err != nil {
t.Error(err)
}
}
// checkConnection returns true if a connection could be made, false otherwise.
func checkConnection() bool {
db, err := sql.Open("postgres", "postgres://root@localhost:26257/?sslmode=disable")
if err != nil {
log.Printf("An error occurred during testing the connection to the server: %v\n", err)
return false
}
defer db.Close()
err = db.Ping()
if err != nil {
log.Printf("An error occurred during testing the connection to the server: %v\n", err)
return false
}
return true
}
func createClient(t *testing.T, codec encoding.Codec) cockroachdb.Client {
options := cockroachdb.Options{
Codec: codec,
// Higher values seem to lead to issues on Travis CI when using MySQL,
// so let's just use the same value here.
MaxOpenConnections: 25,
}
client, err := cockroachdb.NewClient(options)
if err != nil {
t.Fatal(err)
}
return client
}