mock_redis 0.14.1 → 0.15.0

data/spec/commands/pexpireat_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe "#pexpireat(key, timestamp_ms)" do
+describe '#pexpireat(key, timestamp_ms)' do
   before do
     @key = 'mock-redis-test:pexpireat'
     @redises.set(@key, 'spork')
   end
 
-  it "returns true for a key that exists" do
+  it 'returns true for a key that exists' do
     @redises.pexpireat(@key, (Time.now.to_f * 1000).to_i + 1).should == true
   end
 
-  it "returns false for a key that does not exist" do
+  it 'returns false for a key that does not exist' do
     @redises.pexpireat('mock-redis-test:nonesuch',
                        (Time.now.to_f * 1000).to_i + 1).should == false
   end
 
-  it "removes a key immediately when timestamp is now" do
+  it 'removes a key immediately when timestamp is now' do
     @redises.pexpireat(@key, (Time.now.to_f * 1000).to_i)
     @redises.get(@key).should be_nil
   end
@@ -26,7 +26,7 @@ describe "#pexpireat(key, timestamp_ms)" do
     end.should raise_error(RuntimeError)
   end
 
-  context "[mock only]" do
+  context '[mock only]' do
     # These are mock-only since we can't actually manipulate time in
     # the real Redis.
 
@@ -39,7 +39,7 @@ describe "#pexpireat(key, timestamp_ms)" do
       Time.stub(:now).and_return(@now)
     end
 
-    it "removes keys after enough time has passed" do
+    it 'removes keys after enough time has passed' do
       @mock.pexpireat(@key, (@now.to_f * 1000).to_i + 5)
       Time.stub(:now).and_return(@now + 0.006)
       @mock.get(@key).should be_nil

data/spec/commands/ping_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#ping" do
+describe '#ping' do
   it "returns 'PONG'" do
     @redises.ping.should == 'PONG'
   end

data/spec/commands/pipelined_spec.rb

@@ -10,10 +10,10 @@ describe '#pipelined' do
   end
 
   context 'with a few added data' do
-    let(:key1)   { "hello" }
-    let(:key2)   { "world" }
-    let(:value1) { "foo" }
-    let(:value2) { "bar" }
+    let(:key1)   { 'hello' }
+    let(:key2)   { 'world' }
+    let(:value1) { 'foo' }
+    let(:value2) { 'bar' }
 
     before do
       @redises.set key1, value1
@@ -26,7 +26,7 @@ describe '#pipelined' do
         redis.get key2
       end
 
-      results.should == [ value1, value2 ]
+      results.should == [value1, value2]
     end
 
     it 'returns futures' do

data/spec/commands/pttl_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
-describe "#pttl(key)" do
+describe '#pttl(key)' do
   before do
     @key = 'mock-redis-test:persist'
     @redises.set(@key, 'spork')
   end
 
-  it "returns -1 for a key with no expiration" do
+  it 'returns -1 for a key with no expiration' do
     @redises.pttl(@key).should == -1
   end
 
-  it "returns -2 for a key that does not exist" do
+  it 'returns -2 for a key that does not exist' do
     @redises.pttl('mock-redis-test:nonesuch').should == -2
   end
 
-  it "stringifies key" do
+  it 'stringifies key' do
     @redises.expire(@key, 8)
     # Don't check against Redis since millisecond timing differences are likely
     @redises.send_without_checking(:pttl, @key.to_sym).should > 0
   end
 
-  context "[mock only]" do
+  context '[mock only]' do
     # These are mock-only since we can't actually manipulate time in
     # the real Redis.
 

data/spec/commands/randomkey_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe '#randomkey [mock only]' do
   before { @mock = @redises.mock }
 
-  it "finds a random key" do
+  it 'finds a random key' do
     @keys = ['mock-redis-test:1', 'mock-redis-test:2', 'mock-redis-test:3']
 
     @keys.each do |k|
@@ -13,8 +13,8 @@ describe '#randomkey [mock only]' do
     @keys.should include(@mock.randomkey)
   end
 
-  it "returns nil when there are no keys" do
-    @mock.keys('*').each {|k| @mock.del(k)}
+  it 'returns nil when there are no keys' do
+    @mock.keys('*').each { |k| @mock.del(k) }
     @mock.randomkey.should be_nil
   end
 end

data/spec/commands/rename_spec.rb

@@ -5,38 +5,38 @@ describe '#rename(key, newkey)' do
     @key = 'mock-redis-test:rename:key'
     @newkey = 'mock-redis-test:rename:newkey'
 
-    @redises.set(@key, "oof")
+    @redises.set(@key, 'oof')
   end
 
   it "responds with 'OK'" do
     @redises.rename(@key, @newkey).should == 'OK'
   end
 
-  it "moves the data" do
+  it 'moves the data' do
     @redises.rename(@key, @newkey)
-    @redises.get(@newkey).should == "oof"
+    @redises.get(@newkey).should == 'oof'
   end
 
-  it "raises an error when the source key is nonexistant" do
+  it 'raises an error when the source key is nonexistant' do
     @redises.del(@key)
     lambda do
       @redises.rename(@key, @newkey)
     end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error when key == newkey" do
+  it 'raises an error when key == newkey' do
     lambda do
       @redises.rename(@key, @key)
     end.should raise_error(RuntimeError)
   end
 
-  it "overwrites any existing value at newkey" do
-    @redises.set(@newkey, "rab")
+  it 'overwrites any existing value at newkey' do
+    @redises.set(@newkey, 'rab')
     @redises.rename(@key, @newkey)
-    @redises.get(@newkey).should == "oof"
+    @redises.get(@newkey).should == 'oof'
   end
 
-  it "keeps expiration" do
+  it 'keeps expiration' do
     @redises.expire(@key, 1000)
     @redises.rename(@key, @newkey)
     @redises.ttl(@newkey).should be > 0

data/spec/commands/renamenx_spec.rb

@@ -5,39 +5,39 @@ describe '#renamenx(key, newkey)' do
     @key = 'mock-redis-test:renamenx:key'
     @newkey = 'mock-redis-test:renamenx:newkey'
 
-    @redises.set(@key, "oof")
+    @redises.set(@key, 'oof')
   end
 
-  it "responds with true when newkey does not exist" do
+  it 'responds with true when newkey does not exist' do
     @redises.renamenx(@key, @newkey).should == true
   end
 
-  it "responds with false when newkey exists" do
+  it 'responds with false when newkey exists' do
     @redises.set(@newkey, 'monkey')
     @redises.renamenx(@key, @newkey).should == false
   end
 
-  it "moves the data" do
+  it 'moves the data' do
     @redises.renamenx(@key, @newkey)
-    @redises.get(@newkey).should == "oof"
+    @redises.get(@newkey).should == 'oof'
   end
 
-  it "raises an error when the source key is nonexistant" do
+  it 'raises an error when the source key is nonexistant' do
     @redises.del(@key)
     lambda do
       @redises.rename(@key, @newkey)
     end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error when key == newkey" do
+  it 'raises an error when key == newkey' do
     lambda do
       @redises.renamenx(@key, @key)
     end.should raise_error(RuntimeError)
   end
 
-  it "leaves any existing value at newkey alone" do
-    @redises.set(@newkey, "rab")
+  it 'leaves any existing value at newkey alone' do
+    @redises.set(@newkey, 'rab')
     @redises.renamenx(@key, @newkey)
-    @redises.get(@newkey).should == "rab"
+    @redises.get(@newkey).should == 'rab'
   end
 end

data/spec/commands/rpop_spec.rb

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe '#rpop(key)' do
   before { @key = 'mock-redis-test:43093' }
 
-  it "returns and removes the first element of a list" do
+  it 'returns and removes the first element of a list' do
     @redises.lpush(@key, 1)
     @redises.lpush(@key, 2)
 
-    @redises.rpop(@key).should == "1"
+    @redises.rpop(@key).should == '1'
 
     @redises.llen(@key).should == 1
   end
 
-  it "returns nil if the list is empty" do
+  it 'returns nil if the list is empty' do
     @redises.lpush(@key, 'foo')
     @redises.rpop(@key)
 
     @redises.rpop(@key).should be_nil
   end
 
-  it "returns nil for nonexistent values" do
+  it 'returns nil for nonexistent values' do
     @redises.rpop(@key).should be_nil
   end
 
-  it "removes empty lists" do
+  it 'removes empty lists' do
     @redises.lpush(@key, 'foo')
     @redises.rpop(@key)
 
     @redises.get(@key).should be_nil
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/rpoplpush_spec.rb

@@ -12,8 +12,8 @@ describe '#rpoplpush(source, destination)' do
     @redises.lpush(@list2, 'x')
   end
 
-  it "returns the value moved" do
-    @redises.rpoplpush(@list1, @list2).should == "b"
+  it 'returns the value moved' do
+    @redises.rpoplpush(@list1, @list2).should == 'b'
   end
 
   it "returns false and doesn't append if source empty" do
@@ -21,24 +21,24 @@ describe '#rpoplpush(source, destination)' do
     @redises.lrange(@list1, 0, -1).should == %w[a b]
   end
 
-  it "takes the last element of destination and prepends it to source" do
+  it 'takes the last element of destination and prepends it to source' do
     @redises.rpoplpush(@list1, @list2)
 
     @redises.lrange(@list1, 0, -1).should == %w[a]
     @redises.lrange(@list2, 0, -1).should == %w[b x y]
   end
 
-  it "rotates a list when source and destination are the same" do
+  it 'rotates a list when source and destination are the same' do
     @redises.rpoplpush(@list1, @list1)
     @redises.lrange(@list1, 0, -1).should == %w[b a]
   end
 
-  it "removes empty lists" do
+  it 'removes empty lists' do
     @redises.llen(@list1).times { @redises.rpoplpush(@list1, @list2) }
     @redises.get(@list1).should be_nil
   end
 
-  it "raises an error for non-list source value" do
+  it 'raises an error for non-list source value' do
     @redises.set(@list1, 'string value')
 
     lambda do
@@ -46,5 +46,5 @@ describe '#rpoplpush(source, destination)' do
     end.should raise_error(RuntimeError)
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/rpush_spec.rb

@@ -1,43 +1,43 @@
 require 'spec_helper'
 
-describe "#rpush(key)" do
+describe '#rpush(key)' do
   before { @key = "mock-redis-test:#{__FILE__}" }
 
-  it "returns the new size of the list" do
+  it 'returns the new size of the list' do
     @redises.rpush(@key, 'X').should == 1
     @redises.rpush(@key, 'X').should == 2
   end
 
-  it "creates a new list when run against a nonexistent key" do
+  it 'creates a new list when run against a nonexistent key' do
     @redises.rpush(@key, 'value')
     @redises.llen(@key).should == 1
   end
 
-  it "appends items to the list" do
-    @redises.rpush(@key, "bert")
-    @redises.rpush(@key, "ernie")
+  it 'appends items to the list' do
+    @redises.rpush(@key, 'bert')
+    @redises.rpush(@key, 'ernie')
 
-    @redises.lindex(@key, 0).should == "bert"
-    @redises.lindex(@key, 1).should == "ernie"
+    @redises.lindex(@key, 0).should == 'bert'
+    @redises.lindex(@key, 1).should == 'ernie'
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.rpush(@key, 1)
-    @redises.lindex(@key, 0).should == "1"
+    @redises.lindex(@key, 0).should == '1'
   end
 
-  it "supports a variable number of arguments" do
+  it 'supports a variable number of arguments' do
     @redises.rpush(@key, [1, 2, 3]).should == 3
-    @redises.lindex(@key, 0).should == "1"
-    @redises.lindex(@key, 1).should == "2"
-    @redises.lindex(@key, 2).should == "3"
+    @redises.lindex(@key, 0).should == '1'
+    @redises.lindex(@key, 1).should == '2'
+    @redises.lindex(@key, 2).should == '3'
   end
 
-  it "raises an error if an empty array is given" do
+  it 'raises an error if an empty array is given' do
     lambda do
       @redises.rpush(@key, [])
     end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/rpushx_spec.rb

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
-describe "#rpushx(key, value)" do
+describe '#rpushx(key, value)' do
   before { @key = 'mock-redis-test:92925' }
 
-  it "returns the new size of the list" do
+  it 'returns the new size of the list' do
     @redises.lpush(@key, 'X')
 
     @redises.rpushx(@key, 'X').should == 2
     @redises.rpushx(@key, 'X').should == 3
   end
 
-  it "does nothing when run against a nonexistent key" do
+  it 'does nothing when run against a nonexistent key' do
     @redises.rpushx(@key, 'value')
     @redises.get(@key).should be_nil
   end
 
-  it "appends items to the list" do
-    @redises.lpush(@key, "bert")
-    @redises.rpushx(@key, "ernie")
+  it 'appends items to the list' do
+    @redises.lpush(@key, 'bert')
+    @redises.rpushx(@key, 'ernie')
 
-    @redises.lindex(@key, 0).should == "bert"
-    @redises.lindex(@key, 1).should == "ernie"
+    @redises.lindex(@key, 0).should == 'bert'
+    @redises.lindex(@key, 1).should == 'ernie'
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.rpush(@key, 1)
     @redises.rpushx(@key, 2)
-    @redises.lindex(@key, 1).should == "2"
+    @redises.lindex(@key, 1).should == '2'
   end
 
-  it "raises an error if an empty array is given" do
+  it 'raises an error if an empty array is given' do
     lambda do
       @redises.rpushx(@key, [])
     end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if an array of more than one item is given" do
+  it 'raises an error if an array of more than one item is given' do
     lambda do
       @redises.rpushx(@key, [1, 2])
     end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/sadd_spec.rb

@@ -3,44 +3,43 @@ require 'spec_helper'
 describe '#sadd(key, member)' do
   before { @key = 'mock-redis-test:sadd' }
 
-  it "returns true if the set did not already contain member" do
+  it 'returns true if the set did not already contain member' do
     @redises.sadd(@key, 1).should == true
   end
 
-  it "returns false if the set did already contain member" do
+  it 'returns false if the set did already contain member' do
     @redises.sadd(@key, 1)
     @redises.sadd(@key, 1).should == false
   end
 
-  it "adds member to the set" do
+  it 'adds member to the set' do
     @redises.sadd(@key, 1)
     @redises.sadd(@key, 2)
     @redises.smembers(@key).should == %w[2 1]
   end
 
   describe 'adding multiple members at once' do
-
-    it "returns the amount of added members" do
+    it 'returns the amount of added members' do
       @redises.sadd(@key, [1, 2, 3]).should == 3
       @redises.sadd(@key, [1, 2, 3, 4]).should == 1
     end
 
-    it "returns 0 if the set did already contain all members" do
+    it 'returns 0 if the set did already contain all members' do
       @redises.sadd(@key, [1, 2, 3])
       @redises.sadd(@key, [1, 2, 3]).should == 0
     end
 
-    it "adds the members to the set" do
+    it 'adds the members to the set' do
       @redises.sadd(@key, [1, 2, 3])
       @redises.smembers(@key).should == %w[1 2 3]
     end
 
-    it "raises an error if an empty array is given" do
+    it 'raises an error if an empty array is given' do
       lambda do
         @redises.sadd(@key, [])
       end.should raise_error(Redis::CommandError)
     end
   end
 
-  it_should_behave_like "a set-only command"
+  it_should_behave_like 'a set-only command'
 end