redis-namespace 1.5.3 → 1.9.0

data/spec/redis_spec.rb

@@ -3,49 +3,60 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe "redis" do
-  @redis_version = Gem::Version.new(Redis.current.info["redis_version"])
+  @redis_version = Gem::Version.new(Redis.new.info["redis_version"])
+  let(:redis_client) { @redis.respond_to?(:_client) ? @redis._client : @redis.client}
 
-  before(:all) do
+  before(:each) do
     # use database 15 for testing so we dont accidentally step on your real data
     @redis = Redis.new :db => 15
-  end
-
-  before(:each) do
-    @namespaced = Redis::Namespace.new(:ns, :redis => @redis)
     @redis.flushdb
-    @redis['foo'] = 'bar'
+    @namespaced = Redis::Namespace.new(:ns, :redis => @redis)
+    @redis.set('foo', 'bar')
   end
 
-  after(:each) do
-    @redis.flushdb
+  # redis-rb 3.3.4+
+  it "should inject :namespace into connection info" do
+    info = @redis.connection.merge(:namespace => :ns)
+    expect(@namespaced.connection).to eq(info)
   end
 
-  after(:all) do
-    @redis.quit
+  it "proxies `client` to the _client and deprecated" do
+    expect(@namespaced.client).to eq(redis_client)
   end
 
-  it "proxies `client` to the client" do
-    @namespaced.client.should eq(@redis.client)
+  it "proxies `_client` to the _client" do
+    expect(@namespaced._client).to eq(redis_client)
   end
 
   it "should be able to use a namespace" do
-    @namespaced['foo'].should eq(nil)
-    @namespaced['foo'] = 'chris'
-    @namespaced['foo'].should eq('chris')
-    @redis['foo'] = 'bob'
-    @redis['foo'].should eq('bob')
+    expect(@namespaced.get('foo')).to eq(nil)
+    @namespaced.set('foo', 'chris')
+    expect(@namespaced.get('foo')).to eq('chris')
+    @redis.set('foo', 'bob')
+    expect(@redis.get('foo')).to eq('bob')
 
     @namespaced.incrby('counter', 2)
-    @namespaced['counter'].to_i.should eq(2)
-    @redis['counter'].should eq(nil)
-    @namespaced.type('counter').should eq('string')
+    expect(@namespaced.get('counter').to_i).to eq(2)
+    expect(@redis.get('counter')).to eq(nil)
+    expect(@namespaced.type('counter')).to eq('string')
+  end
+
+  it "should work with Proc namespaces" do
+    namespace = Proc.new { :dynamic_ns }
+    namespaced = Redis::Namespace.new(namespace, redis: @redis)
+
+    expect(namespaced.get('foo')).to eq(nil)
+    namespaced.set('foo', 'chris')
+    expect(namespaced.get('foo')).to eq('chris')
+    @redis.set('foo', 'bob')
+    expect(@redis.get('foo')).to eq('bob')
   end
 
   context 'when sending capital commands (issue 68)' do
     it 'should be able to use a namespace' do
       @namespaced.send('SET', 'fubar', 'quux')
-      @redis.get('fubar').should be_nil
-      @namespaced.get('fubar').should eq 'quux'
+      expect(@redis.get('fubar')).to be_nil
+      expect(@namespaced.get('fubar')).to eq 'quux'
     end
   end
 
@@ -53,136 +64,179 @@ describe "redis" do
     @namespaced.rpush "foo", "string"
     @namespaced.rpush "foo", "ns:string"
     @namespaced.rpush "foo", "string_no_timeout"
-    @namespaced.blpop("foo", 1).should eq(["foo", "string"])
-    @namespaced.blpop("foo", 1).should eq(["foo", "ns:string"])
-    @namespaced.blpop("foo").should eq(["foo", "string_no_timeout"])
-    @namespaced.blpop("foo", 1).should eq(nil)
+    expect(@namespaced.blpop("foo", 1)).to eq(["foo", "string"])
+    expect(@namespaced.blpop("foo", 1)).to eq(["foo", "ns:string"])
+    expect(@namespaced.blpop("foo")).to eq(["foo", "string_no_timeout"])
+    expect(@namespaced.blpop("foo", 1)).to eq(nil)
   end
 
   it "should be able to use a namespace with del" do
-    @namespaced['foo'] = 1000
-    @namespaced['bar'] = 2000
-    @namespaced['baz'] = 3000
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    @namespaced.set('baz', 3000)
     @namespaced.del 'foo'
-    @namespaced['foo'].should eq(nil)
+    expect(@namespaced.get('foo')).to eq(nil)
     @namespaced.del 'bar', 'baz'
-    @namespaced['bar'].should eq(nil)
-    @namespaced['baz'].should eq(nil)
+    expect(@namespaced.get('bar')).to eq(nil)
+    expect(@namespaced.get('baz')).to eq(nil)
+  end
+
+  it "should be able to use a namespace with unlink" do
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    @namespaced.set('baz', 3000)
+    @namespaced.unlink 'foo'
+    expect(@namespaced.get('foo')).to eq(nil)
+    @namespaced.unlink 'bar', 'baz'
+    expect(@namespaced.get('bar')).to eq(nil)
+    expect(@namespaced.get('baz')).to eq(nil)
   end
 
   it 'should be able to use a namespace with append' do
-    @namespaced['foo'] = 'bar'
-    @namespaced.append('foo','n').should eq(4)
-    @namespaced['foo'].should eq('barn')
-    @redis['foo'].should eq('bar')
+    @namespaced.set('foo', 'bar')
+    expect(@namespaced.append('foo','n')).to eq(4)
+    expect(@namespaced.get('foo')).to eq('barn')
+    expect(@redis.get('foo')).to eq('bar')
   end
 
   it 'should be able to use a namespace with brpoplpush' do
     @namespaced.lpush('foo','bar')
-    @namespaced.brpoplpush('foo','bar',0).should eq('bar')
-    @namespaced.lrange('foo',0,-1).should eq([])
-    @namespaced.lrange('bar',0,-1).should eq(['bar'])
+    expect(@namespaced.brpoplpush('foo','bar',0)).to eq('bar')
+    expect(@namespaced.lrange('foo',0,-1)).to eq([])
+    expect(@namespaced.lrange('bar',0,-1)).to eq(['bar'])
+  end
+
+  it "should be able to use a namespace with getex" do
+    expect(@namespaced.set('mykey', 'Hello')).to eq('OK')
+    expect(@namespaced.getex('mykey', ex: 50)).to eq('Hello')
+    expect(@namespaced.get('mykey')).to eq('Hello')
+    expect(@namespaced.ttl('mykey')).to eq(50)
   end
 
   it 'should be able to use a namespace with getbit' do
     @namespaced.set('foo','bar')
-    @namespaced.getbit('foo',1).should eq(1)
+    expect(@namespaced.getbit('foo',1)).to eq(1)
   end
 
   it 'should be able to use a namespace with getrange' do
     @namespaced.set('foo','bar')
-    @namespaced.getrange('foo',0,-1).should eq('bar')
+    expect(@namespaced.getrange('foo',0,-1)).to eq('bar')
   end
 
   it 'should be able to use a namespace with linsert' do
     @namespaced.rpush('foo','bar')
     @namespaced.rpush('foo','barn')
     @namespaced.rpush('foo','bart')
-    @namespaced.linsert('foo','BEFORE','barn','barf').should eq(4)
-    @namespaced.lrange('foo',0,-1).should eq(['bar','barf','barn','bart'])
+    expect(@namespaced.linsert('foo','BEFORE','barn','barf')).to eq(4)
+    expect(@namespaced.lrange('foo',0,-1)).to eq(['bar','barf','barn','bart'])
   end
 
   it 'should be able to use a namespace with lpushx' do
-    @namespaced.lpushx('foo','bar').should eq(0)
+    expect(@namespaced.lpushx('foo','bar')).to eq(0)
     @namespaced.lpush('foo','boo')
-    @namespaced.lpushx('foo','bar').should eq(2)
-    @namespaced.lrange('foo',0,-1).should eq(['bar','boo'])
+    expect(@namespaced.lpushx('foo','bar')).to eq(2)
+    expect(@namespaced.lrange('foo',0,-1)).to eq(['bar','boo'])
   end
 
   it 'should be able to use a namespace with rpushx' do
-    @namespaced.rpushx('foo','bar').should eq(0)
+    expect(@namespaced.rpushx('foo','bar')).to eq(0)
     @namespaced.lpush('foo','boo')
-    @namespaced.rpushx('foo','bar').should eq(2)
-    @namespaced.lrange('foo',0,-1).should eq(['boo','bar'])
+    expect(@namespaced.rpushx('foo','bar')).to eq(2)
+    expect(@namespaced.lrange('foo',0,-1)).to eq(['boo','bar'])
   end
 
   it 'should be able to use a namespace with setbit' do
     @namespaced.setbit('virgin_key', 1, 1)
-    @namespaced.exists('virgin_key').should be_true
-    @namespaced.get('virgin_key').should eq(@namespaced.getrange('virgin_key',0,-1))
+    expect(@namespaced.exists?('virgin_key')).to be true
+    expect(@namespaced.get('virgin_key')).to eq(@namespaced.getrange('virgin_key',0,-1))
+  end
+
+  it 'should be able to use a namespace with exists' do
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    expect(@namespaced.exists('foo', 'bar')).to eq(2)
+  end
+
+  it 'should be able to use a namespace with exists?' do
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    expect(@namespaced.exists?('does_not_exist', 'bar')).to eq(true)
+  end
+
+  it 'should be able to use a namespace with bitpos' do
+    @namespaced.setbit('bit_map', 42, 1)
+    expect(@namespaced.bitpos('bit_map', 0)).to eq(0)
+    expect(@namespaced.bitpos('bit_map', 1)).to eq(42)
   end
 
   it 'should be able to use a namespace with setrange' do
     @namespaced.setrange('foo', 0, 'bar')
-    @namespaced['foo'].should eq('bar')
+    expect(@namespaced.get('foo')).to eq('bar')
 
     @namespaced.setrange('bar', 2, 'foo')
-    @namespaced['bar'].should eq("\000\000foo")
+    expect(@namespaced.get('bar')).to eq("\000\000foo")
   end
 
   it "should be able to use a namespace with mget" do
-    @namespaced['foo'] = 1000
-    @namespaced['bar'] = 2000
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({'foo'=>'1000', 'bar'=>'2000', 'baz' => nil})
+    @namespaced.set('foo', 1000)
+    @namespaced.set('bar', 2000)
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
+    expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({'foo'=>'1000', 'bar'=>'2000', 'baz' => nil})
   end
 
   it "should be able to use a namespace with mset" do
     @namespaced.mset('foo', '1000', 'bar', '2000')
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
+    expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
+
     @namespaced.mapped_mset('foo' => '3000', 'bar' => '5000')
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '3000', 'bar' => '5000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '3000', 'bar' => '5000', 'baz' => nil})
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '3000', 'bar' => '5000' })
+    expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '3000', 'bar' => '5000', 'baz' => nil})
+
+    @namespaced.mset(['foo', '4000'], ['baz', '6000'])
+    expect(@namespaced.mapped_mget('foo', 'bar', 'baz')).to eq({ 'foo' => '4000', 'bar' => '5000', 'baz' => '6000' })
   end
 
   it "should be able to use a namespace with msetnx" do
     @namespaced.msetnx('foo', '1000', 'bar', '2000')
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000' })
-    @namespaced.mapped_mget('foo', 'baz', 'bar').should eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000' })
+    expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => nil})
+
+    @namespaced.msetnx(['baz', '4000'])
+    expect(@namespaced.mapped_mget('foo', 'baz', 'bar')).to eq({ 'foo' => '1000', 'bar' => '2000', 'baz' => '4000'})
   end
 
   it "should be able to use a namespace with mapped_msetnx" do
     @namespaced.set('foo','1')
-    @namespaced.mapped_msetnx('foo'=>'1000', 'bar'=>'2000').should be_false
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1', 'bar' => nil })
-    @namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000').should be_true
-    @namespaced.mapped_mget('foo', 'bar').should eq({ 'foo' => '1', 'bar' => '2000' })
+    expect(@namespaced.mapped_msetnx('foo'=>'1000', 'bar'=>'2000')).to be false
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1', 'bar' => nil })
+    expect(@namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000')).to be true
+    expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1', 'bar' => '2000' })
   end
 
   it "should be able to use a namespace with hashes" do
     @namespaced.hset('foo', 'key', 'value')
     @namespaced.hset('foo', 'key1', 'value1')
-    @namespaced.hget('foo', 'key').should eq('value')
-    @namespaced.hgetall('foo').should eq({'key' => 'value', 'key1' => 'value1'})
-    @namespaced.hlen('foo').should eq(2)
-    @namespaced.hkeys('foo').should eq(['key', 'key1'])
+    expect(@namespaced.hget('foo', 'key')).to eq('value')
+    expect(@namespaced.hgetall('foo')).to eq({'key' => 'value', 'key1' => 'value1'})
+    expect(@namespaced.hlen('foo')).to eq(2)
+    expect(@namespaced.hkeys('foo')).to eq(['key', 'key1'])
     @namespaced.hmset('bar', 'key', 'value', 'key1', 'value1')
     @namespaced.hmget('bar', 'key', 'key1')
     @namespaced.hmset('bar', 'a_number', 1)
-    @namespaced.hmget('bar', 'a_number').should eq(['1'])
+    expect(@namespaced.hmget('bar', 'a_number')).to eq(['1'])
     @namespaced.hincrby('bar', 'a_number', 3)
-    @namespaced.hmget('bar', 'a_number').should eq(['4'])
-    @namespaced.hgetall('bar').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
-
-    @namespaced.hsetnx('foonx','nx',10).should be_true
-    @namespaced.hsetnx('foonx','nx',12).should be_false
-    @namespaced.hget('foonx','nx').should eq("10")
-    @namespaced.hkeys('foonx').should eq(%w{ nx })
-    @namespaced.hvals('foonx').should eq(%w{ 10 })
+    expect(@namespaced.hmget('bar', 'a_number')).to eq(['4'])
+    expect(@namespaced.hgetall('bar')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
+
+    expect(@namespaced.hsetnx('foonx','nx',10)).to be true
+    expect(@namespaced.hsetnx('foonx','nx',12)).to be false
+    expect(@namespaced.hget('foonx','nx')).to eq("10")
+    expect(@namespaced.hkeys('foonx')).to eq(%w{ nx })
+    expect(@namespaced.hvals('foonx')).to eq(%w{ 10 })
     @namespaced.mapped_hmset('baz', {'key' => 'value', 'key1' => 'value1', 'a_number' => 4})
-    @namespaced.mapped_hmget('baz', 'key', 'key1', 'a_number').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
-    @namespaced.hgetall('baz').should eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
+    expect(@namespaced.mapped_hmget('baz', 'key', 'key1', 'a_number')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
+    expect(@namespaced.hgetall('baz')).to eq({'key' => 'value', 'key1' => 'value1', 'a_number' => '4'})
   end
 
   it "should properly intersect three sets" do
@@ -193,7 +247,7 @@ describe "redis" do
     @namespaced.sadd('bar', 3)
     @namespaced.sadd('bar', 4)
     @namespaced.sadd('baz', 3)
-    @namespaced.sinter('foo', 'bar', 'baz').should eq(%w( 3 ))
+    expect(@namespaced.sinter('foo', 'bar', 'baz')).to eq(%w( 3 ))
   end
 
   it "should properly union two sets" do
@@ -202,7 +256,7 @@ describe "redis" do
     @namespaced.sadd('bar', 2)
     @namespaced.sadd('bar', 3)
     @namespaced.sadd('bar', 4)
-    @namespaced.sunion('foo', 'bar').sort.should eq(%w( 1 2 3 4 ))
+    expect(@namespaced.sunion('foo', 'bar').sort).to eq(%w( 1 2 3 4 ))
   end
 
   it "should properly union two sorted sets with options" do
@@ -211,8 +265,8 @@ describe "redis" do
     @namespaced.zadd('sort2', 2, 2)
     @namespaced.zadd('sort2', 3, 3)
     @namespaced.zadd('sort2', 4, 4)
-    @namespaced.zunionstore('union', ['sort1', 'sort2'], :weights => [2, 1])
-    @namespaced.zrevrange('union', 0, -1).should eq(%w( 2 4 3 1 ))
+    @namespaced.zunionstore('union', ['sort1', 'sort2'], weights: [2, 1])
+    expect(@namespaced.zrevrange('union', 0, -1)).to eq(%w( 2 4 3 1 ))
   end
 
   it "should properly union two sorted sets without options" do
@@ -222,7 +276,7 @@ describe "redis" do
     @namespaced.zadd('sort2', 3, 3)
     @namespaced.zadd('sort2', 4, 4)
     @namespaced.zunionstore('union', ['sort1', 'sort2'])
-    @namespaced.zrevrange('union', 0, -1).should eq(%w( 4 2 3 1 ))
+    expect(@namespaced.zrevrange('union', 0, -1)).to eq(%w( 4 2 3 1 ))
   end
 
   it "should properly intersect two sorted sets without options" do
@@ -237,7 +291,7 @@ describe "redis" do
     @namespaced.zinterstore('inter', ['food', 'color'])
 
     inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
-    inter_values.should =~ [['orange', 3.0], ['eggplant', 7.0]]
+    expect(inter_values).to match_array([['orange', 3.0], ['eggplant', 7.0]])
   end
 
   it "should properly intersect two sorted sets with options" do
@@ -252,7 +306,37 @@ describe "redis" do
     @namespaced.zinterstore('inter', ['food', 'color'], :aggregate => "min")
 
     inter_values = @namespaced.zrevrange('inter', 0, -1, :with_scores => true)
-    inter_values.should =~ [['orange', 1.0], ['eggplant', 3.0]]
+    expect(inter_values).to match_array([['orange', 1.0], ['eggplant', 3.0]])
+  end
+
+  it "should return lexicographical range for sorted set" do
+    @namespaced.zadd('food', 0, 'orange')
+    @namespaced.zadd('food', 0, 'banana')
+    @namespaced.zadd('food', 0, 'eggplant')
+
+    values = @namespaced.zrangebylex('food', '[b', '(o')
+    expect(values).to match_array(['banana', 'eggplant'])
+  end
+
+  it "should return the number of elements removed from the set" do
+    @namespaced.zadd('food', 0, 'orange')
+    @namespaced.zadd('food', 0, 'banana')
+    @namespaced.zadd('food', 0, 'eggplant')
+
+    removed = @namespaced.zremrangebylex('food', '[b', '(o')
+    expect(removed).to eq(2)
+
+    values = @namespaced.zrange('food', 0, -1)
+    expect(values).to eq(['orange'])
+  end
+
+  it "should return reverce lexicographical range for sorted set" do
+    @namespaced.zadd('food', 0, 'orange')
+    @namespaced.zadd('food', 0, 'banana')
+    @namespaced.zadd('food', 0, 'eggplant')
+
+    values = @namespaced.zrevrangebylex('food', '(o', '[b')
+    expect(values).to match_array(['banana', 'eggplant'])
   end
 
   it "should add namespace to sort" do
@@ -263,24 +347,24 @@ describe "redis" do
     @namespaced.set('value_1', 'a')
     @namespaced.set('value_2', 'b')
 
-    @namespaced.sort('foo').should eq(%w( 1 2 ))
-    @namespaced.sort('foo', :limit => [0, 1]).should eq(%w( 1 ))
-    @namespaced.sort('foo', :order => 'desc').should eq(%w( 2 1 ))
-    @namespaced.sort('foo', :by => 'weight_*').should eq(%w( 2 1 ))
-    @namespaced.sort('foo', :get => 'value_*').should eq(%w( a b ))
-    @namespaced.sort('foo', :get => '#').should eq(%w( 1 2 ))
-    @namespaced.sort('foo', :get => ['#', 'value_*']).should eq([["1", "a"], ["2", "b"]])
+    expect(@namespaced.sort('foo')).to eq(%w( 1 2 ))
+    expect(@namespaced.sort('foo', :limit => [0, 1])).to eq(%w( 1 ))
+    expect(@namespaced.sort('foo', :order => 'desc')).to eq(%w( 2 1 ))
+    expect(@namespaced.sort('foo', :by => 'weight_*')).to eq(%w( 2 1 ))
+    expect(@namespaced.sort('foo', :get => 'value_*')).to eq(%w( a b ))
+    expect(@namespaced.sort('foo', :get => '#')).to eq(%w( 1 2 ))
+    expect(@namespaced.sort('foo', :get => ['#', 'value_*'])).to eq([["1", "a"], ["2", "b"]])
 
     @namespaced.sort('foo', :store => 'result')
-    @namespaced.lrange('result', 0, -1).should eq(%w( 1 2 ))
+    expect(@namespaced.lrange('result', 0, -1)).to eq(%w( 1 2 ))
   end
 
   it "should yield the correct list of keys" do
-    @namespaced["foo"] = 1
-    @namespaced["bar"] = 2
-    @namespaced["baz"] = 3
-    @namespaced.keys("*").sort.should eq(%w( bar baz foo ))
-    @namespaced.keys.sort.should eq(%w( bar baz foo ))
+    @namespaced.set("foo", 1)
+    @namespaced.set("bar", 2)
+    @namespaced.set("baz", 3)
+    expect(@namespaced.keys("*").sort).to eq(%w( bar baz foo ))
+    expect(@namespaced.keys.sort).to eq(%w( bar baz foo ))
   end
 
   it "should add namepsace to multi blocks" do
@@ -289,7 +373,7 @@ describe "redis" do
       r.del "foo"
       r.mapped_hmset "foo", {"key1" => "value1"}
     end
-    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
   it "should pass through multi commands without block" do
@@ -300,14 +384,14 @@ describe "redis" do
     @namespaced.mapped_hmset "foo", {"key1" => "value1"}
     @namespaced.exec
 
-    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
   it 'should return futures without attempting to remove namespaces' do
     @namespaced.multi do
       @future = @namespaced.keys('*')
     end
-    @future.class.should be(Redis::Future)
+    expect(@future.class).to be(Redis::Future)
   end
 
   it "should add namespace to pipelined blocks" do
@@ -316,74 +400,134 @@ describe "redis" do
       r.del "foo"
       r.mapped_hmset "foo", {"key1" => "value1"}
     end
-    @namespaced.hgetall("foo").should eq({"key1" => "value1"})
+    expect(@namespaced.hgetall("foo")).to eq({"key1" => "value1"})
   end
 
   it "should returned response array from pipelined block" do
     @namespaced.mset "foo", "bar", "key", "value"
     result = @namespaced.pipelined do |r|
-      r["foo"]
-      r["key"]
+      r.get("foo")
+      r.get("key")
     end
-    result.should eq(["bar", "value"])
+    expect(result).to eq(["bar", "value"])
+  end
+
+  it "is thread safe for multi blocks" do
+    mon = Monitor.new
+    entered = false
+    entered_cond = mon.new_cond
+
+    thread = Thread.new do
+      mon.synchronize do
+        entered_cond.wait_until { entered }
+        @namespaced.multi
+      end
+    end
+
+    @namespaced.multi do |transaction|
+      entered = true
+      mon.synchronize { entered_cond.signal }
+      thread.join(0.1)
+      transaction.get("foo")
+    end
+    thread.join
   end
 
   it "should add namespace to strlen" do
     @namespaced.set("mykey", "123456")
-    @namespaced.strlen("mykey").should eq(6)
+    expect(@namespaced.strlen("mykey")).to eq(6)
   end
 
   it "should not add namespace to echo" do
-    @namespaced.echo(123).should eq("123")
+    expect(@namespaced.echo(123)).to eq("123")
   end
 
   it 'should not add namespace to disconnect!' do
-    expect(@redis).to receive(:disconnect!).with().and_call_original
+    expect(@redis).to receive(:disconnect!).with(no_args).and_call_original
 
     expect(@namespaced.disconnect!).to be nil
   end
 
   it "can change its namespace" do
-    @namespaced['foo'].should eq(nil)
-    @namespaced['foo'] = 'chris'
-    @namespaced['foo'].should eq('chris')
+    expect(@namespaced.get('foo')).to eq(nil)
+    @namespaced.set('foo', 'chris')
+    expect(@namespaced.get('foo')).to eq('chris')
 
-    @namespaced.namespace.should eq(:ns)
+    expect(@namespaced.namespace).to eq(:ns)
     @namespaced.namespace = :spec
-    @namespaced.namespace.should eq(:spec)
+    expect(@namespaced.namespace).to eq(:spec)
 
-    @namespaced['foo'].should eq(nil)
-    @namespaced['foo'] = 'chris'
-    @namespaced['foo'].should eq('chris')
+    expect(@namespaced.get('foo')).to eq(nil)
+    @namespaced.set('foo', 'chris')
+    expect(@namespaced.get('foo')).to eq('chris')
   end
 
   it "can accept a temporary namespace" do
-    @namespaced.namespace.should eq(:ns)
-    @namespaced['foo'].should eq(nil)
+    expect(@namespaced.namespace).to eq(:ns)
+    expect(@namespaced.get('foo')).to eq(nil)
 
     @namespaced.namespace(:spec) do |temp_ns|
-      temp_ns.namespace.should eq(:spec)
-      temp_ns['foo'].should eq(nil)
-      temp_ns['foo'] = 'jake'
-      temp_ns['foo'].should eq('jake')
+      expect(temp_ns.namespace).to eq(:spec)
+      expect(temp_ns.get('foo')).to eq(nil)
+      temp_ns.set('foo', 'jake')
+      expect(temp_ns.get('foo')).to eq('jake')
     end
 
-    @namespaced.namespace.should eq(:ns)
-    @namespaced['foo'].should eq(nil)
+    expect(@namespaced.namespace).to eq(:ns)
+    expect(@namespaced.get('foo')).to eq(nil)
   end
 
   it "should respond to :namespace=" do
-    @namespaced.respond_to?(:namespace=).should eq(true)
+    expect(@namespaced.respond_to?(:namespace=)).to eq(true)
   end
 
   it "should respond to :warning=" do
-    @namespaced.respond_to?(:warning=).should == true
+    expect(@namespaced.respond_to?(:warning=)).to eq(true)
   end
 
   it "should raise an exception when an unknown command is passed" do
     expect { @namespaced.unknown('foo') }.to raise_exception NoMethodError
   end
 
+  describe '#inspect' do
+    let(:single_level_names) { %i[first] }
+    let(:double_level_names) { %i[first second] }
+    let(:triple_level_names) { %i[first second third] }
+    let(:namespace_builder) do
+      ->(redis, *namespaces) { namespaces.reduce(redis) { |r, n| Redis::Namespace.new(n, redis: r) } }
+    end
+    let(:regexp_builder) do
+      ->(*namespaces) { %r{/#{namespaces.join(':')}>\z} }
+    end
+
+    context 'when one namespace' do
+      let(:single_namespaced) { namespace_builder.call(@redis, *single_level_names) }
+      let(:regexp) { regexp_builder.call(*single_level_names) }
+
+      it 'should have correct ending of inspect string' do
+        expect(regexp =~ single_namespaced.inspect).not_to be(nil)
+      end
+    end
+
+    context 'when two namespaces' do
+      let(:double_namespaced) { namespace_builder.call(@redis, *double_level_names) }
+      let(:regexp) { regexp_builder.call(*double_level_names) }
+
+      it 'should have correct ending of inspect string' do
+        expect(regexp =~ double_namespaced.inspect).not_to be(nil)
+      end
+    end
+
+    context 'when three namespaces' do
+      let(:triple_namespaced) { namespace_builder.call(@redis, *triple_level_names) }
+      let(:regexp) { regexp_builder.call(*triple_level_names) }
+
+      it 'should have correct ending of inspect string' do
+        expect(regexp =~ triple_namespaced.inspect).not_to be(nil)
+      end
+    end
+  end
+
   # Redis 2.6 RC reports its version as 2.5.
   if @redis_version >= Gem::Version.new("2.5.0")
     describe "redis 2.6 commands" do
@@ -417,7 +561,7 @@ describe "redis" do
         v = @namespaced.dump("foo")
         @redis.del("ns:foo")
 
-        expect(@namespaced.restore("foo", 1000, v)).to be_true
+        expect(@namespaced.restore("foo", 1000, v)).to be_truthy
         expect(@redis.get("ns:foo")).to eq 'a'
         expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
 
@@ -425,72 +569,72 @@ describe "redis" do
         w = @namespaced.dump("bar")
         @redis.del("ns:bar")
 
-        expect(@namespaced.restore("bar", 1000, w)).to be_true
+        expect(@namespaced.restore("bar", 1000, w)).to be_truthy
         expect(@redis.lrange('ns:bar', 0, -1)).to eq %w(b c d)
         expect(@redis.ttl("ns:foo")).to satisfy {|v| (0..1).include?(v) }
       end
 
       it "should namespace hincrbyfloat" do
         @namespaced.hset('mykey', 'field', 10.50)
-        @namespaced.hincrbyfloat('mykey', 'field', 0.1).should eq(10.6)
+        expect(@namespaced.hincrbyfloat('mykey', 'field', 0.1)).to eq(10.6)
       end
 
       it "should namespace incrbyfloat" do
         @namespaced.set('mykey', 10.50)
-        @namespaced.incrbyfloat('mykey', 0.1).should eq(10.6)
+        expect(@namespaced.incrbyfloat('mykey', 0.1)).to eq(10.6)
       end
 
       it "should namespace object" do
         @namespaced.set('foo', 1000)
-        @namespaced.object('encoding', 'foo').should eq('int')
+        expect(@namespaced.object('encoding', 'foo')).to eq('int')
       end
 
       it "should namespace persist" do
         @namespaced.set('mykey', 'Hello')
         @namespaced.expire('mykey', 60)
-        @namespaced.persist('mykey').should eq(true)
-        @namespaced.ttl('mykey').should eq(-1)
+        expect(@namespaced.persist('mykey')).to eq(true)
+        expect(@namespaced.ttl('mykey')).to eq(-1)
       end
 
       it "should namespace pexpire" do
         @namespaced.set('mykey', 'Hello')
-        @namespaced.pexpire('mykey', 60000).should eq(true)
+        expect(@namespaced.pexpire('mykey', 60000)).to eq(true)
       end
 
       it "should namespace pexpireat" do
         @namespaced.set('mykey', 'Hello')
-        @namespaced.pexpire('mykey', 1555555555005).should eq(true)
+        expect(@namespaced.pexpire('mykey', 1555555555005)).to eq(true)
       end
 
       it "should namespace psetex" do
-        @namespaced.psetex('mykey', 10000, 'Hello').should eq('OK')
-        @namespaced.get('mykey').should eq('Hello')
+        expect(@namespaced.psetex('mykey', 10000, 'Hello')).to eq('OK')
+        expect(@namespaced.get('mykey')).to eq('Hello')
       end
 
       it "should namespace pttl" do
         @namespaced.set('mykey', 'Hello')
         @namespaced.expire('mykey', 1)
-        @namespaced.pttl('mykey').should >= 0
+        expect(@namespaced.pttl('mykey')).to be >= 0
       end
 
       it "should namespace eval keys passed in as array args" do
-        @namespaced.
-          eval("return {KEYS[1], KEYS[2]}", %w[k1 k2], %w[arg1 arg2]).
-          should eq(%w[ns:k1 ns:k2])
+        expect(@namespaced.
+          eval("return {KEYS[1], KEYS[2]}", %w[k1 k2], %w[arg1 arg2])).
+          to eq(%w[ns:k1 ns:k2])
       end
 
       it "should namespace eval keys passed in as hash args" do
-        @namespaced.
-          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-          should eq(%w[ns:k1 ns:k2])
+        expect(@namespaced.
+          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+          to eq(%w[ns:k1 ns:k2])
       end
 
       it "should namespace eval keys passed in as hash args unmodified" do
         args = { :keys => %w[k1 k2], :argv => %w[arg1 arg2] }
         args.freeze
-        @namespaced.
-          eval("return {KEYS[1], KEYS[2]}", args).
-          should eq(%w[ns:k1 ns:k2])
+        expect(@namespaced.
+          eval("return {KEYS[1], KEYS[2]}", args)).
+          to eq(%w[ns:k1 ns:k2])
       end
 
       context '#evalsha' do
@@ -499,23 +643,23 @@ describe "redis" do
         end
 
         it "should namespace evalsha keys passed in as array args" do
-          @namespaced.
-            evalsha(sha, %w[k1 k2], %w[arg1 arg2]).
-            should eq(%w[ns:k1 ns:k2])
+          expect(@namespaced.
+            evalsha(sha, %w[k1 k2], %w[arg1 arg2])).
+            to eq(%w[ns:k1 ns:k2])
         end
 
         it "should namespace evalsha keys passed in as hash args" do
-          @namespaced.
-            evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-            should eq(%w[ns:k1 ns:k2])
+          expect(@namespaced.
+            evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+            to eq(%w[ns:k1 ns:k2])
         end
 
         it "should namespace evalsha keys passed in as hash args unmodified" do
           args = { :keys => %w[k1 k2], :argv => %w[arg1 arg2] }
           args.freeze
-          @namespaced.
-            evalsha(sha, args).
-            should eq(%w[ns:k1 ns:k2])
+          expect(@namespaced.
+            evalsha(sha, args)).
+            to eq(%w[ns:k1 ns:k2])
         end
       end
 
@@ -524,13 +668,13 @@ describe "redis" do
         let(:sha) { @redis.script(:load, "return {KEYS[1], KEYS[2]}") }
 
         it "should namespace eval keys passed in as hash args" do
-          nested_namespace.
-          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-          should eq(%w[ns:nest:k1 ns:nest:k2])
+          expect(nested_namespace.
+          eval("return {KEYS[1], KEYS[2]}", :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+          to eq(%w[ns:nest:k1 ns:nest:k2])
         end
         it "should namespace evalsha keys passed in as hash args" do
-          nested_namespace.evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2]).
-            should eq(%w[ns:nest:k1 ns:nest:k2])
+          expect(nested_namespace.evalsha(sha, :keys => %w[k1 k2], :argv => %w[arg1 arg2])).
+            to eq(%w[ns:nest:k1 ns:nest:k2])
         end
       end
     end
@@ -559,16 +703,16 @@ describe "redis" do
           context 'when :match supplied' do
             it 'should retrieve the proper keys' do
               _, result = @namespaced.scan(0, :match => 'zeta:*', :count => 1000)
-              result.should =~ matching_namespaced_keys
+              expect(result).to match_array(matching_namespaced_keys)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve the proper keys' do
               _, result = @namespaced.scan(0, :count => 1000)
-              result.should =~ namespaced_keys
+              expect(result).to match_array(namespaced_keys)
             end
           end
-        end if Redis.current.respond_to?(:scan)
+        end if Redis.new.respond_to?(:scan)
 
         context '#scan_each' do
           context 'when :match supplied' do
@@ -576,13 +720,13 @@ describe "redis" do
               it 'should yield unnamespaced' do
                 results = []
                 @namespaced.scan_each(:match => 'zeta:*', :count => 1000) {|k| results << k }
-                results.should =~ matching_namespaced_keys
+                expect(results).to match_array(matching_namespaced_keys)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that un-namespaces' do
                 enum = @namespaced.scan_each(:match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ matching_namespaced_keys
+                expect(enum.to_a).to match_array(matching_namespaced_keys)
               end
             end
           end
@@ -591,17 +735,17 @@ describe "redis" do
               it 'should yield unnamespaced' do
                 results = []
                 @namespaced.scan_each(:count => 1000){ |k| results << k }
-                results.should =~ namespaced_keys
+                expect(results).to match_array(namespaced_keys)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that un-namespaces' do
                 enum = @namespaced.scan_each(:count => 1000)
-                enum.to_a.should =~ namespaced_keys
+                expect(enum.to_a).to match_array(namespaced_keys)
               end
             end
           end
-        end if Redis.current.respond_to?(:scan_each)
+        end if Redis.new.respond_to?(:scan_each)
       end
 
       context 'hash scan methods' do
@@ -620,16 +764,16 @@ describe "redis" do
           context 'when supplied :match' do
             it 'should retrieve the proper keys' do
               _, results = @namespaced.hscan('hsh', 0, :match => 'zeta:*')
-              results.should =~ hash_matching_subset.to_a
+              expect(results).to match_array(hash_matching_subset.to_a)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve all hash keys' do
               _, results = @namespaced.hscan('hsh', 0)
-              results.should =~ @redis.hgetall('ns:hsh').to_a
+              expect(results).to match_array(@redis.hgetall('ns:hsh').to_a)
             end
           end
-        end if Redis.current.respond_to?(:hscan)
+        end if Redis.new.respond_to?(:hscan)
 
         context '#hscan_each' do
           context 'when :match supplied' do
@@ -637,13 +781,13 @@ describe "redis" do
               it 'should yield the correct hash keys unchanged' do
                 results = []
                 @namespaced.hscan_each('hsh', :match => 'zeta:*', :count => 1000) { |kv| results << kv}
-                results.should =~ hash_matching_subset.to_a
+                expect(results).to match_array(hash_matching_subset.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields the correct hash keys unchanged' do
                 enum = @namespaced.hscan_each('hsh', :match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ hash_matching_subset.to_a
+                expect(enum.to_a).to match_array(hash_matching_subset.to_a)
               end
             end
           end
@@ -652,17 +796,17 @@ describe "redis" do
               it 'should yield all hash keys unchanged' do
                 results = []
                 @namespaced.hscan_each('hsh', :count => 1000){ |k| results << k }
-                results.should =~ hash.to_a
+                expect(results).to match_array(hash.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields all keys unchanged' do
                 enum = @namespaced.hscan_each('hsh', :count => 1000)
-                enum.to_a.should =~ hash.to_a
+                expect(enum.to_a).to match_array(hash.to_a)
               end
             end
           end
-        end if Redis.current.respond_to?(:hscan_each)
+        end if Redis.new.respond_to?(:hscan_each)
       end
 
       context 'set scan methods' do
@@ -681,16 +825,16 @@ describe "redis" do
           context 'when supplied :match' do
             it 'should retrieve the matching set members from the proper set' do
               _, results = @namespaced.sscan('set', 0, :match => 'zeta:*', :count => 1000)
-              results.should =~ matching_subset
+              expect(results).to match_array(matching_subset)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve all set members from the proper set' do
               _, results = @namespaced.sscan('set', 0, :count => 1000)
-              results.should =~ set
+              expect(results).to match_array(set)
             end
           end
-        end if Redis.current.respond_to?(:sscan)
+        end if Redis.new.respond_to?(:sscan)
 
         context '#sscan_each' do
           context 'when :match supplied' do
@@ -698,13 +842,13 @@ describe "redis" do
               it 'should yield the correct hset elements unchanged' do
                 results = []
                 @namespaced.sscan_each('set', :match => 'zeta:*', :count => 1000) { |kv| results << kv}
-                results.should =~ matching_subset
+                expect(results).to match_array(matching_subset)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields the correct set elements unchanged' do
                 enum = @namespaced.sscan_each('set', :match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ matching_subset
+                expect(enum.to_a).to match_array(matching_subset)
               end
             end
           end
@@ -713,17 +857,17 @@ describe "redis" do
               it 'should yield all set elements unchanged' do
                 results = []
                 @namespaced.sscan_each('set', :count => 1000){ |k| results << k }
-                results.should =~ set
+                expect(results).to match_array(set)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields all set elements unchanged' do
                 enum = @namespaced.sscan_each('set', :count => 1000)
-                enum.to_a.should =~ set
+                expect(enum.to_a).to match_array(set)
               end
             end
           end
-        end if Redis.current.respond_to?(:sscan_each)
+        end if Redis.new.respond_to?(:sscan_each)
       end
 
       context 'zset scan methods' do
@@ -743,17 +887,17 @@ describe "redis" do
             it 'should retrieve the matching set elements and their scores' do
               results = []
               @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000) { |ms| results << ms }
-              results.should =~ hash_matching_subset.to_a
+              expect(results).to match_array(hash_matching_subset.to_a)
             end
           end
           context 'without :match supplied' do
             it 'should retrieve all set elements and their scores' do
               results = []
               @namespaced.zscan_each('zset', :count => 1000) { |ms| results << ms }
-              results.should =~ hash.to_a
+              expect(results).to match_array(hash.to_a)
             end
           end
-        end if Redis.current.respond_to?(:zscan)
+        end if Redis.new.respond_to?(:zscan)
 
         context '#zscan_each' do
           context 'when :match supplied' do
@@ -761,13 +905,13 @@ describe "redis" do
               it 'should yield the correct set elements and scores unchanged' do
                 results = []
                 @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000) { |ms| results << ms}
-                results.should =~ hash_matching_subset.to_a
+                expect(results).to match_array(hash_matching_subset.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields the correct set elements and scoresunchanged' do
                 enum = @namespaced.zscan_each('zset', :match => 'zeta:*', :count => 1000)
-                enum.to_a.should =~ hash_matching_subset.to_a
+                expect(enum.to_a).to match_array(hash_matching_subset.to_a)
               end
             end
           end
@@ -776,17 +920,17 @@ describe "redis" do
               it 'should yield all set elements and scores unchanged' do
                 results = []
                 @namespaced.zscan_each('zset', :count => 1000){ |ms| results << ms }
-                results.should =~ hash.to_a
+                expect(results).to match_array(hash.to_a)
               end
             end
             context 'without a block' do
               it 'should return an Enumerator that yields all set elements and scores unchanged' do
                 enum = @namespaced.zscan_each('zset', :count => 1000)
-                enum.to_a.should =~ hash.to_a
+                expect(enum.to_a).to match_array(hash.to_a)
               end
             end
           end
-        end if Redis.current.respond_to?(:zscan_each)
+        end if Redis.new.respond_to?(:zscan_each)
       end
     end
   end
@@ -794,12 +938,12 @@ describe "redis" do
   if @redis_version >= Gem::Version.new("2.8.9")
     it 'should namespace pfadd' do
       5.times { |n| @namespaced.pfadd("pf", n) }
-      @redis.pfcount("ns:pf").should == 5
+      expect(@redis.pfcount("ns:pf")).to eq(5)
     end
 
     it 'should namespace pfcount' do
       5.times { |n| @redis.pfadd("ns:pf", n) }
-      @namespaced.pfcount("pf").should == 5
+      expect(@namespaced.pfcount("pf")).to eq(5)
     end
 
     it 'should namespace pfmerge' do
@@ -809,7 +953,18 @@ describe "redis" do
       end
 
       @namespaced.pfmerge("pfc", "pfa", "pfb")
-      @redis.pfcount("ns:pfc").should == 10
+      expect(@redis.pfcount("ns:pfc")).to eq(10)
+    end
+  end
+
+  describe :full_namespace do
+    it "should return the full namespace including sub namespaces" do
+      sub_namespaced     = Redis::Namespace.new(:sub1, :redis => @namespaced)
+      sub_sub_namespaced = Redis::Namespace.new(:sub2, :redis => sub_namespaced)
+
+      expect(@namespaced.full_namespace).to eql("ns")
+      expect(sub_namespaced.full_namespace).to eql("ns:sub1")
+      expect(sub_sub_namespaced.full_namespace).to eql("ns:sub1:sub2")
     end
   end
 end