Debian Codegraph @

bolt_store_test.go

raw
1 package raftboltdb
2
3 import (
4 "bytes"
5 "io/ioutil"
6 "os"
7 "reflect"
8 "testing"
9 "time"
10
11 "github.com/boltdb/bolt"
12 "github.com/hashicorp/raft"
13 )
14
15 func testBoltStore(t testing.TB) *BoltStore {
16 fh, err := ioutil.TempFile("", "bolt")
17 if err != nil {
18 t.Fatalf("err: %s", err)
19 }
20 os.Remove(fh.Name())
21
22 // Successfully creates and returns a store
23 store, err := NewBoltStore(fh.Name())
24 if err != nil {
25 t.Fatalf("err: %s", err)
26 }
27
28 return store
29 }
30
31 func testRaftLog(idx uint64, data string) *raft.Log {
32 return &raft.Log{
33 Data: []byte(data),
34 Index: idx,
35 }
36 }
37
38 func TestBoltStore_Implements(t *testing.T) {
39 var store interface{} = &BoltStore{}
40 if _, ok := store.(raft.StableStore); !ok {
41 t.Fatalf("BoltStore does not implement raft.StableStore")
42 }
43 if _, ok := store.(raft.LogStore); !ok {
44 t.Fatalf("BoltStore does not implement raft.LogStore")
45 }
46 }
47
48 func TestBoltOptionsTimeout(t *testing.T) {
49 fh, err := ioutil.TempFile("", "bolt")
50 if err != nil {
51 t.Fatalf("err: %s", err)
52 }
53 os.Remove(fh.Name())
54 defer os.Remove(fh.Name())
55 options := Options{
56 Path: fh.Name(),
57 BoltOptions: &bolt.Options{
58 Timeout: time.Second / 10,
59 },
60 }
61 store, err := New(options)
62 if err != nil {
63 t.Fatalf("err: %v", err)
64 }
65 defer store.Close()
66 // trying to open it again should timeout
67 doneCh := make(chan error, 1)
68 go func() {
69 _, err := New(options)
70 doneCh <- err
71 }()
72 select {
73 case err := <-doneCh:
74 if err == nil || err.Error() != "timeout" {
75 t.Errorf("Expected timeout error but got %v", err)
76 }
77 case <-time.After(5 * time.Second):
78 t.Errorf("Gave up waiting for timeout response")
79 }
80 }
81
82 func TestBoltOptionsReadOnly(t *testing.T) {
83 fh, err := ioutil.TempFile("", "bolt")
84 if err != nil {
85 t.Fatalf("err: %s", err)
86 }
87 defer os.Remove(fh.Name())
88 store, err := NewBoltStore(fh.Name())
89 if err != nil {
90 t.Fatalf("err: %s", err)
91 }
92 // Create the log
93 log := &raft.Log{
94 Data: []byte("log1"),
95 Index: 1,
96 }
97 // Attempt to store the log
98 if err := store.StoreLog(log); err != nil {
99 t.Fatalf("err: %s", err)
100 }
101
102 store.Close()
103 options := Options{
104 Path: fh.Name(),
105 BoltOptions: &bolt.Options{
106 Timeout: time.Second / 10,
107 ReadOnly: true,
108 },
109 }
110 roStore, err := New(options)
111 if err != nil {
112 t.Fatalf("err: %s", err)
113 }
114 defer roStore.Close()
115 result := new(raft.Log)
116 if err := roStore.GetLog(1, result); err != nil {
117 t.Fatalf("err: %s", err)
118 }
119
120 // Ensure the log comes back the same
121 if !reflect.DeepEqual(log, result) {
122 t.Errorf("bad: %v", result)
123 }
124 // Attempt to store the log, should fail on a read-only store
125 err = roStore.StoreLog(log)
126 if err != bolt.ErrDatabaseReadOnly {
127 t.Errorf("expecting error %v, but got %v", bolt.ErrDatabaseReadOnly, err)
128 }
129 }
130
131 func TestNewBoltStore(t *testing.T) {
132 fh, err := ioutil.TempFile("", "bolt")
133 if err != nil {
134 t.Fatalf("err: %s", err)
135 }
136 os.Remove(fh.Name())
137 defer os.Remove(fh.Name())
138
139 // Successfully creates and returns a store
140 store, err := NewBoltStore(fh.Name())
141 if err != nil {
142 t.Fatalf("err: %s", err)
143 }
144
145 // Ensure the file was created
146 if store.path != fh.Name() {
147 t.Fatalf("unexpected file path %q", store.path)
148 }
149 if _, err := os.Stat(fh.Name()); err != nil {
150 t.Fatalf("err: %s", err)
151 }
152
153 // Close the store so we can open again
154 if err := store.Close(); err != nil {
155 t.Fatalf("err: %s", err)
156 }
157
158 // Ensure our tables were created
159 db, err := bolt.Open(fh.Name(), dbFileMode, nil)
160 if err != nil {
161 t.Fatalf("err: %s", err)
162 }
163 tx, err := db.Begin(true)
164 if err != nil {
165 t.Fatalf("err: %s", err)
166 }
167 if _, err := tx.CreateBucket([]byte(dbLogs)); err != bolt.ErrBucketExists {
168 t.Fatalf("bad: %v", err)
169 }
170 if _, err := tx.CreateBucket([]byte(dbConf)); err != bolt.ErrBucketExists {
171 t.Fatalf("bad: %v", err)
172 }
173 }
174
175 func TestBoltStore_FirstIndex(t *testing.T) {
176 store := testBoltStore(t)
177 defer store.Close()
178 defer os.Remove(store.path)
179
180 // Should get 0 index on empty log
181 idx, err := store.FirstIndex()
182 if err != nil {
183 t.Fatalf("err: %s", err)
184 }
185 if idx != 0 {
186 t.Fatalf("bad: %v", idx)
187 }
188
189 // Set a mock raft log
190 logs := []*raft.Log{
191 testRaftLog(1, "log1"),
192 testRaftLog(2, "log2"),
193 testRaftLog(3, "log3"),
194 }
195 if err := store.StoreLogs(logs); err != nil {
196 t.Fatalf("bad: %s", err)
197 }
198
199 // Fetch the first Raft index
200 idx, err = store.FirstIndex()
201 if err != nil {
202 t.Fatalf("err: %s", err)
203 }
204 if idx != 1 {
205 t.Fatalf("bad: %d", idx)
206 }
207 }
208
209 func TestBoltStore_LastIndex(t *testing.T) {
210 store := testBoltStore(t)
211 defer store.Close()
212 defer os.Remove(store.path)
213
214 // Should get 0 index on empty log
215 idx, err := store.LastIndex()
216 if err != nil {
217 t.Fatalf("err: %s", err)
218 }
219 if idx != 0 {
220 t.Fatalf("bad: %v", idx)
221 }
222
223 // Set a mock raft log
224 logs := []*raft.Log{
225 testRaftLog(1, "log1"),
226 testRaftLog(2, "log2"),
227 testRaftLog(3, "log3"),
228 }
229 if err := store.StoreLogs(logs); err != nil {
230 t.Fatalf("bad: %s", err)
231 }
232
233 // Fetch the last Raft index
234 idx, err = store.LastIndex()
235 if err != nil {
236 t.Fatalf("err: %s", err)
237 }
238 if idx != 3 {
239 t.Fatalf("bad: %d", idx)
240 }
241 }
242
243 func TestBoltStore_GetLog(t *testing.T) {
244 store := testBoltStore(t)
245 defer store.Close()
246 defer os.Remove(store.path)
247
248 log := new(raft.Log)
249
250 // Should return an error on non-existent log
251 if err := store.GetLog(1, log); err != raft.ErrLogNotFound {
252 t.Fatalf("expected raft log not found error, got: %v", err)
253 }
254
255 // Set a mock raft log
256 logs := []*raft.Log{
257 testRaftLog(1, "log1"),
258 testRaftLog(2, "log2"),
259 testRaftLog(3, "log3"),
260 }
261 if err := store.StoreLogs(logs); err != nil {
262 t.Fatalf("bad: %s", err)
263 }
264
265 // Should return the proper log
266 if err := store.GetLog(2, log); err != nil {
267 t.Fatalf("err: %s", err)
268 }
269 if !reflect.DeepEqual(log, logs[1]) {
270 t.Fatalf("bad: %#v", log)
271 }
272 }
273
274 func TestBoltStore_SetLog(t *testing.T) {
275 store := testBoltStore(t)
276 defer store.Close()
277 defer os.Remove(store.path)
278
279 // Create the log
280 log := &raft.Log{
281 Data: []byte("log1"),
282 Index: 1,
283 }
284
285 // Attempt to store the log
286 if err := store.StoreLog(log); err != nil {
287 t.Fatalf("err: %s", err)
288 }
289
290 // Retrieve the log again
291 result := new(raft.Log)
292 if err := store.GetLog(1, result); err != nil {
293 t.Fatalf("err: %s", err)
294 }
295
296 // Ensure the log comes back the same
297 if !reflect.DeepEqual(log, result) {
298 t.Fatalf("bad: %v", result)
299 }
300 }
301
302 func TestBoltStore_SetLogs(t *testing.T) {
303 store := testBoltStore(t)
304 defer store.Close()
305 defer os.Remove(store.path)
306
307 // Create a set of logs
308 logs := []*raft.Log{
309 testRaftLog(1, "log1"),
310 testRaftLog(2, "log2"),
311 }
312
313 // Attempt to store the logs
314 if err := store.StoreLogs(logs); err != nil {
315 t.Fatalf("err: %s", err)
316 }
317
318 // Ensure we stored them all
319 result1, result2 := new(raft.Log), new(raft.Log)
320 if err := store.GetLog(1, result1); err != nil {
321 t.Fatalf("err: %s", err)
322 }
323 if !reflect.DeepEqual(logs[0], result1) {
324 t.Fatalf("bad: %#v", result1)
325 }
326 if err := store.GetLog(2, result2); err != nil {
327 t.Fatalf("err: %s", err)
328 }
329 if !reflect.DeepEqual(logs[1], result2) {
330 t.Fatalf("bad: %#v", result2)
331 }
332 }
333
334 func TestBoltStore_DeleteRange(t *testing.T) {
335 store := testBoltStore(t)
336 defer store.Close()
337 defer os.Remove(store.path)
338
339 // Create a set of logs
340 log1 := testRaftLog(1, "log1")
341 log2 := testRaftLog(2, "log2")
342 log3 := testRaftLog(3, "log3")
343 logs := []*raft.Log{log1, log2, log3}
344
345 // Attempt to store the logs
346 if err := store.StoreLogs(logs); err != nil {
347 t.Fatalf("err: %s", err)
348 }
349
350 // Attempt to delete a range of logs
351 if err := store.DeleteRange(1, 2); err != nil {
352 t.Fatalf("err: %s", err)
353 }
354
355 // Ensure the logs were deleted
356 if err := store.GetLog(1, new(raft.Log)); err != raft.ErrLogNotFound {
357 t.Fatalf("should have deleted log1")
358 }
359 if err := store.GetLog(2, new(raft.Log)); err != raft.ErrLogNotFound {
360 t.Fatalf("should have deleted log2")
361 }
362 }
363
364 func TestBoltStore_Set_Get(t *testing.T) {
365 store := testBoltStore(t)
366 defer store.Close()
367 defer os.Remove(store.path)
368
369 // Returns error on non-existent key
370 if _, err := store.Get([]byte("bad")); err != ErrKeyNotFound {
371 t.Fatalf("expected not found error, got: %q", err)
372 }
373
374 k, v := []byte("hello"), []byte("world")
375
376 // Try to set a k/v pair
377 if err := store.Set(k, v); err != nil {
378 t.Fatalf("err: %s", err)
379 }
380
381 // Try to read it back
382 val, err := store.Get(k)
383 if err != nil {
384 t.Fatalf("err: %s", err)
385 }
386 if !bytes.Equal(val, v) {
387 t.Fatalf("bad: %v", val)
388 }
389 }
390
391 func TestBoltStore_SetUint64_GetUint64(t *testing.T) {
392 store := testBoltStore(t)
393 defer store.Close()
394 defer os.Remove(store.path)
395
396 // Returns error on non-existent key
397 if _, err := store.GetUint64([]byte("bad")); err != ErrKeyNotFound {
398 t.Fatalf("expected not found error, got: %q", err)
399 }
400
401 k, v := []byte("abc"), uint64(123)
402
403 // Attempt to set the k/v pair
404 if err := store.SetUint64(k, v); err != nil {
405 t.Fatalf("err: %s", err)
406 }
407
408 // Read back the value
409 val, err := store.GetUint64(k)
410 if err != nil {
411 t.Fatalf("err: %s", err)
412 }
413 if val != v {
414 t.Fatalf("bad: %v", val)
415 }
416 }