redis-namespace 1.6.0 → 1.8.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/spec/redis_spec.rb CHANGED
@@ -6,51 +6,46 @@ describe "redis" do
6
6
  @redis_version = Gem::Version.new(Redis.current.info["redis_version"])
7
7
  let(:redis_client) { @redis.respond_to?(:_client) ? @redis._client : @redis.client}
8
8
 
9
- before(:all) do
9
+ before(:each) do
10
10
  # use database 15 for testing so we dont accidentally step on your real data
11
11
  @redis = Redis.new :db => 15
12
- end
13
-
14
- before(:each) do
15
- @namespaced = Redis::Namespace.new(:ns, :redis => @redis)
16
12
  @redis.flushdb
13
+ @namespaced = Redis::Namespace.new(:ns, :redis => @redis)
17
14
  @redis.set('foo', 'bar')
18
15
  end
19
16
 
20
- after(:each) do
21
- @redis.flushdb
22
- end
23
-
24
- after(:all) do
25
- @redis.quit
17
+ # redis-rb 3.3.4+
18
+ it "should inject :namespace into connection info" do
19
+ info = @redis.connection.merge(:namespace => :ns)
20
+ expect(@namespaced.connection).to eq(info)
26
21
  end
27
22
 
28
23
  it "proxies `client` to the _client and deprecated" do
29
- @namespaced.client.should eq(redis_client)
24
+ expect(@namespaced.client).to eq(redis_client)
30
25
  end
31
26
 
32
27
  it "proxies `_client` to the _client" do
33
- @namespaced._client.should eq(redis_client)
28
+ expect(@namespaced._client).to eq(redis_client)
34
29
  end
35
30
 
36
31
  it "should be able to use a namespace" do
37
- @namespaced.get('foo').should eq(nil)
32
+ expect(@namespaced.get('foo')).to eq(nil)
38
33
  @namespaced.set('foo', 'chris')
39
- @namespaced.get('foo').should eq('chris')
34
+ expect(@namespaced.get('foo')).to eq('chris')
40
35
  @redis.set('foo', 'bob')
41
- @redis.get('foo').should eq('bob')
36
+ expect(@redis.get('foo')).to eq('bob')
42
37
 
43
38
  @namespaced.incrby('counter', 2)
44
- @namespaced.get('counter').to_i.should eq(2)
45
- @redis.get('counter').should eq(nil)
46
- @namespaced.type('counter').should eq('string')
39
+ expect(@namespaced.get('counter').to_i).to eq(2)
40
+ expect(@redis.get('counter')).to eq(nil)
41
+ expect(@namespaced.type('counter')).to eq('string')
47
42
  end
48
43
 
49
44
  context 'when sending capital commands (issue 68)' do
50
45
  it 'should be able to use a namespace' do
51
46
  @namespaced.send('SET', 'fubar', 'quux')
52
- @redis.get('fubar').should be_nil
53
- @namespaced.get('fubar').should eq 'quux'
47
+ expect(@redis.get('fubar')).to be_nil
48
+ expect(@namespaced.get('fubar')).to eq 'quux'
54
49
  end
55
50
  end
56
51
 
@@ -58,10 +53,10 @@ describe "redis" do
58
53
  @namespaced.rpush "foo", "string"
59
54
  @namespaced.rpush "foo", "ns:string"
60
55
  @namespaced.rpush "foo", "string_no_timeout"
61
- @namespaced.blpop("foo", 1).should eq(["foo", "string"])
62
- @namespaced.blpop("foo", 1).should eq(["foo", "ns:string"])
63
- @namespaced.blpop("foo").should eq(["foo", "string_no_timeout"])
64
- @namespaced.blpop("foo", 1).should eq(nil)
56
+ expect(@namespaced.blpop("foo", 1)).to eq(["foo", "string"])
57
+ expect(@namespaced.blpop("foo", 1)).to eq(["foo", "ns:string"])
58
+ expect(@namespaced.blpop("foo")).to eq(["foo", "string_no_timeout"])
59
+ expect(@namespaced.blpop("foo", 1)).to eq(nil)
65
60
  end
66
61
 
67
62
  it "should be able to use a namespace with del" do
@@ -69,125 +64,154 @@ describe "redis" do
69
64
  @namespaced.set('bar', 2000)
70
65
  @namespaced.set('baz', 3000)
71
66
  @namespaced.del 'foo'
72
- @namespaced.get('foo').should eq(nil)
67
+ expect(@namespaced.get('foo')).to eq(nil)
73
68
  @namespaced.del 'bar', 'baz'
74
- @namespaced.get('bar').should eq(nil)
75
- @namespaced.get('baz').should eq(nil)
69
+ expect(@namespaced.get('bar')).to eq(nil)
70
+ expect(@namespaced.get('baz')).to eq(nil)
71
+ end
72
+
73
+ it "should be able to use a namespace with unlink" do
74
+ @namespaced.set('foo', 1000)
75
+ @namespaced.set('bar', 2000)
76
+ @namespaced.set('baz', 3000)
77
+ @namespaced.unlink 'foo'
78
+ expect(@namespaced.get('foo')).to eq(nil)
79
+ @namespaced.unlink 'bar', 'baz'
80
+ expect(@namespaced.get('bar')).to eq(nil)
81
+ expect(@namespaced.get('baz')).to eq(nil)
76
82
  end
77
83
 
78
84
  it 'should be able to use a namespace with append' do
79
85
  @namespaced.set('foo', 'bar')
80
- @namespaced.append('foo','n').should eq(4)
81
- @namespaced.get('foo').should eq('barn')
82
- @redis.get('foo').should eq('bar')
86
+ expect(@namespaced.append('foo','n')).to eq(4)
87
+ expect(@namespaced.get('foo')).to eq('barn')
88
+ expect(@redis.get('foo')).to eq('bar')
83
89
  end
84
90
 
85
91
  it 'should be able to use a namespace with brpoplpush' do
86
92
  @namespaced.lpush('foo','bar')
87
- @namespaced.brpoplpush('foo','bar',0).should eq('bar')
88
- @namespaced.lrange('foo',0,-1).should eq([])
89
- @namespaced.lrange('bar',0,-1).should eq(['bar'])
93
+ expect(@namespaced.brpoplpush('foo','bar',0)).to eq('bar')
94
+ expect(@namespaced.lrange('foo',0,-1)).to eq([])
95
+ expect(@namespaced.lrange('bar',0,-1)).to eq(['bar'])
90
96
  end
91
97
 
92
98
  it 'should be able to use a namespace with getbit' do
93
99
  @namespaced.set('foo','bar')
94
- @namespaced.getbit('foo',1).should eq(1)
100
+ expect(@namespaced.getbit('foo',1)).to eq(1)
95
101
  end
96
102
 
97
103
  it 'should be able to use a namespace with getrange' do
98
104
  @namespaced.set('foo','bar')
99
- @namespaced.getrange('foo',0,-1).should eq('bar')
105
+ expect(@namespaced.getrange('foo',0,-1)).to eq('bar')
100
106
  end
101
107
 
102
108
  it 'should be able to use a namespace with linsert' do
103
109
  @namespaced.rpush('foo','bar')
104
110
  @namespaced.rpush('foo','barn')
105
111
  @namespaced.rpush('foo','bart')
106
- @namespaced.linsert('foo','BEFORE','barn','barf').should eq(4)
107
- @namespaced.lrange('foo',0,-1).should eq(['bar','barf','barn','bart'])
112
+ expect(@namespaced.linsert('foo','BEFORE','barn','barf')).to eq(4)
113
+ expect(@namespaced.lrange('foo',0,-1)).to eq(['bar','barf','barn','bart'])
108
114
  end
109
115
 
110
116
  it 'should be able to use a namespace with lpushx' do
111
- @namespaced.lpushx('foo','bar').should eq(0)
117
+ expect(@namespaced.lpushx('foo','bar')).to eq(0)
112
118
  @namespaced.lpush('foo','boo')
113
- @namespaced.lpushx('foo','bar').should eq(2)
114
- @namespaced.lrange('foo',0,-1).should eq(['bar','boo'])
119
+ expect(@namespaced.lpushx('foo','bar')).to eq(2)
120
+ expect(@namespaced.lrange('foo',0,-1)).to eq(['bar','boo'])
115
121
  end
116
122
 
117
123
  it 'should be able to use a namespace with rpushx' do
118
- @namespaced.rpushx('foo','bar').should eq(0)
124
+ expect(@namespaced.rpushx('foo','bar')).to eq(0)
119
125
  @namespaced.lpush('foo','boo')
120
- @namespaced.rpushx('foo','bar').should eq(2)
121
- @namespaced.lrange('foo',0,-1).should eq(['boo','bar'])
126
+ expect(@namespaced.rpushx('foo','bar')).to eq(2)
127
+ expect(@namespaced.lrange('foo',0,-1)).to eq(['boo','bar'])
122
128
  end
123
129
 
124
130
  it 'should be able to use a namespace with setbit' do
125
131
  @namespaced.setbit('virgin_key', 1, 1)
126
- @namespaced.exists('virgin_key').should be_true
127
- @namespaced.get('virgin_key').should eq(@namespaced.getrange('virgin_key',0,-1))
132
+ expect(@namespaced.exists?('virgin_key')).to be true
133
+ expect(@namespaced.get('virgin_key')).to eq(@namespaced.getrange('virgin_key',0,-1))
134
+ end
135
+
136
+ it 'should be able to use a namespace with exists' do
137
+ @namespaced.set('foo', 1000)
138
+ @namespaced.set('bar', 2000)
139
+ expect(@namespaced.exists('foo', 'bar')).to eq(2)
140
+ end
141
+
142
+ it 'should be able to use a namespace with exists?' do
143
+ @namespaced.set('foo', 1000)
144
+ @namespaced.set('bar', 2000)
145
+ expect(@namespaced.exists?('does_not_exist', 'bar')).to eq(true)
146
+ end
147
+
148
+ it 'should be able to use a namespace with bitpos' do
149
+ @namespaced.setbit('bit_map', 42, 1)
150
+ expect(@namespaced.bitpos('bit_map', 0)).to eq(0)
151
+ expect(@namespaced.bitpos('bit_map', 1)).to eq(42)
128
152
  end
129
153
 
130
154
  it 'should be able to use a namespace with setrange' do
131
155
  @namespaced.setrange('foo', 0, 'bar')
132
- @namespaced.get('foo').should eq('bar')
156
+ expect(@namespaced.get('foo')).to eq('bar')
133
157
 
134
158
  @namespaced.setrange('bar', 2, 'foo')
135
- @namespaced.get('bar').should eq("\000\000foo")
159
+ expect(@namespaced.get('bar')).to eq("\000\000foo")
136
160
  end
137
161
 
138
162
  it "should be able to use a namespace with mget" do
139
163
  @namespaced.set('foo', 1000)
140
164
  @namespaced.set('bar', 2000)
141
- @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
142
- @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({'foo'=>'1000', 'bar'=>'2000', 'baz' => nil})
165
+ expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
166
+ expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({'foo'=>'1000', 'bar'=>'2000', 'baz' => nil})
143
167
  end
144
168
 
145
169
  it "should be able to use a namespace with mset" do
146
170
  @namespaced.mset('foo', '1000', 'bar', '2000')
147
- @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
148
- @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
171
+ expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
172
+ expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
149
173
  @namespaced.mapped_mset('foo' => '3000', 'bar' => '5000')
150
- @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '3000', 'bar' => '5000' })
151
- @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '3000', 'bar' => '5000', 'baz' => nil})
174
+ expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '3000', 'bar' => '5000' })
175
+ expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '3000', 'bar' => '5000', 'baz' => nil})
152
176
  end
153
177
 
154
178
  it "should be able to use a namespace with msetnx" do
155
179
  @namespaced.msetnx('foo', '1000', 'bar', '2000')
156
- @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
157
- @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
180
+ expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
181
+ expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
158
182
  end
159
183
 
160
184
  it "should be able to use a namespace with mapped_msetnx" do
161
185
  @namespaced.set('foo','1')
162
- @namespaced.mapped_msetnx('foo'=>'1000', 'bar'=>'2000').should be_false
163
- @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1', 'bar' => nil })
164
- @namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000').should be_true
165
- @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1', 'bar' => '2000' })
186
+ expect(@namespaced.mapped_msetnx('foo'=>'1000', 'bar'=>'2000')).to be false
187
+ expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1', 'bar' => nil })
188
+ expect(@namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000')).to be true
189
+ expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1', 'bar' => '2000' })
166
190
  end
167
191
 
168
192
  it "should be able to use a namespace with hashes" do
169
193
  @namespaced.hset('foo', 'key', 'value')
170
194
  @namespaced.hset('foo', 'key1', 'value1')
171
- @namespaced.hget('foo', 'key').should eq('value')
172
- @namespaced.hgetall('foo').should eq({'key' => 'value', 'key1' => 'value1'})
173
- @namespaced.hlen('foo').should eq(2)
174
- @namespaced.hkeys('foo').should eq(['key', 'key1'])
195
+ expect(@namespaced.hget('foo', 'key')).to eq('value')
196
+ expect(@namespaced.hgetall('foo')).to eq({'key' => 'value', 'key1' => 'value1'})
197
+ expect(@namespaced.hlen('foo')).to eq(2)
198
+ expect(@namespaced.hkeys('foo')).to eq(['key', 'key1'])
175
199
  @namespaced.hmset('bar', 'key', 'value', 'key1', 'value1')
176
200
  @namespaced.hmget('bar', 'key', 'key1')
177
201
  @namespaced.hmset('bar', 'a_number', 1)
178
- @namespaced.hmget('bar', 'a_number').should eq(['1'])
202
+ expect(@namespaced.hmget('bar', 'a_number')).to eq(['1'])
179
203
  @namespaced.hincrby('bar', 'a_number', 3)
180
- @namespaced.hmget('bar', 'a_number').should eq(['4'])
181
- @namespaced.hgetall('bar').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
182
-
183
- @namespaced.hsetnx('foonx','nx',10).should be_true
184
- @namespaced.hsetnx('foonx','nx',12).should be_false
185
- @namespaced.hget('foonx','nx').should eq("10")
186
- @namespaced.hkeys('foonx').should eq(%w{ nx })
187
- @namespaced.hvals('foonx').should eq(%w{ 10 })
204
+ expect(@namespaced.hmget('bar', 'a_number')).to eq(['4'])
205
+ expect(@namespaced.hgetall('bar')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
206
+
207
+ expect(@namespaced.hsetnx('foonx','nx',10)).to be true
208
+ expect(@namespaced.hsetnx('foonx','nx',12)).to be false
209
+ expect(@namespaced.hget('foonx','nx')).to eq("10")
210
+ expect(@namespaced.hkeys('foonx')).to eq(%w{ nx })
211
+ expect(@namespaced.hvals('foonx')).to eq(%w{ 10 })
188
212
  @namespaced.mapped_hmset('baz', {'key' => 'value', 'key1' => 'value1', 'a_number' => 4})
189
- @namespaced.mapped_hmget('baz', 'key', 'key1', 'a_number').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
190
- @namespaced.hgetall('baz').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
213
+ expect(@namespaced.mapped_hmget('baz', 'key', 'key1', 'a_number')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
214
+ expect(@namespaced.hgetall('baz')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
191
215
  end
192
216
 
193
217
  it "should properly intersect three sets" do
@@ -198,7 +222,7 @@ describe "redis" do
198
222
  @namespaced.sadd('bar', 3)
199
223
  @namespaced.sadd('bar', 4)
200
224
  @namespaced.sadd('baz', 3)
201
- @namespaced.sinter('foo', 'bar', 'baz').should eq(%w( 3 ))
225
+ expect(@namespaced.sinter('foo', 'bar', 'baz')).to eq(%w( 3 ))
202
226
  end
203
227
 
204
228
  it "should properly union two sets" do
@@ -207,7 +231,7 @@ describe "redis" do
207
231
  @namespaced.sadd('bar', 2)
208
232
  @namespaced.sadd('bar', 3)
209
233
  @namespaced.sadd('bar', 4)
210
- @namespaced.sunion('foo', 'bar').sort.should eq(%w( 1 2 3 4 ))
234
+ expect(@namespaced.sunion('foo', 'bar').sort).to eq(%w( 1 2 3 4 ))
211
235
  end
212
236
 
213
237
  it "should properly union two sorted sets with options" do
@@ -216,8 +240,8 @@ describe "redis" do
216
240
  @namespaced.zadd('sort2', 2, 2)
217
241
  @namespaced.zadd('sort2', 3, 3)
218
242
  @namespaced.zadd('sort2', 4, 4)
219
- @namespaced.zunionstore('union', ['sort1', 'sort2'], :weights => [2, 1])
220
- @namespaced.zrevrange('union', 0, -1).should eq(%w( 2 4 3 1 ))
243
+ @namespaced.zunionstore('union', ['sort1', 'sort2'], weights: [2, 1])
244
+ expect(@namespaced.zrevrange('union', 0, -1)).to eq(%w( 2 4 3 1 ))
221
245
  end
222
246
 
223
247
  it "should properly union two sorted sets without options" do
@@ -227,7 +251,7 @@ describe "redis" do
227
251
  @namespaced.zadd('sort2', 3, 3)
228
252
  @namespaced.zadd('sort2', 4, 4)
229
253
  @namespaced.zunionstore('union', ['sort1', 'sort2'])
230
- @namespaced.zrevrange('union', 0, -1).should eq(%w( 4 2 3 1 ))
254
+ expect(@namespaced.zrevrange('union', 0, -1)).to eq(%w( 4 2 3 1 ))
231
255
  end
232
256
 
233
257
  it "should properly intersect two sorted sets without options" do
@@ -242,7 +266,7 @@ describe "redis" do
242
266
  @namespaced.zinterstore('inter', ['food', 'color'])
243
267
 
244
268
  inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
245
- inter_values.should =~ [['orange', 3.0], ['eggplant', 7.0]]
269
+ expect(inter_values).to match_array([['orange', 3.0], ['eggplant', 7.0]])
246
270
  end
247
271
 
248
272
  it "should properly intersect two sorted sets with options" do
@@ -257,7 +281,37 @@ describe "redis" do
257
281
  @namespaced.zinterstore('inter', ['food', 'color'], :aggregate => "min")
258
282
 
259
283
  inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
260
- inter_values.should =~ [['orange', 1.0], ['eggplant', 3.0]]
284
+ expect(inter_values).to match_array([['orange', 1.0], ['eggplant', 3.0]])
285
+ end
286
+
287
+ it "should return lexicographical range for sorted set" do
288
+ @namespaced.zadd('food', 0, 'orange')
289
+ @namespaced.zadd('food', 0, 'banana')
290
+ @namespaced.zadd('food', 0, 'eggplant')
291
+
292
+ values = @namespaced.zrangebylex('food', '[b', '(o')
293
+ expect(values).to match_array(['banana', 'eggplant'])
294
+ end
295
+
296
+ it "should return the number of elements removed from the set" do
297
+ @namespaced.zadd('food', 0, 'orange')
298
+ @namespaced.zadd('food', 0, 'banana')
299
+ @namespaced.zadd('food', 0, 'eggplant')
300
+
301
+ removed = @namespaced.zremrangebylex('food', '[b', '(o')
302
+ expect(removed).to eq(2)
303
+
304
+ values = @namespaced.zrange('food', 0, -1)
305
+ expect(values).to eq(['orange'])
306
+ end
307
+
308
+ it "should return reverce lexicographical range for sorted set" do
309
+ @namespaced.zadd('food', 0, 'orange')
310
+ @namespaced.zadd('food', 0, 'banana')
311
+ @namespaced.zadd('food', 0, 'eggplant')
312
+
313
+ values = @namespaced.zrevrangebylex('food', '(o', '[b')
314
+ expect(values).to match_array(['banana', 'eggplant'])
261
315
  end
262
316
 
263
317
  it "should add namespace to sort" do
@@ -268,24 +322,24 @@ describe "redis" do
268
322
  @namespaced.set('value_1', 'a')
269
323
  @namespaced.set('value_2', 'b')
270
324
 
271
- @namespaced.sort('foo').should eq(%w( 1 2 ))
272
- @namespaced.sort('foo', :limit => [0, 1]).should eq(%w( 1 ))
273
- @namespaced.sort('foo', :order => 'desc').should eq(%w( 2 1 ))
274
- @namespaced.sort('foo', :by => 'weight_*').should eq(%w( 2 1 ))
275
- @namespaced.sort('foo', :get => 'value_*').should eq(%w( a b ))
276
- @namespaced.sort('foo', :get => '#').should eq(%w( 1 2 ))
277
- @namespaced.sort('foo', :get => ['#', 'value_*']).should eq([["1", "a"], ["2", "b"]])
325
+ expect(@namespaced.sort('foo')).to eq(%w( 1 2 ))
326
+ expect(@namespaced.sort('foo', :limit => [0, 1])).to eq(%w( 1 ))
327
+ expect(@namespaced.sort('foo', :order => 'desc')).to eq(%w( 2 1 ))
328
+ expect(@namespaced.sort('foo', :by => 'weight_*')).to eq(%w( 2 1 ))
329
+ expect(@namespaced.sort('foo', :get => 'value_*')).to eq(%w( a b ))
330
+ expect(@namespaced.sort('foo', :get => '#')).to eq(%w( 1 2 ))
331
+ expect(@namespaced.sort('foo', :get => ['#', 'value_*'])).to eq([["1", "a"], ["2", "b"]])
278
332
 
279
333
  @namespaced.sort('foo', :store => 'result')
280
- @namespaced.lrange('result', 0, -1).should eq(%w( 1 2 ))
334
+ expect(@namespaced.lrange('result', 0, -1)).to eq(%w( 1 2 ))
281
335
  end
282
336
 
283
337
  it "should yield the correct list of keys" do
284
338
  @namespaced.set("foo", 1)
285
339
  @namespaced.set("bar", 2)
286
340
  @namespaced.set("baz", 3)
287
- @namespaced.keys("*").sort.should eq(%w( bar baz foo ))
288
- @namespaced.keys.sort.should eq(%w( bar baz foo ))
341
+ expect(@namespaced.keys("*").sort).to eq(%w( bar baz foo ))
342
+ expect(@namespaced.keys.sort).to eq(%w( bar baz foo ))
289
343
  end
290
344
 
291
345
  it "should add namepsace to multi blocks" do
@@ -294,7 +348,7 @@ describe "redis" do
294
348
  r.del "foo"
295
349
  r.mapped_hmset "foo", {"key1" => "value1"}
296
350
  end
297
- @namespaced.hgetall("foo").should eq({"key1" => "value1"})
351
+ expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
298
352
  end
299
353
 
300
354
  it "should pass through multi commands without block" do
@@ -305,14 +359,14 @@ describe "redis" do
305
359
  @namespaced.mapped_hmset "foo", {"key1" => "value1"}
306
360
  @namespaced.exec
307
361
 
308
- @namespaced.hgetall("foo").should eq({"key1" => "value1"})
362
+ expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
309
363
  end
310
364
 
311
365
  it 'should return futures without attempting to remove namespaces' do
312
366
  @namespaced.multi do
313
367
  @future = @namespaced.keys('*')
314
368
  end
315
- @future.class.should be(Redis::Future)
369
+ expect(@future.class).to be(Redis::Future)
316
370
  end
317
371
 
318
372
  it "should add namespace to pipelined blocks" do
@@ -321,7 +375,7 @@ describe "redis" do
321
375
  r.del "foo"
322
376
  r.mapped_hmset "foo", {"key1" => "value1"}
323
377
  end
324
- @namespaced.hgetall("foo").should eq({"key1" => "value1"})
378
+ expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
325
379
  end
326
380
 
327
381
  it "should returned response array from pipelined block" do
@@ -330,65 +384,125 @@ describe "redis" do
330
384
  r.get("foo")
331
385
  r.get("key")
332
386
  end
333
- result.should eq(["bar", "value"])
387
+ expect(result).to eq(["bar", "value"])
388
+ end
389
+
390
+ it "is thread safe for multi blocks" do
391
+ mon = Monitor.new
392
+ entered = false
393
+ entered_cond = mon.new_cond
394
+
395
+ thread = Thread.new do
396
+ mon.synchronize do
397
+ entered_cond.wait_until { entered }
398
+ @namespaced.multi
399
+ end
400
+ end
401
+
402
+ @namespaced.multi do |transaction|
403
+ entered = true
404
+ mon.synchronize { entered_cond.signal }
405
+ thread.join(0.1)
406
+ transaction.get("foo")
407
+ end
408
+ thread.join
334
409
  end
335
410
 
336
411
  it "should add namespace to strlen" do
337
412
  @namespaced.set("mykey", "123456")
338
- @namespaced.strlen("mykey").should eq(6)
413
+ expect(@namespaced.strlen("mykey")).to eq(6)
339
414
  end
340
415
 
341
416
  it "should not add namespace to echo" do
342
- @namespaced.echo(123).should eq("123")
417
+ expect(@namespaced.echo(123)).to eq("123")
343
418
  end
344
419
 
345
420
  it 'should not add namespace to disconnect!' do
346
- expect(@redis).to receive(:disconnect!).with().and_call_original
421
+ expect(@redis).to receive(:disconnect!).with(no_args).and_call_original
347
422
 
348
423
  expect(@namespaced.disconnect!).to be nil
349
424
  end
350
425
 
351
426
  it "can change its namespace" do
352
- @namespaced.get('foo').should eq(nil)
427
+ expect(@namespaced.get('foo')).to eq(nil)
353
428
  @namespaced.set('foo', 'chris')
354
- @namespaced.get('foo').should eq('chris')
429
+ expect(@namespaced.get('foo')).to eq('chris')
355
430
 
356
- @namespaced.namespace.should eq(:ns)
431
+ expect(@namespaced.namespace).to eq(:ns)
357
432
  @namespaced.namespace = :spec
358
- @namespaced.namespace.should eq(:spec)
433
+ expect(@namespaced.namespace).to eq(:spec)
359
434
 
360
- @namespaced.get('foo').should eq(nil)
435
+ expect(@namespaced.get('foo')).to eq(nil)
361
436
  @namespaced.set('foo', 'chris')
362
- @namespaced.get('foo').should eq('chris')
437
+ expect(@namespaced.get('foo')).to eq('chris')
363
438
  end
364
439
 
365
440
  it "can accept a temporary namespace" do
366
- @namespaced.namespace.should eq(:ns)
367
- @namespaced.get('foo').should eq(nil)
441
+ expect(@namespaced.namespace).to eq(:ns)
442
+ expect(@namespaced.get('foo')).to eq(nil)
368
443
 
369
444
  @namespaced.namespace(:spec) do |temp_ns|
370
- temp_ns.namespace.should eq(:spec)
371
- temp_ns.get('foo').should eq(nil)
445
+ expect(temp_ns.namespace).to eq(:spec)
446
+ expect(temp_ns.get('foo')).to eq(nil)
372
447
  temp_ns.set('foo', 'jake')
373
- temp_ns.get('foo').should eq('jake')
448
+ expect(temp_ns.get('foo')).to eq('jake')
374
449
  end
375
450
 
376
- @namespaced.namespace.should eq(:ns)
377
- @namespaced.get('foo').should eq(nil)
451
+ expect(@namespaced.namespace).to eq(:ns)
452
+ expect(@namespaced.get('foo')).to eq(nil)
378
453
  end
379
454
 
380
455
  it "should respond to :namespace=" do
381
- @namespaced.respond_to?(:namespace=).should eq(true)
456
+ expect(@namespaced.respond_to?(:namespace=)).to eq(true)
382
457
  end
383
458
 
384
459
  it "should respond to :warning=" do
385
- @namespaced.respond_to?(:warning=).should == true
460
+ expect(@namespaced.respond_to?(:warning=)).to eq(true)
386
461
  end
387
462
 
388
463
  it "should raise an exception when an unknown command is passed" do
389
464
  expect { @namespaced.unknown('foo') }.to raise_exception NoMethodError
390
465
  end
391
466
 
467
+ describe '#inspect' do
468
+ let(:single_level_names) { %i[first] }
469
+ let(:double_level_names) { %i[first second] }
470
+ let(:triple_level_names) { %i[first second third] }
471
+ let(:namespace_builder) do
472
+ ->(redis, *namespaces) { namespaces.reduce(redis) { |r, n| Redis::Namespace.new(n, redis: r) } }
473
+ end
474
+ let(:regexp_builder) do
475
+ ->(*namespaces) { %r{/#{namespaces.join(':')}>\z} }
476
+ end
477
+
478
+ context 'when one namespace' do
479
+ let(:single_namespaced) { namespace_builder.call(@redis, *single_level_names) }
480
+ let(:regexp) { regexp_builder.call(*single_level_names) }
481
+
482
+ it 'should have correct ending of inspect string' do
483
+ expect(regexp =~ single_namespaced.inspect).not_to be(nil)
484
+ end
485
+ end
486
+
487
+ context 'when two namespaces' do
488
+ let(:double_namespaced) { namespace_builder.call(@redis, *double_level_names) }
489
+ let(:regexp) { regexp_builder.call(*double_level_names) }
490
+
491
+ it 'should have correct ending of inspect string' do
492
+ expect(regexp =~ double_namespaced.inspect).not_to be(nil)
493
+ end
494
+ end
495
+
496
+ context 'when three namespaces' do
497
+ let(:triple_namespaced) { namespace_builder.call(@redis, *triple_level_names) }
498
+ let(:regexp) { regexp_builder.call(*triple_level_names) }
499
+
500
+ it 'should have correct ending of inspect string' do
501
+ expect(regexp =~ triple_namespaced.inspect).not_to be(nil)
502
+ end
503
+ end
504
+ end
505
+
392
506
  # Redis 2.6 RC reports its version as 2.5.
393
507
  if @redis_version >= Gem::Version.new("2.5.0")
394
508
  describe "redis 2.6 commands" do
@@ -422,7 +536,7 @@ describe "redis" do
422
536
  v = @namespaced.dump("foo")
423
537
  @redis.del("ns:foo")
424
538
 
425
- expect(@namespaced.restore("foo", 1000, v)).to be_true
539
+ expect(@namespaced.restore("foo", 1000, v)).to be_truthy
426
540
  expect(@redis.get("ns:foo")).to eq 'a'
427
541
  expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
428
542
 
@@ -430,72 +544,72 @@ describe "redis" do
430
544
  w = @namespaced.dump("bar")
431
545
  @redis.del("ns:bar")
432
546
 
433
- expect(@namespaced.restore("bar", 1000, w)).to be_true
547
+ expect(@namespaced.restore("bar", 1000, w)).to be_truthy
434
548
  expect(@redis.lrange('ns:bar', 0, -1)).to eq %w(b c d)
435
549
  expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
436
550
  end
437
551
 
438
552
  it "should namespace hincrbyfloat" do
439
553
  @namespaced.hset('mykey', 'field', 10.50)
440
- @namespaced.hincrbyfloat('mykey', 'field', 0.1).should eq(10.6)
554
+ expect(@namespaced.hincrbyfloat('mykey', 'field', 0.1)).to eq(10.6)
441
555
  end
442
556
 
443
557
  it "should namespace incrbyfloat" do
444
558
  @namespaced.set('mykey', 10.50)
445
- @namespaced.incrbyfloat('mykey', 0.1).should eq(10.6)
559
+ expect(@namespaced.incrbyfloat('mykey', 0.1)).to eq(10.6)
446
560
  end
447
561
 
448
562
  it "should namespace object" do
449
563
  @namespaced.set('foo', 1000)
450
- @namespaced.object('encoding', 'foo').should eq('int')
564
+ expect(@namespaced.object('encoding', 'foo')).to eq('int')
451
565
  end
452
566
 
453
567
  it "should namespace persist" do
454
568
  @namespaced.set('mykey', 'Hello')
455
569
  @namespaced.expire('mykey', 60)
456
- @namespaced.persist('mykey').should eq(true)
457
- @namespaced.ttl('mykey').should eq(-1)
570
+ expect(@namespaced.persist('mykey')).to eq(true)
571
+ expect(@namespaced.ttl('mykey')).to eq(-1)
458
572
  end
459
573
 
460
574
  it "should namespace pexpire" do
461
575
  @namespaced.set('mykey', 'Hello')
462
- @namespaced.pexpire('mykey', 60000).should eq(true)
576
+ expect(@namespaced.pexpire('mykey', 60000)).to eq(true)
463
577
  end
464
578
 
465
579
  it "should namespace pexpireat" do
466
580
  @namespaced.set('mykey', 'Hello')
467
- @namespaced.pexpire('mykey', 1555555555005).should eq(true)
581
+ expect(@namespaced.pexpire('mykey', 1555555555005)).to eq(true)
468
582
  end
469
583
 
470
584
  it "should namespace psetex" do
471
- @namespaced.psetex('mykey', 10000, 'Hello').should eq('OK')
472
- @namespaced.get('mykey').should eq('Hello')
585
+ expect(@namespaced.psetex('mykey', 10000, 'Hello')).to eq('OK')
586
+ expect(@namespaced.get('mykey')).to eq('Hello')
473
587
  end
474
588
 
475
589
  it "should namespace pttl" do
476
590
  @namespaced.set('mykey', 'Hello')
477
591
  @namespaced.expire('mykey', 1)
478
- @namespaced.pttl('mykey').should >= 0
592
+ expect(@namespaced.pttl('mykey')).to be >= 0
479
593
  end
480
594
 
481
595
  it "should namespace eval keys passed in as array args" do
482
- @namespaced.
483
- eval("return {KEYS[1], KEYS[2]}", %w[k1 k2], %w[arg1 arg2]).
484
- should eq(%w[ns:k1 ns:k2])
596
+ expect(@namespaced.
597
+ eval("return {KEYS[1], KEYS[2]}", %w[k1 k2], %w[arg1 arg2])).
598
+ to eq(%w[ns:k1 ns:k2])
485
599
  end
486
600
 
487
601
  it "should namespace eval keys passed in as hash args" do
488
- @namespaced.
489
- eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
490
- should eq(%w[ns:k1 ns:k2])
602
+ expect(@namespaced.
603
+ eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
604
+ to eq(%w[ns:k1 ns:k2])
491
605
  end
492
606
 
493
607
  it "should namespace eval keys passed in as hash args unmodified" do
494
608
  args = { :keys => %w[k1 k2], :argv => %w[arg1 arg2] }
495
609
  args.freeze
496
- @namespaced.
497
- eval("return {KEYS[1], KEYS[2]}", args).
498
- should eq(%w[ns:k1 ns:k2])
610
+ expect(@namespaced.
611
+ eval("return {KEYS[1], KEYS[2]}", args)).
612
+ to eq(%w[ns:k1 ns:k2])
499
613
  end
500
614
 
501
615
  context '#evalsha' do
@@ -504,23 +618,23 @@ describe "redis" do
504
618
  end
505
619
 
506
620
  it "should namespace evalsha keys passed in as array args" do
507
- @namespaced.
508
- evalsha(sha, %w[k1 k2], %w[arg1 arg2]).
509
- should eq(%w[ns:k1 ns:k2])
621
+ expect(@namespaced.
622
+ evalsha(sha, %w[k1 k2], %w[arg1 arg2])).
623
+ to eq(%w[ns:k1 ns:k2])
510
624
  end
511
625
 
512
626
  it "should namespace evalsha keys passed in as hash args" do
513
- @namespaced.
514
- evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
515
- should eq(%w[ns:k1 ns:k2])
627
+ expect(@namespaced.
628
+ evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
629
+ to eq(%w[ns:k1 ns:k2])
516
630
  end
517
631
 
518
632
  it "should namespace evalsha keys passed in as hash args unmodified" do
519
633
  args = { :keys => %w[k1 k2], :argv => %w[arg1 arg2] }
520
634
  args.freeze
521
- @namespaced.
522
- evalsha(sha, args).
523
- should eq(%w[ns:k1 ns:k2])
635
+ expect(@namespaced.
636
+ evalsha(sha, args)).
637
+ to eq(%w[ns:k1 ns:k2])
524
638
  end
525
639
  end
526
640
 
@@ -529,13 +643,13 @@ describe "redis" do
529
643
  let(:sha) { @redis.script(:load, "return {KEYS[1], KEYS[2]}") }
530
644
 
531
645
  it "should namespace eval keys passed in as hash args" do
532
- nested_namespace.
533
- eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
534
- should eq(%w[ns:nest:k1 ns:nest:k2])
646
+ expect(nested_namespace.
647
+ eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
648
+ to eq(%w[ns:nest:k1 ns:nest:k2])
535
649
  end
536
650
  it "should namespace evalsha keys passed in as hash args" do
537
- nested_namespace.evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
538
- should eq(%w[ns:nest:k1 ns:nest:k2])
651
+ expect(nested_namespace.evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
652
+ to eq(%w[ns:nest:k1 ns:nest:k2])
539
653
  end
540
654
  end
541
655
  end
@@ -564,13 +678,13 @@ describe "redis" do
564
678
  context 'when :match supplied' do
565
679
  it 'should retrieve the proper keys' do
566
680
  _, result = @namespaced.scan(0, :match => 'zeta:*', :count => 1000)
567
- result.should =~ matching_namespaced_keys
681
+ expect(result).to match_array(matching_namespaced_keys)
568
682
  end
569
683
  end
570
684
  context 'without :match supplied' do
571
685
  it 'should retrieve the proper keys' do
572
686
  _, result = @namespaced.scan(0, :count => 1000)
573
- result.should =~ namespaced_keys
687
+ expect(result).to match_array(namespaced_keys)
574
688
  end
575
689
  end
576
690
  end if Redis.current.respond_to?(:scan)
@@ -581,13 +695,13 @@ describe "redis" do
581
695
  it 'should yield unnamespaced' do
582
696
  results = []
583
697
  @namespaced.scan_each(:match => 'zeta:*', :count => 1000) {|k| results << k }
584
- results.should =~ matching_namespaced_keys
698
+ expect(results).to match_array(matching_namespaced_keys)
585
699
  end
586
700
  end
587
701
  context 'without a block' do
588
702
  it 'should return an Enumerator that un-namespaces' do
589
703
  enum = @namespaced.scan_each(:match => 'zeta:*', :count => 1000)
590
- enum.to_a.should =~ matching_namespaced_keys
704
+ expect(enum.to_a).to match_array(matching_namespaced_keys)
591
705
  end
592
706
  end
593
707
  end
@@ -596,13 +710,13 @@ describe "redis" do
596
710
  it 'should yield unnamespaced' do
597
711
  results = []
598
712
  @namespaced.scan_each(:count => 1000){ |k| results << k }
599
- results.should =~ namespaced_keys
713
+ expect(results).to match_array(namespaced_keys)
600
714
  end
601
715
  end
602
716
  context 'without a block' do
603
717
  it 'should return an Enumerator that un-namespaces' do
604
718
  enum = @namespaced.scan_each(:count => 1000)
605
- enum.to_a.should =~ namespaced_keys
719
+ expect(enum.to_a).to match_array(namespaced_keys)
606
720
  end
607
721
  end
608
722
  end
@@ -625,13 +739,13 @@ describe "redis" do
625
739
  context 'when supplied :match' do
626
740
  it 'should retrieve the proper keys' do
627
741
  _, results = @namespaced.hscan('hsh', 0, :match => 'zeta:*')
628
- results.should =~ hash_matching_subset.to_a
742
+ expect(results).to match_array(hash_matching_subset.to_a)
629
743
  end
630
744
  end
631
745
  context 'without :match supplied' do
632
746
  it 'should retrieve all hash keys' do
633
747
  _, results = @namespaced.hscan('hsh', 0)
634
- results.should =~ @redis.hgetall('ns:hsh').to_a
748
+ expect(results).to match_array(@redis.hgetall('ns:hsh').to_a)
635
749
  end
636
750
  end
637
751
  end if Redis.current.respond_to?(:hscan)
@@ -642,13 +756,13 @@ describe "redis" do
642
756
  it 'should yield the correct hash keys unchanged' do
643
757
  results = []
644
758
  @namespaced.hscan_each('hsh', :match => 'zeta:*', :count => 1000) { |kv| results << kv}
645
- results.should =~ hash_matching_subset.to_a
759
+ expect(results).to match_array(hash_matching_subset.to_a)
646
760
  end
647
761
  end
648
762
  context 'without a block' do
649
763
  it 'should return an Enumerator that yields the correct hash keys unchanged' do
650
764
  enum = @namespaced.hscan_each('hsh', :match => 'zeta:*', :count => 1000)
651
- enum.to_a.should =~ hash_matching_subset.to_a
765
+ expect(enum.to_a).to match_array(hash_matching_subset.to_a)
652
766
  end
653
767
  end
654
768
  end
@@ -657,13 +771,13 @@ describe "redis" do
657
771
  it 'should yield all hash keys unchanged' do
658
772
  results = []
659
773
  @namespaced.hscan_each('hsh', :count => 1000){ |k| results << k }
660
- results.should =~ hash.to_a
774
+ expect(results).to match_array(hash.to_a)
661
775
  end
662
776
  end
663
777
  context 'without a block' do
664
778
  it 'should return an Enumerator that yields all keys unchanged' do
665
779
  enum = @namespaced.hscan_each('hsh', :count => 1000)
666
- enum.to_a.should =~ hash.to_a
780
+ expect(enum.to_a).to match_array(hash.to_a)
667
781
  end
668
782
  end
669
783
  end
@@ -686,13 +800,13 @@ describe "redis" do
686
800
  context 'when supplied :match' do
687
801
  it 'should retrieve the matching set members from the proper set' do
688
802
  _, results = @namespaced.sscan('set', 0, :match => 'zeta:*', :count => 1000)
689
- results.should =~ matching_subset
803
+ expect(results).to match_array(matching_subset)
690
804
  end
691
805
  end
692
806
  context 'without :match supplied' do
693
807
  it 'should retrieve all set members from the proper set' do
694
808
  _, results = @namespaced.sscan('set', 0, :count => 1000)
695
- results.should =~ set
809
+ expect(results).to match_array(set)
696
810
  end
697
811
  end
698
812
  end if Redis.current.respond_to?(:sscan)
@@ -703,13 +817,13 @@ describe "redis" do
703
817
  it 'should yield the correct hset elements unchanged' do
704
818
  results = []
705
819
  @namespaced.sscan_each('set', :match => 'zeta:*', :count => 1000) { |kv| results << kv}
706
- results.should =~ matching_subset
820
+ expect(results).to match_array(matching_subset)
707
821
  end
708
822
  end
709
823
  context 'without a block' do
710
824
  it 'should return an Enumerator that yields the correct set elements unchanged' do
711
825
  enum = @namespaced.sscan_each('set', :match => 'zeta:*', :count => 1000)
712
- enum.to_a.should =~ matching_subset
826
+ expect(enum.to_a).to match_array(matching_subset)
713
827
  end
714
828
  end
715
829
  end
@@ -718,13 +832,13 @@ describe "redis" do
718
832
  it 'should yield all set elements unchanged' do
719
833
  results = []
720
834
  @namespaced.sscan_each('set', :count => 1000){ |k| results << k }
721
- results.should =~ set
835
+ expect(results).to match_array(set)
722
836
  end
723
837
  end
724
838
  context 'without a block' do
725
839
  it 'should return an Enumerator that yields all set elements unchanged' do
726
840
  enum = @namespaced.sscan_each('set', :count => 1000)
727
- enum.to_a.should =~ set
841
+ expect(enum.to_a).to match_array(set)
728
842
  end
729
843
  end
730
844
  end
@@ -748,14 +862,14 @@ describe "redis" do
748
862
  it 'should retrieve the matching set elements and their scores' do
749
863
  results = []
750
864
  @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000) { |ms| results << ms }
751
- results.should =~ hash_matching_subset.to_a
865
+ expect(results).to match_array(hash_matching_subset.to_a)
752
866
  end
753
867
  end
754
868
  context 'without :match supplied' do
755
869
  it 'should retrieve all set elements and their scores' do
756
870
  results = []
757
871
  @namespaced.zscan_each('zset', :count => 1000) { |ms| results << ms }
758
- results.should =~ hash.to_a
872
+ expect(results).to match_array(hash.to_a)
759
873
  end
760
874
  end
761
875
  end if Redis.current.respond_to?(:zscan)
@@ -766,13 +880,13 @@ describe "redis" do
766
880
  it 'should yield the correct set elements and scores unchanged' do
767
881
  results = []
768
882
  @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000) { |ms| results << ms}
769
- results.should =~ hash_matching_subset.to_a
883
+ expect(results).to match_array(hash_matching_subset.to_a)
770
884
  end
771
885
  end
772
886
  context 'without a block' do
773
887
  it 'should return an Enumerator that yields the correct set elements and scoresunchanged' do
774
888
  enum = @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000)
775
- enum.to_a.should =~ hash_matching_subset.to_a
889
+ expect(enum.to_a).to match_array(hash_matching_subset.to_a)
776
890
  end
777
891
  end
778
892
  end
@@ -781,13 +895,13 @@ describe "redis" do
781
895
  it 'should yield all set elements and scores unchanged' do
782
896
  results = []
783
897
  @namespaced.zscan_each('zset', :count => 1000){ |ms| results << ms }
784
- results.should =~ hash.to_a
898
+ expect(results).to match_array(hash.to_a)
785
899
  end
786
900
  end
787
901
  context 'without a block' do
788
902
  it 'should return an Enumerator that yields all set elements and scores unchanged' do
789
903
  enum = @namespaced.zscan_each('zset', :count => 1000)
790
- enum.to_a.should =~ hash.to_a
904
+ expect(enum.to_a).to match_array(hash.to_a)
791
905
  end
792
906
  end
793
907
  end
@@ -799,12 +913,12 @@ describe "redis" do
799
913
  if @redis_version >= Gem::Version.new("2.8.9")
800
914
  it 'should namespace pfadd' do
801
915
  5.times { |n| @namespaced.pfadd("pf", n) }
802
- @redis.pfcount("ns:pf").should == 5
916
+ expect(@redis.pfcount("ns:pf")).to eq(5)
803
917
  end
804
918
 
805
919
  it 'should namespace pfcount' do
806
920
  5.times { |n| @redis.pfadd("ns:pf", n) }
807
- @namespaced.pfcount("pf").should == 5
921
+ expect(@namespaced.pfcount("pf")).to eq(5)
808
922
  end
809
923
 
810
924
  it 'should namespace pfmerge' do
@@ -814,7 +928,18 @@ describe "redis" do
814
928
  end
815
929
 
816
930
  @namespaced.pfmerge("pfc", "pfa", "pfb")
817
- @redis.pfcount("ns:pfc").should == 10
931
+ expect(@redis.pfcount("ns:pfc")).to eq(10)
932
+ end
933
+ end
934
+
935
+ describe :full_namespace do
936
+ it "should return the full namespace including sub namespaces" do
937
+ sub_namespaced = Redis::Namespace.new(:sub1, :redis => @namespaced)
938
+ sub_sub_namespaced = Redis::Namespace.new(:sub2, :redis => sub_namespaced)
939
+
940
+ expect(@namespaced.full_namespace).to eql("ns")
941
+ expect(sub_namespaced.full_namespace).to eql("ns:sub1")
942
+ expect(sub_sub_namespaced.full_namespace).to eql("ns:sub1:sub2")
818
943
  end
819
944
  end
820
945
  end