fakeredis 0.5.0 → 0.6.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -10,41 +10,51 @@ module FakeRedis
10
10
  @client.lpush("key1", "val1")
11
11
  @client.lpush("key1", "val2")
12
12
 
13
- @client.lindex("key1", 0).should be == "val2"
14
- @client.lindex("key1", -1).should be == "val1"
15
- @client.lindex("key1", 3).should be == nil
13
+ expect(@client.lindex("key1", 0)).to eq("val2")
14
+ expect(@client.lindex("key1", -1)).to eq("val1")
15
+ expect(@client.lindex("key1", 3)).to eq(nil)
16
16
  end
17
17
 
18
18
  it "should insert an element before or after another element in a list" do
19
19
  @client.rpush("key1", "v1")
20
20
  @client.rpush("key1", "v3")
21
21
  @client.linsert("key1", :before, "v3", "v2")
22
+ @client.linsert("key1", :after, "v3", 100)
23
+ @client.linsert("key1", :before, 100, 99)
22
24
 
23
- @client.lrange("key1", 0, -1).should be == ["v1", "v2", "v3"]
25
+ expect(@client.lrange("key1", 0, -1)).to eq(["v1", "v2", "v3", "99", "100"])
26
+ end
27
+
28
+ it "should not insert if after/before index not found" do
29
+ @client.rpush("key", "v1")
30
+ expect(@client.linsert("key", :before, "unknown", "v2")).to eq(-1)
31
+ expect(@client.linsert("key", :after, "unknown", "v3")).to eq(-1)
32
+
33
+ expect(@client.lrange("key", 0, -1)).to eq(["v1"])
24
34
  end
25
35
 
26
36
  it 'should allow multiple values to be added to a list in a single rpush' do
27
37
  @client.rpush('key1', [1, 2, 3])
28
- @client.lrange('key1', 0, -1).should be == ['1', '2', '3']
38
+ expect(@client.lrange('key1', 0, -1)).to eq(['1', '2', '3'])
29
39
  end
30
40
 
31
41
  it 'should allow multiple values to be added to a list in a single lpush' do
32
42
  @client.lpush('key1', [1, 2, 3])
33
- @client.lrange('key1', 0, -1).should be == ['3', '2', '1']
43
+ expect(@client.lrange('key1', 0, -1)).to eq(['3', '2', '1'])
34
44
  end
35
45
 
36
46
  it "should error if an invalid where argument is given" do
37
47
  @client.rpush("key1", "v1")
38
48
  @client.rpush("key1", "v3")
39
- lambda { @client.linsert("key1", :invalid, "v3", "v2") }.should raise_error(Redis::CommandError, "ERR syntax error")
49
+ expect { @client.linsert("key1", :invalid, "v3", "v2") }.to raise_error(Redis::CommandError, "ERR syntax error")
40
50
  end
41
51
 
42
52
  it "should get the length of a list" do
43
53
  @client.rpush("key1", "v1")
44
54
  @client.rpush("key1", "v2")
45
55
 
46
- @client.llen("key1").should be == 2
47
- @client.llen("key2").should be == 0
56
+ expect(@client.llen("key1")).to eq(2)
57
+ expect(@client.llen("key2")).to eq(0)
48
58
  end
49
59
 
50
60
  it "should remove and get the first element in a list" do
@@ -52,15 +62,15 @@ module FakeRedis
52
62
  @client.rpush("key1", "v2")
53
63
  @client.rpush("key1", "v3")
54
64
 
55
- @client.lpop("key1").should be == "v1"
56
- @client.lrange("key1", 0, -1).should be == ["v2", "v3"]
65
+ expect(@client.lpop("key1")).to eq("v1")
66
+ expect(@client.lrange("key1", 0, -1)).to eq(["v2", "v3"])
57
67
  end
58
68
 
59
69
  it "should prepend a value to a list" do
60
70
  @client.rpush("key1", "v1")
61
71
  @client.rpush("key1", "v2")
62
72
 
63
- @client.lrange("key1", 0, -1).should be == ["v1", "v2"]
73
+ expect(@client.lrange("key1", 0, -1)).to eq(["v1", "v2"])
64
74
  end
65
75
 
66
76
  it "should prepend a value to a list, only if the list exists" do
@@ -69,8 +79,8 @@ module FakeRedis
69
79
  @client.lpushx("key1", "v2")
70
80
  @client.lpushx("key2", "v3")
71
81
 
72
- @client.lrange("key1", 0, -1).should be == ["v2", "v1"]
73
- @client.llen("key2").should be == 0
82
+ expect(@client.lrange("key1", 0, -1)).to eq(["v2", "v1"])
83
+ expect(@client.llen("key2")).to eq(0)
74
84
  end
75
85
 
76
86
  it "should get a range of elements from a list" do
@@ -78,7 +88,8 @@ module FakeRedis
78
88
  @client.rpush("key1", "v2")
79
89
  @client.rpush("key1", "v3")
80
90
 
81
- @client.lrange("key1", 1, -1).should be == ["v2", "v3"]
91
+ expect(@client.lrange("key1", 1, -1)).to eq(["v2", "v3"])
92
+ expect(@client.lrange("key1", -999, -1)).to eq(["v1", "v2", "v3"])
82
93
  end
83
94
 
84
95
  it "should remove elements from a list" do
@@ -87,10 +98,17 @@ module FakeRedis
87
98
  @client.rpush("key1", "v2")
88
99
  @client.rpush("key1", "v2")
89
100
  @client.rpush("key1", "v1")
101
+ @client.rpush("key1", 42)
102
+
103
+ expect(@client.lrem("key1", 1, "v1")).to eq(1)
104
+ expect(@client.lrem("key1", -2, "v2")).to eq(2)
105
+ expect(@client.lrem("key1", 0, 42)).to eq(1)
106
+ expect(@client.llen("key1")).to eq(2)
107
+ end
90
108
 
91
- @client.lrem("key1", 1, "v1").should be == 1
92
- @client.lrem("key1", -2, "v2").should be == 2
93
- @client.llen("key1").should be == 2
109
+ it "should return 0 if key does not map to a list" do
110
+ expect(@client.exists("nonexistant")).to eq(false)
111
+ expect(@client.lrem("nonexistant", 0, "value")).to eq(0)
94
112
  end
95
113
 
96
114
  it "should remove list's key when list is empty" do
@@ -99,7 +117,7 @@ module FakeRedis
99
117
  @client.lrem("key1", 1, "v1")
100
118
  @client.lrem("key1", 1, "v2")
101
119
 
102
- @client.exists("key1").should be == false
120
+ expect(@client.exists("key1")).to eq(false)
103
121
  end
104
122
 
105
123
  it "should set the value of an element in a list by its index" do
@@ -109,9 +127,10 @@ module FakeRedis
109
127
 
110
128
  @client.lset("key1", 0, "four")
111
129
  @client.lset("key1", -2, "five")
112
- @client.lrange("key1", 0, -1).should be == ["four", "five", "three"]
130
+ @client.lset("key1", 2, 6)
113
131
 
114
- lambda { @client.lset("key1", 4, "six") }.should raise_error(Redis::CommandError, "ERR index out of range")
132
+ expect(@client.lrange("key1", 0, -1)).to eq(["four", "five", "6"])
133
+ expect { @client.lset("key1", 4, "seven") }.to raise_error(Redis::CommandError, "ERR index out of range")
115
134
  end
116
135
 
117
136
  it "should trim a list to the specified range" do
@@ -119,8 +138,8 @@ module FakeRedis
119
138
  @client.rpush("key1", "two")
120
139
  @client.rpush("key1", "three")
121
140
 
122
- @client.ltrim("key1", 1, -1).should be == "OK"
123
- @client.lrange("key1", 0, -1).should be == ["two", "three"]
141
+ expect(@client.ltrim("key1", 1, -1)).to eq("OK")
142
+ expect(@client.lrange("key1", 0, -1)).to eq(["two", "three"])
124
143
  end
125
144
 
126
145
 
@@ -131,7 +150,7 @@ module FakeRedis
131
150
  before { @client.ltrim("listOfOne", -5, -1) }
132
151
 
133
152
  it "returns the unmodified list" do
134
- @client.lrange("listOfOne", 0, -1).should be == ["one"]
153
+ expect(@client.lrange("listOfOne", 0, -1)).to eq(["one"])
135
154
  end
136
155
  end
137
156
  end
@@ -150,7 +169,7 @@ module FakeRedis
150
169
  before { @client.ltrim("maxTest", -5, -1) }
151
170
 
152
171
  it "should trim a list to the specified maximum size" do
153
- @client.lrange("maxTest", 0, -1).should be == ["two","three", "four", "five", "six"]
172
+ expect(@client.lrange("maxTest", 0, -1)).to eq(["two","three", "four", "five", "six"])
154
173
  end
155
174
  end
156
175
  end
@@ -161,8 +180,8 @@ module FakeRedis
161
180
  @client.rpush("key1", "two")
162
181
  @client.rpush("key1", "three")
163
182
 
164
- @client.rpop("key1").should be == "three"
165
- @client.lrange("key1", 0, -1).should be == ["one", "two"]
183
+ expect(@client.rpop("key1")).to eq("three")
184
+ expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
166
185
  end
167
186
 
168
187
  it "should remove the last element in a list, append it to another list and return it" do
@@ -170,17 +189,17 @@ module FakeRedis
170
189
  @client.rpush("key1", "two")
171
190
  @client.rpush("key1", "three")
172
191
 
173
- @client.rpoplpush("key1", "key2").should be == "three"
192
+ expect(@client.rpoplpush("key1", "key2")).to eq("three")
174
193
 
175
- @client.lrange("key1", 0, -1).should be == ["one", "two"]
176
- @client.lrange("key2", 0, -1).should be == ["three"]
194
+ expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
195
+ expect(@client.lrange("key2", 0, -1)).to eq(["three"])
177
196
  end
178
197
 
179
198
  context 'when the source list is empty' do
180
199
  it 'rpoplpush does not add anything to the destination list' do
181
200
  @client.rpoplpush("source", "destination")
182
201
 
183
- @client.lrange("destination", 0, -1).should be == []
202
+ expect(@client.lrange("destination", 0, -1)).to eq([])
184
203
  end
185
204
  end
186
205
 
@@ -188,7 +207,7 @@ module FakeRedis
188
207
  @client.rpush("key1", "one")
189
208
  @client.rpush("key1", "two")
190
209
 
191
- @client.lrange("key1", 0, -1).should be == ["one", "two"]
210
+ expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
192
211
  end
193
212
 
194
213
  it "should append a value to a list, only if the list exists" do
@@ -196,8 +215,16 @@ module FakeRedis
196
215
  @client.rpushx("key1", "two")
197
216
  @client.rpushx("key2", "two")
198
217
 
199
- @client.lrange("key1", 0, -1).should be == ["one", "two"]
200
- @client.lrange("key2", 0, -1).should be == []
218
+ expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
219
+ expect(@client.lrange("key2", 0, -1)).to eq([])
220
+ end
221
+
222
+ it 'should not allow pushing empty list of objects' do
223
+ expect { @client.lpush("key1", []) }.to raise_error(Redis::CommandError, /lpush[^x]/)
224
+ expect { @client.lpush("key1", 1); @client.lpushx("key1", []) }.to raise_error(Redis::CommandError, /lpushx/)
225
+
226
+ expect { @client.rpush("key1", []) }.to raise_error(Redis::CommandError, /rpush[^x]/)
227
+ expect { @client.rpush("key1", 1); @client.rpushx("key1", []) }.to raise_error(Redis::CommandError, /rpushx/)
201
228
  end
202
229
  end
203
230
  end
@@ -1,27 +1,80 @@
1
1
  require 'spec_helper'
2
2
 
3
- module FakeRedis
3
+ RSpec.describe FakeRedis do
4
+ let(:redis) { Redis.new }
5
+
6
+ def populate_keys_in_redis(num)
7
+ num.times do |count|
8
+ redis.set("key#{count}", count)
9
+ end
10
+ end
11
+
12
+ describe '#scan' do
13
+ def result
14
+ returned_keys = []
15
+ cursor = 0
16
+
17
+ loop do
18
+ cursor, keys = redis.scan(cursor, match_arguments)
19
+ returned_keys += keys
20
+ break if cursor == '0'
21
+ end
22
+ returned_keys
23
+ end
24
+
25
+ before do
26
+ populate_keys_in_redis(11)
27
+ end
28
+
29
+ context('when deleting') do
30
+ it('preverves cursor') do
31
+ cursor, keys = redis.scan('0')
32
+ keys.each { |key| redis.del(key) }
33
+ _, keys = redis.scan(cursor)
34
+ expect(keys).to eq(%w(key10))
35
+ end
36
+ end
37
+
38
+ context 'with one namespace' do
39
+ let(:match_arguments) { {} }
40
+
41
+ it 'returns the expected array of keys' do
42
+ expect(result).to match_array(redis.keys)
43
+ end
44
+ end
45
+
46
+ context 'with multiple namespaces' do
47
+ let(:namespaced_key) { 'test' }
48
+ let(:match_arguments) { { match: namespaced_key } }
49
+
50
+ before { redis.set(namespaced_key, 12) }
51
+
52
+ it 'returns the expected array of keys' do
53
+ expect(result).to match_array([namespaced_key])
54
+ end
55
+ end
56
+ end
57
+
4
58
  describe 'time' do
5
59
  before(:each) do
6
- @client = Redis.new
7
- Time.stub_chain(:now, :to_f).and_return(1397845595.5139461)
60
+ allow(Time).to receive_message_chain(:now, :to_f).and_return(1397845595.5139461)
8
61
  end
9
62
 
10
63
  it 'is an array' do
11
- expect(@client.time).to be_an_instance_of(Array)
64
+ expect(redis.time).to be_an_instance_of(Array)
12
65
  end
13
66
 
14
67
  it 'has two elements' do
15
- expect(@client.time.count).to eql 2
68
+ expect(redis.time.count).to eql 2
16
69
  end
17
70
 
18
71
  if fakeredis?
19
72
  it 'has the current time in seconds' do
20
- expect(@client.time.first).to eql 1397845595
73
+ expect(redis.time.first).to eql 1397845595
21
74
  end
22
75
 
23
76
  it 'has the current leftover microseconds' do
24
- expect(@client.time.last).to eql 513946
77
+ expect(redis.time.last).to eql 513946
25
78
  end
26
79
  end
27
80
  end
@@ -12,29 +12,29 @@ module FakeRedis
12
12
  @client.set("key2", "2")
13
13
  @client.set("key2", "two")
14
14
 
15
- @client.dbsize.should be == 2
15
+ expect(@client.dbsize).to eq(2)
16
16
  end
17
17
 
18
18
  it "should get information and statistics about the server" do
19
- @client.info.key?("redis_version").should be == true
19
+ expect(@client.info.key?("redis_version")).to eq(true)
20
20
  end
21
21
 
22
22
  it "should handle non-existent methods" do
23
- lambda { @client.idontexist }.should raise_error(Redis::CommandError, "ERR unknown command 'idontexist'")
23
+ expect { @client.idontexist }.to raise_error(Redis::CommandError, "ERR unknown command 'idontexist'")
24
24
  end
25
25
 
26
26
  describe "multiple databases" do
27
27
  it "should default to database 0" do
28
- @client.inspect.should =~ %r#/0>$#
28
+ expect(@client.inspect).to match(%r#/0>$#)
29
29
  end
30
30
 
31
31
  it "should select another database" do
32
32
  @client.select(1)
33
- @client.inspect.should =~ %r#/1>$#
33
+ expect(@client.inspect).to match(%r#/1>$#)
34
34
  end
35
35
 
36
36
  it "should store keys separately in each database" do
37
- @client.select(0).should be == "OK"
37
+ expect(@client.select(0)).to eq("OK")
38
38
  @client.set("key1", "1")
39
39
  @client.set("key2", "2")
40
40
 
@@ -44,56 +44,56 @@ module FakeRedis
44
44
  @client.set("key5", "5")
45
45
 
46
46
  @client.select(0)
47
- @client.dbsize.should be == 2
48
- @client.exists("key1").should be true
49
- @client.exists("key3").should be false
47
+ expect(@client.dbsize).to eq(2)
48
+ expect(@client.exists("key1")).to be true
49
+ expect(@client.exists("key3")).to be false
50
50
 
51
51
  @client.select(1)
52
- @client.dbsize.should be == 3
53
- @client.exists("key4").should be true
54
- @client.exists("key2").should be false
52
+ expect(@client.dbsize).to eq(3)
53
+ expect(@client.exists("key4")).to be true
54
+ expect(@client.exists("key2")).to be false
55
55
 
56
56
  @client.flushall
57
- @client.dbsize.should be == 0
57
+ expect(@client.dbsize).to eq(0)
58
58
 
59
59
  @client.select(0)
60
- @client.dbsize.should be == 0
60
+ expect(@client.dbsize).to eq(0)
61
61
  end
62
62
 
63
63
  it "should flush a database" do
64
64
  @client.select(0)
65
65
  @client.set("key1", "1")
66
66
  @client.set("key2", "2")
67
- @client.dbsize.should be == 2
67
+ expect(@client.dbsize).to eq(2)
68
68
 
69
69
  @client.select(1)
70
70
  @client.set("key3", "3")
71
71
  @client.set("key4", "4")
72
- @client.dbsize.should be == 2
72
+ expect(@client.dbsize).to eq(2)
73
73
 
74
- @client.flushdb.should be == "OK"
74
+ expect(@client.flushdb).to eq("OK")
75
75
 
76
- @client.dbsize.should be == 0
76
+ expect(@client.dbsize).to eq(0)
77
77
  @client.select(0)
78
- @client.dbsize.should be == 2
78
+ expect(@client.dbsize).to eq(2)
79
79
  end
80
80
 
81
81
  it "should flush all databases" do
82
82
  @client.select(0)
83
83
  @client.set("key3", "3")
84
84
  @client.set("key4", "4")
85
- @client.dbsize.should be == 2
85
+ expect(@client.dbsize).to eq(2)
86
86
 
87
87
  @client.select(1)
88
88
  @client.set("key3", "3")
89
89
  @client.set("key4", "4")
90
- @client.dbsize.should be == 2
90
+ expect(@client.dbsize).to eq(2)
91
91
 
92
- @client.flushall.should be == "OK"
92
+ expect(@client.flushall).to eq("OK")
93
93
 
94
- @client.dbsize.should be == 0
94
+ expect(@client.dbsize).to eq(0)
95
95
  @client.select(0)
96
- @client.dbsize.should be == 0
96
+ expect(@client.dbsize).to eq(0)
97
97
  end
98
98
  end
99
99
  end
@@ -7,30 +7,33 @@ module FakeRedis
7
7
  end
8
8
 
9
9
  it "should add a member to a set" do
10
- @client.sadd("key", "value").should be == true
11
- @client.sadd("key", "value").should be == false
10
+ expect(@client.sadd("key", "value")).to eq(true)
11
+ expect(@client.sadd("key", "value")).to eq(false)
12
12
 
13
- @client.smembers("key").should be == ["value"]
13
+ expect(@client.smembers("key")).to eq(["value"])
14
14
  end
15
15
 
16
16
  it "should raise error if command arguments count is not enough" do
17
17
  expect { @client.sadd("key", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sadd' command")
18
18
  expect { @client.sinter(*[]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sinter' command")
19
+ expect { @client.sinter([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sinter' command")
20
+ expect { @client.sunion(*[]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sunion' command")
21
+ expect { @client.sunion([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sunion' command")
19
22
 
20
- @client.smembers("key").should be_empty
23
+ expect(@client.smembers("key")).to be_empty
21
24
  end
22
25
 
23
26
  it "should add multiple members to a set" do
24
- @client.sadd("key", %w(value other something more)).should be == 4
25
- @client.sadd("key", %w(and additional values)).should be == 3
26
- @client.smembers("key").should =~ ["value", "other", "something", "more", "and", "additional", "values"]
27
+ expect(@client.sadd("key", %w(value other something more))).to eq(4)
28
+ expect(@client.sadd("key", %w(and additional values))).to eq(3)
29
+ expect(@client.smembers("key")).to match_array(["value", "other", "something", "more", "and", "additional", "values"])
27
30
  end
28
31
 
29
32
  it "should get the number of members in a set" do
30
33
  @client.sadd("key", "val1")
31
34
  @client.sadd("key", "val2")
32
35
 
33
- @client.scard("key").should be == 2
36
+ expect(@client.scard("key")).to eq(2)
34
37
  end
35
38
 
36
39
  it "should subtract multiple sets" do
@@ -43,14 +46,16 @@ module FakeRedis
43
46
  @client.sadd("key3", "c")
44
47
  @client.sadd("key3", "e")
45
48
 
46
- @client.sdiff("key1", "key2", "key3").should =~ ["b", "d"]
49
+ expect(@client.sdiff("key1", "key2", "key3")).to match_array(["b", "d"])
50
+ expect(@client.sdiff("key1", ["key2", "key3"])).to match_array(["b", "d"])
47
51
  end
48
52
 
49
53
  it "should subtract from a nonexistent set" do
50
54
  @client.sadd("key2", "a")
51
55
  @client.sadd("key2", "b")
52
56
 
53
- @client.sdiff("key1", "key2").should == []
57
+ expect(@client.sdiff("key1", "key2")).to eq([])
58
+ expect(@client.sdiff(["key1", "key2"])).to eq([])
54
59
  end
55
60
 
56
61
  it "should subtract multiple sets and store the resulting set in a key" do
@@ -63,8 +68,10 @@ module FakeRedis
63
68
  @client.sadd("key3", "c")
64
69
  @client.sadd("key3", "e")
65
70
  @client.sdiffstore("key", "key1", "key2", "key3")
71
+ @client.sdiffstore("new_key", "key1", ["key2", "key3"])
66
72
 
67
- @client.smembers("key").should =~ ["b", "d"]
73
+ expect(@client.smembers("key")).to match_array(["b", "d"])
74
+ expect(@client.smembers("new_key")).to match_array(["b", "d"])
68
75
  end
69
76
 
70
77
  it "should intersect multiple sets" do
@@ -77,7 +84,8 @@ module FakeRedis
77
84
  @client.sadd("key3", "c")
78
85
  @client.sadd("key3", "e")
79
86
 
80
- @client.sinter("key1", "key2", "key3").should be == ["c"]
87
+ expect(@client.sinter("key1", "key2", "key3")).to eq(["c"])
88
+ expect(@client.sinter(["key1", "key2", "key3"])).to eq(["c"])
81
89
  end
82
90
 
83
91
  it "should intersect multiple sets and store the resulting set in a key" do
@@ -90,15 +98,18 @@ module FakeRedis
90
98
  @client.sadd("key3", "c")
91
99
  @client.sadd("key3", "e")
92
100
  @client.sinterstore("key", "key1", "key2", "key3")
93
- @client.smembers("key").should be == ["c"]
101
+ @client.sinterstore("new_key", ["key1", "key2", "key3"])
102
+
103
+ expect(@client.smembers("key")).to eq(["c"])
104
+ expect(@client.smembers("new_key")).to eq(["c"])
94
105
  end
95
106
 
96
107
  it "should determine if a given value is a member of a set" do
97
108
  @client.sadd("key1", "a")
98
109
 
99
- @client.sismember("key1", "a").should be == true
100
- @client.sismember("key1", "b").should be == false
101
- @client.sismember("key2", "a").should be == false
110
+ expect(@client.sismember("key1", "a")).to eq(true)
111
+ expect(@client.sismember("key1", "b")).to eq(false)
112
+ expect(@client.sismember("key2", "a")).to eq(false)
102
113
  end
103
114
 
104
115
  it "should get all the members in a set" do
@@ -107,51 +118,51 @@ module FakeRedis
107
118
  @client.sadd("key", "c")
108
119
  @client.sadd("key", "d")
109
120
 
110
- @client.smembers("key").should =~ ["a", "b", "c", "d"]
121
+ expect(@client.smembers("key")).to match_array(["a", "b", "c", "d"])
111
122
  end
112
123
 
113
124
  it "should move a member from one set to another" do
114
125
  @client.sadd("key1", "a")
115
126
  @client.sadd("key1", "b")
116
127
  @client.sadd("key2", "c")
117
- @client.smove("key1", "key2", "a").should be == true
118
- @client.smove("key1", "key2", "a").should be == false
128
+ expect(@client.smove("key1", "key2", "a")).to eq(true)
129
+ expect(@client.smove("key1", "key2", "a")).to eq(false)
119
130
 
120
- @client.smembers("key1").should be == ["b"]
121
- @client.smembers("key2").should =~ ["c", "a"]
131
+ expect(@client.smembers("key1")).to eq(["b"])
132
+ expect(@client.smembers("key2")).to match_array(["c", "a"])
122
133
  end
123
134
 
124
135
  it "should remove and return a random member from a set" do
125
136
  @client.sadd("key1", "a")
126
137
  @client.sadd("key1", "b")
127
138
 
128
- ["a", "b"].include?(@client.spop("key1")).should be true
129
- ["a", "b"].include?(@client.spop("key1")).should be true
130
- @client.spop("key1").should be_nil
139
+ expect(["a", "b"].include?(@client.spop("key1"))).to be true
140
+ expect(["a", "b"].include?(@client.spop("key1"))).to be true
141
+ expect(@client.spop("key1")).to be_nil
131
142
  end
132
143
 
133
144
  it "should get a random member from a set" do
134
145
  @client.sadd("key1", "a")
135
146
  @client.sadd("key1", "b")
136
147
 
137
- ["a", "b"].include?(@client.spop("key1")).should be true
148
+ expect(["a", "b"].include?(@client.spop("key1"))).to be true
138
149
  end
139
150
 
140
151
  it "should remove a member from a set" do
141
152
  @client.sadd("key1", "a")
142
153
  @client.sadd("key1", "b")
143
- @client.srem("key1", "a").should be == true
144
- @client.srem("key1", "a").should be == false
154
+ expect(@client.srem("key1", "a")).to eq(true)
155
+ expect(@client.srem("key1", "a")).to eq(false)
145
156
 
146
- @client.smembers("key1").should be == ["b"]
157
+ expect(@client.smembers("key1")).to eq(["b"])
147
158
  end
148
159
 
149
160
  it "should remove multiple members from a set" do
150
161
  @client.sadd("key1", "a")
151
162
  @client.sadd("key1", "b")
152
163
 
153
- @client.srem("key1", [ "a", "b"]).should == 2
154
- @client.smembers("key1").should be_empty
164
+ expect(@client.srem("key1", [ "a", "b"])).to eq(2)
165
+ expect(@client.smembers("key1")).to be_empty
155
166
  end
156
167
 
157
168
  it "should remove the set's key once it's empty" do
@@ -160,7 +171,7 @@ module FakeRedis
160
171
  @client.srem("key1", "b")
161
172
  @client.srem("key1", "a")
162
173
 
163
- @client.exists("key1").should be == false
174
+ expect(@client.exists("key1")).to eq(false)
164
175
  end
165
176
 
166
177
  it "should add multiple sets" do
@@ -173,7 +184,7 @@ module FakeRedis
173
184
  @client.sadd("key3", "c")
174
185
  @client.sadd("key3", "e")
175
186
 
176
- @client.sunion("key1", "key2", "key3").should =~ ["a", "b", "c", "d", "e"]
187
+ expect(@client.sunion("key1", "key2", "key3")).to match_array(["a", "b", "c", "d", "e"])
177
188
  end
178
189
 
179
190
  it "should add multiple sets and store the resulting set in a key" do
@@ -187,7 +198,7 @@ module FakeRedis
187
198
  @client.sadd("key3", "e")
188
199
  @client.sunionstore("key", "key1", "key2", "key3")
189
200
 
190
- @client.smembers("key").should =~ ["a", "b", "c", "d", "e"]
201
+ expect(@client.smembers("key")).to match_array(["a", "b", "c", "d", "e"])
191
202
  end
192
203
  end
193
204
 
@@ -207,7 +218,7 @@ module FakeRedis
207
218
  it 'is a random element from the set' do
208
219
  random_element = @client.srandmember("key1")
209
220
 
210
- ['a', 'b', 'c'].include?(random_element).should be true
221
+ expect(['a', 'b', 'c'].include?(random_element)).to be true
211
222
  end
212
223
  end
213
224
 
@@ -215,7 +226,7 @@ module FakeRedis
215
226
  it 'is an array of one random element from the set' do
216
227
  random_elements = @client.srandmember("key1", 1)
217
228
 
218
- [['a'], ['b'], ['c']].include?(@client.srandmember("key1", 1)).should be true
229
+ expect([['a'], ['b'], ['c']].include?(@client.srandmember("key1", 1))).to be true
219
230
  end
220
231
  end
221
232
 
@@ -223,10 +234,10 @@ module FakeRedis
223
234
  it 'is an array of two unique, random elements from the set' do
224
235
  random_elements = @client.srandmember("key1", 2)
225
236
 
226
- random_elements.count.should == 2
227
- random_elements.uniq.count.should == 2
237
+ expect(random_elements.count).to eq(2)
238
+ expect(random_elements.uniq.count).to eq(2)
228
239
  random_elements.all? do |element|
229
- ['a', 'b', 'c'].include?(element).should be true
240
+ expect(['a', 'b', 'c'].include?(element)).to be true
230
241
  end
231
242
  end
232
243
  end
@@ -235,10 +246,10 @@ module FakeRedis
235
246
  it 'is an array of 100 random elements from the set, some of which are repeated' do
236
247
  random_elements = @client.srandmember("key1", -100)
237
248
 
238
- random_elements.count.should == 100
239
- random_elements.uniq.count.should <= 3
249
+ expect(random_elements.count).to eq(100)
250
+ expect(random_elements.uniq.count).to be <= 3
240
251
  random_elements.all? do |element|
241
- ['a', 'b', 'c'].include?(element).should be true
252
+ expect(['a', 'b', 'c'].include?(element)).to be true
242
253
  end
243
254
  end
244
255
  end
@@ -247,9 +258,9 @@ module FakeRedis
247
258
  it 'is an array of all of the elements from the set, none of which are repeated' do
248
259
  random_elements = @client.srandmember("key1", 100)
249
260
 
250
- random_elements.count.should == 3
251
- random_elements.uniq.count.should == 3
252
- random_elements.should =~ ['a', 'b', 'c']
261
+ expect(random_elements.count).to eq(3)
262
+ expect(random_elements.uniq.count).to eq(3)
263
+ expect(random_elements).to match_array(['a', 'b', 'c'])
253
264
  end
254
265
  end
255
266
  end
@@ -258,11 +269,49 @@ module FakeRedis
258
269
  before { @client.del("key1") }
259
270
 
260
271
  it 'is nil without the extra parameter' do
261
- @client.srandmember("key1").should be_nil
272
+ expect(@client.srandmember("key1")).to be_nil
262
273
  end
263
274
 
264
275
  it 'is an empty array with an extra parameter' do
265
- @client.srandmember("key1", 1).should == []
276
+ expect(@client.srandmember("key1", 1)).to eq([])
277
+ end
278
+ end
279
+
280
+ describe "#sscan" do
281
+ it 'with no arguments and few items, returns all items' do
282
+ @client.sadd('set', ['name', 'Jack', 'age', '33'])
283
+ result = @client.sscan('set', 0)
284
+
285
+ expect(result[0]).to eq('0')
286
+ expect(result[1]).to eq(['name', 'Jack', 'age', '33'])
287
+ end
288
+
289
+ it 'with a count should return that number of members or more' do
290
+ @client.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
291
+ result = @client.sscan('set', 0, count: 3)
292
+ expect(result[0]).to eq('3')
293
+ expect(result[1]).to eq([ 'a', '1', 'b'])
294
+ end
295
+
296
+ it 'returns items starting at the provided cursor' do
297
+ @client.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
298
+ result = @client.sscan('set', 2, count: 3)
299
+ expect(result[0]).to eq('5')
300
+ expect(result[1]).to eq(['b', '2', 'c'])
301
+ end
302
+
303
+ it 'with match, returns items matching the given pattern' do
304
+ @client.sadd('set', ['aa', '1', 'b', '2', 'cc', '3', 'd', '4', 'ee', '5', 'f', '6', 'gg', '7'])
305
+ result = @client.sscan('set', 2, count: 7, match: '??')
306
+ expect(result[0]).to eq('9')
307
+ expect(result[1]).to eq(['cc','ee'])
308
+ end
309
+
310
+ it 'returns an empty result if the key is not found' do
311
+ result = @client.sscan('set', 0)
312
+
313
+ expect(result[0]).to eq('0')
314
+ expect(result[1]).to eq([])
266
315
  end
267
316
  end
268
317
  end