[DRE-commits] [ruby-redis-namespace] 01/06: Make tests run
Balasankar C
balasankarc-guest at moszumanska.debian.org
Wed Sep 2 12:10:12 UTC 2015
This is an automated email from the git hooks/post-receive script.
balasankarc-guest pushed a commit to branch master
in repository ruby-redis-namespace.
commit 0fc2a5debf37ee3151949f18312d852cd654207e
Author: Balasankar C <balasankarc at autistici.org>
Date: Wed Sep 2 17:30:34 2015 +0530
Make tests run
---
debian/patches/fix-tests-support-rspec3 | 859 ++++++++++++++++++++++++++++++++
debian/patches/require-rspec-its | 15 +
debian/patches/series | 2 +
3 files changed, 876 insertions(+)
diff --git a/debian/patches/fix-tests-support-rspec3 b/debian/patches/fix-tests-support-rspec3
new file mode 100644
index 0000000..f44d6a8
--- /dev/null
+++ b/debian/patches/fix-tests-support-rspec3
@@ -0,0 +1,859 @@
+Description: Port tests to support RSpec3 syntax
+Author: Balasankar C <balasankarc at autistici.org>
+Last-Update: 2015-09-02
+---
+This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
+--- a/spec/deprecation_spec.rb
++++ b/spec/deprecation_spec.rb
+@@ -17,17 +17,32 @@
+
+ subject { namespaced }
+
+- its(:deprecations?) { should be false }
+- its(:warning?) { should be true }
++ describe '#deprecations?' do
++ subject { super().deprecations? }
++ it { is_expected.to be false }
++ end
++
++ describe '#warning?' do
++ subject { super().warning? }
++ it { is_expected.to be true }
++ end
+
+ context('with REDIS_NAMESPACE_DEPRECATIONS') do
+ around(:each) {|e| with_env('REDIS_NAMESPACE_DEPRECATIONS'=>'1', &e) }
+- its(:deprecations?) { should be true }
++
++ describe '#deprecations?' do
++ subject { super().deprecations? }
++ it { is_expected.to be true }
++ end
+ end
+
+ context('with REDIS_NAMESPACE_QUIET') do
+ around(:each) {|e| with_env('REDIS_NAMESPACE_QUIET'=>'1', &e) }
+- its(:warning?) { should be false }
++
++ describe '#warning?' do
++ subject { super().warning? }
++ it { is_expected.to be false }
++ end
+ end
+
+ before(:each) do
+@@ -39,10 +54,14 @@
+ # This behaviour will hold true after the 2.x migration
+ context('with deprecations enabled') do
+ let(:options) { {:deprecations => true} }
+- its(:deprecations?) { should be true }
++
++ describe '#deprecations?' do
++ subject { super().deprecations? }
++ it { is_expected.to be true }
++ end
+
+ context('with an unhandled command') do
+- it { should_not respond_to :unhandled }
++ it { is_expected.not_to respond_to :unhandled }
+
+ it('raises a NoMethodError') do
+ expect do
+@@ -55,10 +74,14 @@
+ # This behaviour will no longer be available after the 2.x migration
+ context('with deprecations disabled') do
+ let(:options) { {:deprecations => false} }
+- its(:deprecations?) { should be false }
++
++ describe '#deprecations?' do
++ subject { super().deprecations? }
++ it { is_expected.to be false }
++ end
+
+ context('with an an unhandled command') do
+- it { should respond_to :unhandled }
++ it { is_expected.to respond_to :unhandled }
+
+ it 'blindly passes through' do
+ expect(redis).to receive(:unhandled)
+--- a/spec/redis_spec.rb
++++ b/spec/redis_spec.rb
+@@ -25,27 +25,27 @@
+ end
+
+ it "proxies `client` to the client" do
+- @namespaced.client.should eq(@redis.client)
++ expect(@namespaced.client).to eq(@redis.client)
+ end
+
+ it "should be able to use a namespace" do
+- @namespaced['foo'].should eq(nil)
++ expect(@namespaced['foo']).to eq(nil)
+ @namespaced['foo'] = 'chris'
+- @namespaced['foo'].should eq('chris')
++ expect(@namespaced['foo']).to eq('chris')
+ @redis['foo'] = 'bob'
+- @redis['foo'].should eq('bob')
++ expect(@redis['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['counter'].to_i).to eq(2)
++ expect(@redis['counter']).to eq(nil)
++ expect(@namespaced.type('counter')).to eq('string')
+ 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,10 +53,10 @@
+ @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
+@@ -64,125 +64,125 @@
+ @namespaced['bar'] = 2000
+ @namespaced['baz'] = 3000
+ @namespaced.del 'foo'
+- @namespaced['foo'].should eq(nil)
++ expect(@namespaced['foo']).to eq(nil)
+ @namespaced.del 'bar', 'baz'
+- @namespaced['bar'].should eq(nil)
+- @namespaced['baz'].should eq(nil)
++ expect(@namespaced['bar']).to eq(nil)
++ expect(@namespaced['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')
++ expect(@namespaced.append('foo','n')).to eq(4)
++ expect(@namespaced['foo']).to eq('barn')
++ expect(@redis['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 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_truthy
++ expect(@namespaced.get('virgin_key')).to eq(@namespaced.getrange('virgin_key',0,-1))
+ end
+
+ it 'should be able to use a namespace with setrange' do
+ @namespaced.setrange('foo', 0, 'bar')
+- @namespaced['foo'].should eq('bar')
++ expect(@namespaced['foo']).to eq('bar')
+
+ @namespaced.setrange('bar', 2, 'foo')
+- @namespaced['bar'].should eq("\000\000foo")
++ expect(@namespaced['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})
++ 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})
+ 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})
+ 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_falsey
++ expect(@namespaced.mapped_mget('foo', 'bar')).to eq({ 'foo' => '1', 'bar' => nil })
++ expect(@namespaced.mapped_msetnx('bar'=>'2000', 'baz'=>'1000')).to be_truthy
++ 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'})
++ expect(@namespaced.hmget('bar', 'a_number')).to eq(['4'])
++ expect(@namespaced.hgetall('bar')).to 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.hsetnx('foonx','nx',10)).to be_truthy
++ expect(@namespaced.hsetnx('foonx','nx',12)).to be_falsey
++ 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 +193,7 @@
+ @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 +202,7 @@
+ @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
+@@ -212,7 +212,7 @@
+ @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 ))
++ 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 +222,7 @@
+ @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 +237,7 @@
+ @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 +252,7 @@
+ @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 add namespace to sort" do
+@@ -263,24 +263,24 @@
+ @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 ))
++ 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 +289,7 @@
+ 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 +300,14 @@
+ @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,7 +316,7 @@
+ 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
+@@ -325,59 +325,59 @@
+ r["foo"]
+ r["key"]
+ end
+- result.should eq(["bar", "value"])
++ expect(result).to eq(["bar", "value"])
+ 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)
++ expect(@namespaced['foo']).to eq(nil)
+ @namespaced['foo'] = 'chris'
+- @namespaced['foo'].should eq('chris')
++ expect(@namespaced['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)
++ expect(@namespaced['foo']).to eq(nil)
+ @namespaced['foo'] = 'chris'
+- @namespaced['foo'].should eq('chris')
++ expect(@namespaced['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['foo']).to eq(nil)
+
+ @namespaced.namespace(:spec) do |temp_ns|
+- temp_ns.namespace.should eq(:spec)
+- temp_ns['foo'].should eq(nil)
++ expect(temp_ns.namespace).to eq(:spec)
++ expect(temp_ns['foo']).to eq(nil)
+ temp_ns['foo'] = 'jake'
+- temp_ns['foo'].should eq('jake')
++ expect(temp_ns['foo']).to eq('jake')
+ end
+
+- @namespaced.namespace.should eq(:ns)
+- @namespaced['foo'].should eq(nil)
++ expect(@namespaced.namespace).to eq(:ns)
++ expect(@namespaced['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
+@@ -417,7 +417,7 @@
+ 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,64 +425,64 @@
+ 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
+
+ context '#evalsha' do
+@@ -491,15 +491,15 @@
+ 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
+ end
+
+@@ -508,13 +508,13 @@
+ let(:sha) { nested_namespace.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
+@@ -543,13 +543,13 @@
+ 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)
+@@ -560,13 +560,13 @@
+ 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
+@@ -575,13 +575,13 @@
+ 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
+@@ -604,13 +604,13 @@
+ 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(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(@redis.hgetall('ns:hsh').to_a)
+ end
+ end
+ end if Redis.current.respond_to?(:hscan)
+@@ -621,13 +621,13 @@
+ 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(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(hash_matching_subset.to_a)
+ end
+ end
+ end
+@@ -636,13 +636,13 @@
+ 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(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(hash.to_a)
+ end
+ end
+ end
+@@ -665,13 +665,13 @@
+ 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(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(set)
+ end
+ end
+ end if Redis.current.respond_to?(:sscan)
+@@ -682,13 +682,13 @@
+ 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(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(matching_subset)
+ end
+ end
+ end
+@@ -697,13 +697,13 @@
+ 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(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(set)
+ end
+ end
+ end
+@@ -727,14 +727,14 @@
+ 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(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(hash.to_a)
+ end
+ end
+ end if Redis.current.respond_to?(:zscan)
+@@ -745,13 +745,13 @@
+ 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(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(hash_matching_subset.to_a)
+ end
+ end
+ end
+@@ -760,13 +760,13 @@
+ 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(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(hash.to_a)
+ end
+ end
+ end
+@@ -778,12 +778,12 @@
+ 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
+@@ -793,7 +793,7 @@
+ end
+
+ @namespaced.pfmerge("pfc", "pfa", "pfb")
+- @redis.pfcount("ns:pfc").should == 10
++ expect(@redis.pfcount("ns:pfc")).to eq(10)
+ end
+ end
+ end
diff --git a/debian/patches/require-rspec-its b/debian/patches/require-rspec-its
new file mode 100644
index 0000000..4a9c5ce
--- /dev/null
+++ b/debian/patches/require-rspec-its
@@ -0,0 +1,15 @@
+Description: Make test require rspec-its
+Author: Balasankar C <balasankarc at autistici.org>
+Last-Update: 2015-09-02
+---
+This patch header follows DEP-3: http://dep.debian.net/deps/dep3/
+--- a/spec/spec_helper.rb
++++ b/spec/spec_helper.rb
+@@ -6,6 +6,7 @@
+ require 'rspec'
+ require 'redis'
+ require 'logger'
++require 'rspec/its'
+
+ $TESTING=true
+ $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
diff --git a/debian/patches/series b/debian/patches/series
index ec32a3a..20200c9 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -1 +1,3 @@
+require-rspec-its
+fix-tests-support-rspec3
remove-bundler-rubygems.patch
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-ruby-extras/ruby-redis-namespace.git
More information about the Pkg-ruby-extras-commits
mailing list