-
Notifications
You must be signed in to change notification settings - Fork 0
/
client_test.go
127 lines (95 loc) · 3.15 KB
/
client_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
package redisPriorityQueue
import (
"context"
"encoding/json"
"github.com/alicebob/miniredis/v2"
"github.com/go-redis/redis/v8"
"github.com/stretchr/testify/assert"
"os"
"testing"
)
var setup = func() (mr *miniredis.Miniredis, err error) {
// Mock Redis server
return miniredis.Run()
}
type ClientTest struct {
testKey string
testOneData string
testBatchData []string
mr *miniredis.Miniredis
}
func TestClientAll(t *testing.T) {
// setup function
mr, err := setup()
defer mr.Close()
if err != nil {
os.Exit(1)
}
ct := ClientTest{mr: mr, testKey: "testKey", testOneData: "testOneData",
testBatchData: []string{"testBatchData1", "testBatchData2"}}
ct.TestPushOne(t)
ct.TestPopOne(t)
ct.TestBatchPush(t)
ct.TestBatchPop(t)
}
func (ct ClientTest) TestPushOne(t *testing.T) {
// Setup redisQueueClient
rdb := redis.NewClient(&redis.Options{Addr: ct.mr.Addr()})
rqc := NewRedisQueueClient[string](context.Background(), SerializerJson, rdb)
// Test PushOne
err := rqc.PushOne(context.Background(), ct.testOneData, 1, ct.testKey)
assert.Nil(t, err)
// Check if testData has been stored in testKey
storedData, _ := ct.mr.ZMembers(ct.testKey)
assert.NotEmpty(t, storedData)
var storedDataString string
json.Unmarshal([]byte(storedData[0]), &storedDataString)
assert.Equal(t, ct.testOneData, storedDataString)
}
func (ct ClientTest) TestPopOne(t *testing.T) {
// Setup redisQueueClient
rdb := redis.NewClient(&redis.Options{Addr: ct.mr.Addr()})
rqc := NewRedisQueueClient[string](context.Background(), SerializerJson, rdb)
var resultData string
err := rqc.PopOne(context.Background(), ct.testKey, &resultData)
assert.Nil(t, err)
// Check if testData has been stored in testKey
storedData, _ := ct.mr.ZMembers(ct.testKey)
assert.Empty(t, storedData)
assert.Equal(t, ct.testOneData, resultData)
}
func (ct ClientTest) TestBatchPush(t *testing.T) {
// Setup redisQueueClient
rdb := redis.NewClient(&redis.Options{Addr: ct.mr.Addr()})
rqc := NewRedisQueueClient[string](context.Background(), SerializerJson, rdb)
err := rqc.BatchPush(context.Background(), 1, ct.testKey, ct.testBatchData)
assert.Nil(t, err)
// Check if testData has been stored in testKey
storedData, _ := ct.mr.ZMembers(ct.testKey)
result := make([]string, 0, len(storedData))
for _, data := range storedData {
var tmp string
_ = json.Unmarshal([]byte(data), &tmp)
result = append(result, tmp)
}
assert.NotEmpty(t, storedData)
assert.Equal(t, ct.testBatchData, result)
}
func (ct ClientTest) TestBatchPop(t *testing.T) {
// Setup redisQueueClient
rdb := redis.NewClient(&redis.Options{Addr: ct.mr.Addr()})
rqc := NewRedisQueueClient[string](context.Background(), SerializerJson, rdb)
var count = len(ct.testBatchData)
resultData := make([]*string, count, count)
err := rqc.BatchPop(context.Background(), ct.testKey, count, resultData)
assert.Nil(t, err)
// Check if testData has been stored in testKey
storedData, _ := ct.mr.ZMembers(ct.testKey)
assert.Empty(t, storedData)
// Dereference the pointers to get a []string
actual := make([]string, len(resultData))
for i, ptr := range resultData {
actual[i] = *ptr
}
assert.Equal(t, ct.testBatchData, actual)
}