mock_redis 0.14.1 → 0.15.0

data/spec/commands/lpush_spec.rb

@@ -1,43 +1,43 @@
 require 'spec_helper'
 
-describe "#lpush(key, value)" do
+describe '#lpush(key, value)' do
   before { @key = 'mock-redis-test:57367' }
 
-  it "returns the new size of the list" do
+  it 'returns the new size of the list' do
     @redises.lpush(@key, 'X').should == 1
     @redises.lpush(@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.lpush(@key, 'value')
     @redises.llen(@key).should == 1
   end
 
-  it "prepends items to the list" do
-    @redises.lpush(@key, "bert")
-    @redises.lpush(@key, "ernie")
+  it 'prepends items to the list' do
+    @redises.lpush(@key, 'bert')
+    @redises.lpush(@key, 'ernie')
 
-    @redises.lindex(@key, 0).should == "ernie"
-    @redises.lindex(@key, 1).should == "bert"
+    @redises.lindex(@key, 0).should == 'ernie'
+    @redises.lindex(@key, 1).should == 'bert'
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.lpush(@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.lpush(@key, [1, 2, 3]).should == 3
-    @redises.lindex(@key, 0).should == "3"
-    @redises.lindex(@key, 1).should == "2"
-    @redises.lindex(@key, 2).should == "1"
+    @redises.lindex(@key, 0).should == '3'
+    @redises.lindex(@key, 1).should == '2'
+    @redises.lindex(@key, 2).should == '1'
   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.lpush(@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/lpushx_spec.rb

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
-describe "#lpushx(key, value)" do
+describe '#lpushx(key, value)' do
   before { @key = 'mock-redis-test:81267' }
 
-  it "returns the new size of the list" do
+  it 'returns the new size of the list' do
     @redises.lpush(@key, 'X')
 
     @redises.lpushx(@key, 'X').should == 2
     @redises.lpushx(@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.lpushx(@key, 'value')
     @redises.get(@key).should be_nil
   end
 
-  it "prepends items to the list" do
-    @redises.lpush(@key, "bert")
-    @redises.lpushx(@key, "ernie")
+  it 'prepends items to the list' do
+    @redises.lpush(@key, 'bert')
+    @redises.lpushx(@key, 'ernie')
 
-    @redises.lindex(@key, 0).should == "ernie"
-    @redises.lindex(@key, 1).should == "bert"
+    @redises.lindex(@key, 0).should == 'ernie'
+    @redises.lindex(@key, 1).should == 'bert'
   end
 
-  it "stores values as strings" do
+  it 'stores values as strings' do
     @redises.lpush(@key, 1)
     @redises.lpushx(@key, 2)
-    @redises.lindex(@key, 0).should == "2"
+    @redises.lindex(@key, 0).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.lpushx(@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.lpushx(@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/lrange_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#lrange(key, start, stop)" do
+describe '#lrange(key, start, stop)' do
   before do
     @key = 'mock-redis-test:68036'
 
@@ -11,41 +11,41 @@ describe "#lrange(key, start, stop)" do
     @redises.lpush(@key, 'v0')
   end
 
-  it "returns a subset of the list inclusive of the right end" do
+  it 'returns a subset of the list inclusive of the right end' do
     @redises.lrange(@key, 0, 2).should == %w[v0 v1 v2]
   end
 
-  it "returns a subset of the list when start and end are strings" do
+  it 'returns a subset of the list when start and end are strings' do
     @redises.lrange(@key, '0', '2').should == %w[v0 v1 v2]
   end
 
-  it "returns an empty list when start > end" do
+  it 'returns an empty list when start > end' do
     @redises.lrange(@key, 3, 2).should == []
   end
 
-  it "works with a negative stop index" do
+  it 'works with a negative stop index' do
     @redises.lrange(@key, 2, -1).should == %w[v2 v3 v4]
   end
 
-  it "works with negative start and stop indices" do
+  it 'works with negative start and stop indices' do
     @redises.lrange(@key, -2, -1).should == %w[v3 v4]
   end
 
-  it "works with negative start indices less than list length" do
+  it 'works with negative start indices less than list length' do
     @redises.lrange(@key, -10, -2).should == %w[v0 v1 v2 v3]
   end
 
-  it "returns [] when run against a nonexistent value" do
-    @redises.lrange("mock-redis-test:bogus-key", 0, 1).should == []
+  it 'returns [] when run against a nonexistent value' do
+    @redises.lrange('mock-redis-test:bogus-key', 0, 1).should == []
   end
 
-  it "returns [] when start is too large" do
+  it 'returns [] when start is too large' do
     @redises.lrange(@key, 100, 100).should == []
   end
 
-  it "finds the end of the list correctly when end is too large" do
+  it 'finds the end of the list correctly when end is too large' do
     @redises.lrange(@key, 4, 10).should == %w[v4]
   end
 
-  it_should_behave_like "a list-only command"
+  it_should_behave_like 'a list-only command'
 end

data/spec/commands/lrem_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#lrem(key, count, value)" do
+describe '#lrem(key, count, value)' do
   before do
     @key = 'mock-redis-test:66767'
 
@@ -8,12 +8,12 @@ describe "#lrem(key, count, value)" do
        99 bottles of beer
        take one down
        pass it around
-       98 bottles of beer on the wall].reverse.each do |x|
+       98 bottles of beer on the wall].reverse_each do |x|
       @redises.lpush(@key, x)
     end
   end
 
-  it "deletes the first count instances of key when count > 0" do
+  it 'deletes the first count instances of key when count > 0' do
     @redises.lrem(@key, 2, 'bottles')
 
     @redises.lrange(@key, 0, 8).should == %w[
@@ -24,7 +24,7 @@ describe "#lrem(key, count, value)" do
     @redises.lrange(@key, -7, -1).should == %w[98 bottles of beer on the wall]
   end
 
-  it "deletes the last count instances of key when count < 0" do
+  it 'deletes the last count instances of key when count < 0' do
     @redises.lrem(@key, -2, 'bottles')
 
     @redises.lrange(@key, 0, 9).should == %w[
@@ -35,39 +35,39 @@ describe "#lrem(key, count, value)" do
     @redises.lrange(@key, -6, -1).should == %w[98 of beer on the wall]
   end
 
-  it "deletes all instances of key when count == 0" do
+  it 'deletes all instances of key when count == 0' do
     @redises.lrem(@key, 0, 'bottles')
     @redises.lrange(@key, 0, -1).grep(/bottles/).should be_empty
   end
 
-  it "returns the number of elements deleted" do
+  it 'returns the number of elements deleted' do
     @redises.lrem(@key, 2, 'bottles').should == 2
   end
 
-  it "returns the number of elements deleted even if you ask for more" do
+  it 'returns the number of elements deleted even if you ask for more' do
     @redises.lrem(@key, 10, 'bottles').should == 3
   end
 
-  it "stringifies value" do
+  it 'stringifies value' do
     @redises.lrem(@key, 0, 99).should == 2
   end
 
-  it "returns 0 when run against a nonexistent value" do
-    @redises.lrem("mock-redis-test:bogus-key", 0, 1).should == 0
+  it 'returns 0 when run against a nonexistent value' do
+    @redises.lrem('mock-redis-test:bogus-key', 0, 1).should == 0
   end
 
-  it "returns 0 when run against an empty list" do
+  it 'returns 0 when run against an empty list' do
     @redises.llen(@key).times { @redises.lpop(@key) } # empty the list
-    @redises.lrem(@key, 0, "beer").should == 0
+    @redises.lrem(@key, 0, 'beer').should == 0
   end
 
-  it "raises an error if the value does not look like an integer" do
+  it 'raises an error if the value does not look like an integer' do
     lambda do
       @redises.lrem(@key, 'foo', 'bottles')
     end.should raise_error(RuntimeError)
   end
 
-  it "removes empty lists" do
+  it 'removes empty lists' do
     other_key = "mock-redis-test:lrem-#{__LINE__}"
 
     @redises.lpush(other_key, 'foo')
@@ -76,5 +76,5 @@ describe "#lrem(key, count, value)" do
     @redises.get(other_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/lset_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#lset(key, index, value)" do
+describe '#lset(key, index, value)' do
   before do
     @key = 'mock-redis-test:21522'
 
@@ -9,35 +9,35 @@ describe "#lset(key, index, value)" do
   end
 
   it "returns 'OK'" do
-    @redises.lset(@key, 0, "newthing").should == 'OK'
+    @redises.lset(@key, 0, 'newthing').should == 'OK'
   end
 
   it "sets the list's value at index to value" do
-    @redises.lset(@key, 0, "newthing")
-    @redises.lindex(@key, 0).should == "newthing"
+    @redises.lset(@key, 0, 'newthing')
+    @redises.lindex(@key, 0).should == 'newthing'
   end
 
   it "sets the list's value at index to value when the index is a string" do
-    @redises.lset(@key, '0', "newthing")
-    @redises.lindex(@key, 0).should == "newthing"
+    @redises.lset(@key, '0', 'newthing')
+    @redises.lindex(@key, 0).should == 'newthing'
   end
 
-  it "stringifies value" do
-    @redises.lset(@key, 0, 12345)
-    @redises.lindex(@key, 0).should == "12345"
+  it 'stringifies value' do
+    @redises.lset(@key, 0, 12_345)
+    @redises.lindex(@key, 0).should == '12345'
   end
 
-  it "raises an exception for nonexistent keys" do
+  it 'raises an exception for nonexistent keys' do
     lambda do
       @redises.lset('mock-redis-test:bogus-key', 100, 'value')
     end.should raise_error(RuntimeError)
   end
 
-  it "raises an exception for out-of-range indices" do
+  it 'raises an exception for out-of-range indices' do
     lambda do
       @redises.lset(@key, 100, 'value')
     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/ltrim_spec.rb

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
-describe "#ltrim(key, start, stop)" do
+describe '#ltrim(key, start, stop)' do
   before do
     @key = 'mock-redis-test:22310'
 
-    %w[v0 v1 v2 v3 v4].reverse.each{|v| @redises.lpush(@key, v)}
+    %w[v0 v1 v2 v3 v4].reverse_each { |v| @redises.lpush(@key, v) }
   end
 
   it "returns 'OK'" do
     @redises.ltrim(@key, 1, 3).should == 'OK'
   end
 
-  it "trims the list to include only the specified elements" do
+  it 'trims the list to include only the specified elements' do
     @redises.ltrim(@key, 1, 3)
     @redises.lrange(@key, 0, -1).should == %w[v1 v2 v3]
   end
 
-  it "trims the list when start and stop are strings" do
+  it 'trims the list when start and stop are strings' do
     @redises.ltrim(@key, '1', '3')
     @redises.lrange(@key, 0, -1).should == %w[v1 v2 v3]
   end
 
-  it "trims the list to include only the specified elements (negative indices)" do
+  it 'trims the list to include only the specified elements (negative indices)' do
     @redises.ltrim(@key, -2, -1)
     @redises.lrange(@key, 0, -1).should == %w[v3 v4]
   end
 
-  it "trims the list to include only the specified elements (out of range negative indices)" do
+  it 'trims the list to include only the specified elements (out of range negative indices)' do
     @redises.ltrim(@key, -10, -2)
     @redises.lrange(@key, 0, -1).should == %w[v0 v1 v2 v3]
   end
 
-  it "does not crash on overly-large indices" do
+  it 'does not crash on overly-large indices' do
     @redises.ltrim(@key, 100, 200)
     @redises.lrange(@key, 0, -1).should == %w[]
   end
 
-  it "removes empty lists" do
+  it 'removes empty lists' do
     @redises.ltrim(@key, 1, 0)
     @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/mapped_hmget_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
-describe "#mapped_hmget(key, *fields)" do
+describe '#mapped_hmget(key, *fields)' do
   before do
-    @key = "mock-redis-test:mapped_hmget"
+    @key = 'mock-redis-test:mapped_hmget'
     @redises.hmset(@key, 'k1', 'v1', 'k2', 'v2')
   end
 
-  it "returns values stored at key" do
-    @redises.mapped_hmget(@key, 'k1', 'k2').should == {'k1' => 'v1', 'k2' => 'v2'}
+  it 'returns values stored at key' do
+    @redises.mapped_hmget(@key, 'k1', 'k2').should == { 'k1' => 'v1', 'k2' => 'v2' }
   end
 
-  it "returns nils for missing fields" do
+  it 'returns nils for missing fields' do
     @redises.mapped_hmget(@key, 'k1', 'mock-redis-test:nonesuch').
-      should == {'k1' => 'v1', 'mock-redis-test:nonesuch' => nil}
+      should == { 'k1' => 'v1', 'mock-redis-test:nonesuch' => nil }
   end
 
-  it "raises an error if given no fields" do
+  it 'raises an error if given no fields' do
     lambda do
       @redises.mapped_hmget(@key)
     end.should raise_error(RuntimeError)
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/mapped_hmset_spec.rb

@@ -1,45 +1,45 @@
 require 'spec_helper'
 
-describe "#mapped_hmset(key, hash={})" do
+describe '#mapped_hmset(key, hash={})' do
   before do
-    @key = "mock-redis-test:mapped_hmset"
+    @key = 'mock-redis-test:mapped_hmset'
   end
 
   it "returns 'OK'" do
-    @redises.mapped_hmset(@key, {'k1'=>'v1', 'k2'=>'v2'}).should == 'OK'
+    @redises.mapped_hmset(@key, 'k1' => 'v1', 'k2' => 'v2').should == 'OK'
   end
 
-  it "sets the values" do
-    @redises.mapped_hmset(@key, {'k1'=>'v1', 'k2'=>'v2'})
+  it 'sets the values' do
+    @redises.mapped_hmset(@key, 'k1' => 'v1', 'k2' => 'v2')
     @redises.hmget(@key, 'k1', 'k2').should == %w[v1 v2]
   end
 
-  it "updates an existing hash" do
+  it 'updates an existing hash' do
     @redises.hmset(@key, 'foo', 'bar')
-    @redises.mapped_hmset(@key, {'bert' => 'ernie', 'diet' => 'coke'})
+    @redises.mapped_hmset(@key, 'bert' => 'ernie', 'diet' => 'coke')
 
     @redises.hmget(@key, 'foo', 'bert', 'diet').
       should == %w[bar ernie coke]
   end
 
-  it "stores the values as strings" do
-    @redises.mapped_hmset(@key, {'one' => 1})
+  it 'stores the values as strings' do
+    @redises.mapped_hmset(@key, 'one' => 1)
     @redises.hget(@key, 'one').should == '1'
   end
 
-  it "raises an error if given no hash" do
+  it 'raises an error if given no hash' do
     lambda do
       @redises.mapped_hmset(@key)
     end.should raise_error(ArgumentError)
   end
 
-  it "raises an error if given a an odd length array" do
+  it 'raises an error if given a an odd length array' do
     lambda do
       @redises.mapped_hmset(@key, [1])
     end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if given a non-hash value" do
+  it 'raises an error if given a non-hash value' do
     lambda do
       @redises.mapped_hmset(@key, 1)
     end.should raise_error(NoMethodError)