mock_redis 0.5.4 → 0.31.0

data/spec/commands/lpushx_spec.rb

@@ -1,33 +1,46 @@
 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_should_behave_like "a list-only command"
+  it 'raises an error if an empty array is given' do
+    @redises.lpush(@key, 'X')
+    lambda do
+      @redises.lpushx(@key, [])
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it 'stores multiple items if an array of more than one item is given' do
+    @redises.lpush(@key, 'X')
+    @redises.lpushx(@key, [1, 2]).should == 3
+    @redises.lrange(@key, 0, -1).should == %w[2 1 X]
+  end
+
+  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,25 +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 an empty list when start > end" 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
     @redises.lrange(@key, 3, 2).should == []
   end
 
-  it "works with negative indices" do
+  it 'works with a negative stop index' do
     @redises.lrange(@key, 2, -1).should == %w[v2 v3 v4]
   end
 
-  it "returns [] when run against a nonexistent value" do
-    @redises.lrange("mock-redis-test:bogus-key", 0, 1).should == []
+  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
+    @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 == []
+  end
+
+  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.should raise_error(Redis::CommandError)
   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,30 +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 "stringifies value" do
-    @redises.lset(@key, 0, 12345)
-    @redises.lindex(@key, 0).should == "12345"
+  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'
   end
 
-  it "raises an exception for nonexistent keys" do
+  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
     lambda do
       @redises.lset('mock-redis-test:bogus-key', 100, 'value')
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   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.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/ltrim_spec.rb

@@ -1,35 +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 to include only the specified elements (negative indices)" 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
     @redises.ltrim(@key, -2, -1)
     @redises.lrange(@key, 0, -1).should == %w[v3 v4]
   end
 
-  it "does not crash on overly-large 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
     @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,29 @@
 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 'treats an array as the first key' do
+    @redises.mapped_hmget(@key, %w[k1 k2]).should == { %w[k1 k2] => 'v1' }
+  end
+
+  it 'raises an error if given no fields' do
     lambda do
       @redises.mapped_hmget(@key)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   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)

data/spec/commands/mapped_mget_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe '#mapped_mget(*keys)' do
+  before do
+    @key1 = 'mock-redis-test:a'
+    @key2 = 'mock-redis-test:b'
+    @key3 = 'mock-redis-test:c'
+
+    @redises.set(@key1, '1')
+    @redises.set(@key2, '2')
+  end
+
+  it 'returns a hash' do
+    @redises.mapped_mget(@key1, @key2, @key3).should eq(@key1 => '1',
+                                                        @key2 => '2',
+                                                        @key3 => nil)
+  end
+
+  it 'returns a hash even when no matches' do
+    @redises.mapped_mget('qwer').should eq('qwer' => nil)
+  end
+end

data/spec/commands/mapped_mset_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe '#mapped_mset(hash)' do
+  before do
+    @key1 = 'mock-redis-test:a'
+    @key2 = 'mock-redis-test:b'
+    @key3 = 'mock-redis-test:c'
+
+    @redises.set(@key1, '1')
+    @redises.set(@key2, '2')
+  end
+
+  it 'sets the values properly' do
+    @redises.mapped_mset(@key1 => 'one', @key3 => 'three').should eq('OK')
+    @redises.get(@key1).should eq('one')
+    @redises.get(@key2).should eq('2') # left alone
+    @redises.get(@key3).should eq('three')
+  end
+end

data/spec/commands/mapped_msetnx_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe '#mapped_msetnx(hash)' do
+  before do
+    @key1 = 'mock-redis-test:a'
+    @key2 = 'mock-redis-test:b'
+    @key3 = 'mock-redis-test:c'
+
+    @redises.set(@key1, '1')
+    @redises.set(@key2, '2')
+  end
+
+  it 'sets properly when none collide' do
+    @redises.mapped_msetnx(@key3 => 'three').should eq(true)
+    @redises.get(@key1).should eq('1') # existed; untouched
+    @redises.get(@key2).should eq('2') # existed; untouched
+    @redises.get(@key3).should eq('three')
+  end
+
+  it 'does not set any when any collide' do
+    @redises.mapped_msetnx(@key1 => 'one', @key3 => 'three').should eq(false)
+    @redises.get(@key1).should eq('1') # existed; untouched
+    @redises.get(@key2).should eq('2') # existed; untouched
+    @redises.get(@key3).should be_nil
+  end
+end

data/spec/commands/mget_spec.rb

@@ -1,34 +1,65 @@
 require 'spec_helper'
 
-describe "#mget(key [, key, ...])" do
+describe '#mget(key [, key, ...])' do
   before do
-    @key1 = "mock-redis-test:mget1"
-    @key2 = "mock-redis-test:mget2"
+    @key1 = 'mock-redis-test:mget1'
+    @key2 = 'mock-redis-test:mget2'
 
     @redises.set(@key1, 1)
     @redises.set(@key2, 2)
   end
 
-  it "returns an array of values" do
-    @redises.mget(@key1, @key2).should == %w[1 2]
-  end
+  context 'emulate param array' do
+    it 'returns an array of values' do
+      @redises.mget([@key1, @key2]).should == %w[1 2]
+    end
+
+    it 'returns an array of values' do
+      @redises.mget([@key1, @key2]).should == %w[1 2]
+    end
+
+    it 'returns nil for non-string keys' do
+      list = 'mock-redis-test:mget-list'
+
+      @redises.lpush(list, 'bork bork bork')
 
-  it "returns nil for missing keys" do
-    @redises.mget(@key1, 'mock-redis-test:not-found', @key2).
-      should == ["1", nil, "2"]
+      @redises.mget([@key1, @key2, list]).should == ['1', '2', nil]
+    end
   end
 
-  it "returns nil for non-string keys" do
-    list = "mock-redis-test:mget-list"
+  context 'emulate params strings' do
+    it 'returns an array of values' do
+      @redises.mget(@key1, @key2).should == %w[1 2]
+    end
+
+    it 'returns nil for missing keys' do
+      @redises.mget(@key1, 'mock-redis-test:not-found', @key2).should == ['1', nil, '2']
+    end
+
+    it 'returns nil for non-string keys' do
+      list = 'mock-redis-test:mget-list'
+
+      @redises.lpush(list, 'bork bork bork')
+
+      @redises.mget(@key1, @key2, list).should == ['1', '2', nil]
+    end
 
-    @redises.lpush(list, 'bork bork bork')
+    it 'raises an error if you pass it 0 arguments' do
+      lambda do
+        @redises.mget
+      end.should raise_error(Redis::CommandError)
+    end
 
-    @redises.mget(@key1, @key2, list).should == ["1", "2", nil]
+    it 'raises an error if you pass it empty array' do
+      lambda do
+        @redises.mget([])
+      end.should raise_error(Redis::CommandError)
+    end
   end
 
-  it "raises an error if you pass it 0 arguments" do
-    lambda do
-      @redises.mget()
-    end.should raise_error(RuntimeError)
+  context 'emulate block' do
+    it 'returns an array of values' do
+      @redises.mget(@key1, @key2) { |values| values.map(&:to_i) }.should == [1, 2]
+    end
   end
 end