mock_redis 0.5.4 → 0.31.0

data/spec/commands/hexists_spec.rb

@@ -1,27 +1,27 @@
 require 'spec_helper'
 
-describe "#hexists(key, field)" do
+describe '#hexists(key, field)' do
   before do
-    @key = "mock-redis-test:hexists"
+    @key = 'mock-redis-test:hexists'
     @redises.hset(@key, 'field', 'value')
   end
 
-  it "returns true if the hash has that field" do
-    @redises.hexists(@key, 'field').should be_true
+  it 'returns true if the hash has that field' do
+    @redises.hexists(@key, 'field').should == true
   end
 
-  it "returns false if the hash lacks that field" do
-    @redises.hexists(@key, 'nonesuch').should be_false
+  it 'returns false if the hash lacks that field' do
+    @redises.hexists(@key, 'nonesuch').should == false
   end
 
-  it "treats the field as a string" do
+  it 'treats the field as a string' do
     @redises.hset(@key, 1, 'one')
-    @redises.hexists(@key, 1).should be_true
+    @redises.hexists(@key, 1).should == true
   end
 
-  it "returns nil when there is no such key" do
-    @redises.hexists('mock-redis-test:nonesuch', 'key').should be_false
+  it 'returns nil when there is no such key' do
+    @redises.hexists('mock-redis-test:nonesuch', 'key').should == false
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hget_spec.rb

@@ -1,28 +1,28 @@
 require 'spec_helper'
 
-describe "#hget(key, field)" do
+describe '#hget(key, field)' do
   before do
-    @key = "mock-redis-test:hget"
+    @key = 'mock-redis-test:hget'
     @redises.hset(@key, 'k1', 'v1')
     @redises.hset(@key, 'k2', 'v2')
   end
 
-  it "returns the value stored at field" do
+  it 'returns the value stored at field' do
     @redises.hget(@key, 'k1').should == 'v1'
   end
 
-  it "treats the field as a string" do
+  it 'treats the field as a string' do
     @redises.hset(@key, '3', 'v3')
     @redises.hget(@key, 3).should == 'v3'
   end
 
-  it "returns nil when there is no such field" do
+  it 'returns nil when there is no such field' do
     @redises.hget(@key, 'nonesuch').should be_nil
   end
 
-  it "returns nil when there is no such key" do
+  it 'returns nil when there is no such key' do
     @redises.hget('mock-redis-test:nonesuch', 'k1').should be_nil
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hgetall_spec.rb

@@ -1,22 +1,32 @@
 require 'spec_helper'
 
-describe "#hgetall(key)" do
+describe '#hgetall(key)' do
   before do
-    @key = "mock-redis-test:hgetall"
+    @key = 'mock-redis-test:hgetall'
     @redises.hset(@key, 'k1', 'v1')
     @redises.hset(@key, 'k2', 'v2')
   end
 
-  it "returns the (key, value) pairs stored in the hash" do
+  it 'returns the (key, value) pairs stored in the hash' do
     @redises.hgetall(@key).should == {
       'k1' => 'v1',
       'k2' => 'v2',
     }
   end
 
-  it "returns [] when there is no such key" do
+  it 'returns [] when there is no such key' do
     @redises.hgetall('mock-redis-test:nonesuch').should == {}
   end
 
-  it_should_behave_like "a hash-only command"
+  it "doesn't return a mutable reference to the returned data" do
+    mr = MockRedis.new
+    mr.hset(@key, 'k1', 'v1')
+    mr.hset(@key, 'k2', 'v2')
+    hash = mr.hgetall(@key)
+    hash['dont'] = 'mutate'
+    new_hash = mr.hgetall(@key)
+    new_hash.keys.sort.should == %w[k1 k2]
+  end
+
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hincrby_spec.rb

@@ -6,53 +6,53 @@ describe '#hincrby(key, field, increment)' do
     @field = 'count'
   end
 
-  it "returns the value after the increment" do
+  it 'returns the value after the increment' do
     @redises.hset(@key, @field, 2)
     @redises.hincrby(@key, @field, 2).should == 4
   end
 
-  it "treats a missing key like 0" do
+  it 'treats a missing key like 0' do
     @redises.hincrby(@key, @field, 1).should == 1
   end
 
-  it "creates a hash if nothing is present" do
+  it 'creates a hash if nothing is present' do
     @redises.hincrby(@key, @field, 1)
-    @redises.hget(@key, @field).should == "1"
+    @redises.hget(@key, @field).should == '1'
   end
 
-  it "increments negative numbers" do
+  it 'increments negative numbers' do
     @redises.hset(@key, @field, -10)
     @redises.hincrby(@key, @field, 2).should == -8
   end
 
-  it "works multiple times" do
+  it 'works multiple times' do
     @redises.hincrby(@key, @field, 2).should == 2
     @redises.hincrby(@key, @field, 2).should == 4
     @redises.hincrby(@key, @field, 2).should == 6
   end
 
-  it "accepts an integer-ish string" do
-    @redises.hincrby(@key, @field, "2").should == 2
+  it 'accepts an integer-ish string' do
+    @redises.hincrby(@key, @field, '2').should == 2
   end
 
-  it "treats the field as a string" do
+  it 'treats the field as a string' do
     field = 11
     @redises.hset(@key, field, 2)
     @redises.hincrby(@key, field, 2).should == 4
   end
 
-  it "raises an error if the value does not look like an integer" do
-    @redises.hset(@key, @field, "one")
+  it 'raises an error if the value does not look like an integer' do
+    @redises.hset(@key, @field, 'one')
     lambda do
       @redises.hincrby(@key, @field, 1)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if the delta does not look like an integer" do
+  it 'raises an error if the delta does not look like an integer' do
     lambda do
-      @redises.hincrby(@key, @field, "foo")
-    end.should raise_error(RuntimeError)
+      @redises.hincrby(@key, @field, 'foo')
+    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/hincrbyfloat_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe '#hincrbyfloat(key, field, increment)' do
+  before do
+    @key = 'mock-redis-test:hincrbyfloat'
+    @field = 'count'
+  end
+
+  it 'returns the value after the increment' do
+    @redises.hset(@key, @field, 2.0)
+    @redises.hincrbyfloat(@key, @field, 2.1).should be_within(0.0001).of(4.1)
+  end
+
+  it 'treats a missing key like 0' do
+    @redises.hincrbyfloat(@key, @field, 1.2).should be_within(0.0001).of(1.2)
+  end
+
+  it 'creates a hash if nothing is present' do
+    @redises.hincrbyfloat(@key, @field, 1.0)
+    @redises.hget(@key, @field).should == '1'
+  end
+
+  it 'increments negative numbers' do
+    @redises.hset(@key, @field, -10.4)
+    @redises.hincrbyfloat(@key, @field, 2.3).should be_within(0.0001).of(-8.1)
+  end
+
+  it 'works multiple times' do
+    @redises.hincrbyfloat(@key, @field, 2.1).should be_within(0.0001).of(2.1)
+    @redises.hincrbyfloat(@key, @field, 2.2).should be_within(0.0001).of(4.3)
+    @redises.hincrbyfloat(@key, @field, 2.3).should be_within(0.0001).of(6.6)
+  end
+
+  it 'accepts a float-ish string' do
+    @redises.hincrbyfloat(@key, @field, '2.2').should be_within(0.0001).of(2.2)
+  end
+
+  it 'treats the field as a string' do
+    field = 11
+    @redises.hset(@key, field, 2)
+    @redises.hincrbyfloat(@key, field, 2).should == 4.0
+  end
+
+  it 'raises an error if the value does not look like a float' do
+    @redises.hset(@key, @field, 'one.two')
+    lambda do
+      @redises.hincrbyfloat(@key, @field, 1)
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it 'raises an error if the delta does not look like a float' do
+    lambda do
+      @redises.hincrbyfloat(@key, @field, 'foobar.baz')
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it_should_behave_like 'a hash-only command'
+end

data/spec/commands/hkeys_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-describe "#hkeys(key)" do
+describe '#hkeys(key)' do
   before do
-    @key = "mock-redis-test:hkeys"
+    @key = 'mock-redis-test:hkeys'
     @redises.hset(@key, 'k1', 'v1')
     @redises.hset(@key, 'k2', 'v2')
   end
 
-  it "returns the keys stored in the hash" do
+  it 'returns the keys stored in the hash' do
     @redises.hkeys(@key).sort.should == %w[k1 k2]
   end
 
-  it "returns [] when there is no such key" do
+  it 'returns [] when there is no such key' do
     @redises.hkeys('mock-redis-test:nonesuch').should == []
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hlen_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-describe "#hlen(key)" do
+describe '#hlen(key)' do
   before do
-    @key = "mock-redis-test:hlen"
+    @key = 'mock-redis-test:hlen'
     @redises.hset(@key, 'k1', 'v1')
     @redises.hset(@key, 'k2', 'v2')
   end
 
-  it "returns the number of keys stored in the hash" do
+  it 'returns the number of keys stored in the hash' do
     @redises.hlen(@key).should == 2
   end
 
-  it "returns [] when there is no such key" do
+  it 'returns [] when there is no such key' do
     @redises.hlen('mock-redis-test:nonesuch').should == 0
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hmget_spec.rb

@@ -1,36 +1,46 @@
 require 'spec_helper'
 
-describe "#hmget(key, field [, field, ...])" do
+describe '#hmget(key, field [, field, ...])' do
   before do
-    @key = "mock-redis-test:hmget"
+    @key = 'mock-redis-test:hmget'
     @redises.hset(@key, 'k1', 'v1')
     @redises.hset(@key, 'k2', 'v2')
   end
 
-  it "returns the values for those keys" do
+  it 'returns the values for those keys' do
     @redises.hmget(@key, 'k1', 'k2').sort.should == %w[v1 v2]
   end
 
-  it "treats the fielsd as strings" do
+  it 'treats an array as multiple keys' do
+    @redises.hmget(@key, %w[k1 k2]).sort.should == %w[v1 v2]
+  end
+
+  it 'treats the fielsd as strings' do
     @redises.hset(@key, 1, 'one')
     @redises.hset(@key, 2, 'two')
     @redises.hmget(@key, 1, 2).sort.should == %w[one two]
   end
 
-  it "returns nils when there are no such fields" do
+  it 'returns nils when there are no such fields' do
     @redises.hmget(@key, 'k1', 'mock-redis-test:nonesuch').
       should == ['v1', nil]
   end
 
-  it "returns nils when there is no such key" do
+  it 'returns nils when there is no such key' do
     @redises.hmget(@key, 'mock-redis-test:nonesuch').should == [nil]
   end
 
-  it "raises an error if given no fields" do
+  it 'raises an error if given no fields' do
     lambda do
       @redises.hmget(@key)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
+  end
+
+  it 'raises an error if given an empty list of fields' do
+    lambda do
+      @redises.hmget(@key, [])
+    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/hmset_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
-describe "#hmset(key, field, value [, field, value ...])" do
+describe '#hmset(key, field, value [, field, value ...])' do
   before do
-    @key = "mock-redis-test:hmset"
+    @key = 'mock-redis-test:hmset'
   end
 
   it "returns 'OK'" do
-    @redises.hmset(@key, 'k1', 'v1', 'k2', 'v2').should == "OK"
+    @redises.hmset(@key, 'k1', 'v1', 'k2', 'v2').should == 'OK'
   end
 
-  it "sets the values" do
+  it 'sets the values' do
     @redises.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.hset(@key, 'foo', 'bar')
     @redises.hmset(@key, 'bert', 'ernie', 'diet', 'coke')
 
@@ -22,22 +22,48 @@ describe "#hmset(key, field, value [, field, value ...])" do
       should == %w[bar ernie coke]
   end
 
-  it "stores the values as strings" do
+  it 'stores the values as strings' do
     @redises.hmset(@key, 'one', 1)
-    @redises.hget(@key, 'one').should == "1"
+    @redises.hget(@key, 'one').should == '1'
   end
 
-  it "raises an error if given no fields or values" do
+  it 'raises an error if given no fields or values' do
     lambda do
       @redises.hmset(@key)
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it "raises an error if given an odd number of fields+values" do
+  it 'raises an error if given an odd number of fields+values' do
     lambda do
       @redises.hmset(@key, 'k1', 1, 'k2')
-    end.should raise_error(RuntimeError)
+    end.should raise_error(Redis::CommandError)
   end
 
-  it_should_behave_like "a hash-only command"
+  # The following tests address https://github.com/sds/mock_redis/issues/170
+  context 'keys are stored as strings' do
+    before do
+      @redises.hmset(1, :foo, :bar)
+      @redises.hmset(:a_sym, :boo, :bas)
+    end
+
+    it { expect(@redises.hgetall('1')).to eq @redises.hgetall(1) }
+    it { expect(@redises.hgetall('a_sym')).to eq @redises.hgetall(:a_sym) }
+    it { expect(@redises.del('1')).to eq 1 }
+    it { expect(@redises.del(1)).to eq 1 }
+    it { expect(@redises.del('a_sym')).to eq 1 }
+    it { expect(@redises.del(:a_sym)).to eq 1 }
+
+    after do
+      @redises.del(1)
+      @redises.del(:a_sym)
+    end
+  end
+
+  # The following tests address https://github.com/sds/mock_redis/issues/134
+  context 'hmset accepts an array as its only argument' do
+    it { expect(@redises.hmset([@key, :bar, :bas])).to eq 'OK' }
+    it { lambda { @redises.hmset([:foo, :bar]) }.should raise_error(Redis::CommandError) }
+  end
+
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hscan_each_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe '#hscan_each' do
+  subject { MockRedis::Database.new(self) }
+
+  let(:key) { 'mock-redis-test:hscan_each' }
+
+  before do
+    allow(subject).to receive(:hgetall).and_return(collection)
+  end
+
+  context 'when no keys are found' do
+    let(:collection) { [] }
+
+    it 'does not iterate over any elements' do
+      results = subject.hscan_each(key).map do |k, v|
+        [k, v]
+      end
+      expect(results).to match_array(collection)
+    end
+  end
+
+  context 'when keys are found' do
+    context 'when no match filter is supplied' do
+      let(:collection) { Array.new(20) { |i| ["k#{i}", "v#{i}"] } }
+
+      it 'iterates over each item in the collection' do
+        results = subject.hscan_each(key).map do |k, v|
+          [k, v]
+        end
+        expect(results).to match_array(collection)
+      end
+    end
+
+    context 'when giving a custom match filter' do
+      let(:match) { 'k1*' }
+      let(:collection) { Array.new(12) { |i| ["k#{i}", "v#{i}"] } }
+      let(:expected) { [%w[k1 v1], %w[k10 v10], %w[k11 v11]] }
+
+      it 'iterates over each item in the filtered collection' do
+        results = subject.hscan_each(key, match: match).map do |k, v|
+          [k, v]
+        end
+        expect(results).to match_array(expected)
+      end
+    end
+  end
+end

data/spec/commands/hscan_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe '#hscan' do
+  let(:count) { 10 }
+  let(:match) { '*' }
+  let(:key) { 'mock-redis-test:hscan' }
+
+  context 'when the hash does not exist' do
+    it 'returns a 0 cursor and an empty collection' do
+      expect(@redises.hscan(key, 0, count: count, match: match)).to eq(['0', []])
+    end
+  end
+
+  context 'when the hash exists' do
+    before do
+      @redises.hset(key, 'k1', 'v1')
+      @redises.hset(key, 'k2', 'v2')
+      @redises.hset(key, 'k3', 'v3')
+    end
+
+    let(:expected) { ['0', [%w[k1 v1], %w[k2 v2], %w[k3 v3]]] }
+
+    it 'returns a 0 cursor and the collection' do
+      expect(@redises.hscan(key, 0, count: 10)).to eq(expected)
+    end
+  end
+end

data/spec/commands/hset_spec.rb

@@ -1,28 +1,42 @@
 require 'spec_helper'
 
-describe "#hset(key, field)" do
+describe '#hset(key, field)' do
   before do
-    @key = "mock-redis-test:hset"
+    @key = 'mock-redis-test:hset'
   end
 
-  it "returns true" do
-    @redises.hset(@key, 'k1', 'v1').should == true
+  it 'returns 1 if the key does not exist' do
+    @redises.hset(@key, 'k1', 'v1').should == 1
   end
 
-  it "creates a hash there is no such field" do
+  it 'returns 1 if the key exists but the field does not' do
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k2', 'v2').should == 1
+  end
+
+  it 'returns 0 if the field already exists' do
+    @redises.hset(@key, 'k1', 'v1')
+    @redises.hset(@key, 'k1', 'v1').should == 0
+  end
+
+  it 'creates a hash there is no such field' do
     @redises.hset(@key, 'k1', 'v1')
     @redises.hget(@key, 'k1').should == 'v1'
   end
 
-  it "stores values as strings" do
-    @redises.hset(@key, "num", 1)
-    @redises.hget(@key, 'num').should == "1"
+  it 'stores values as strings' do
+    @redises.hset(@key, 'num', 1)
+    @redises.hget(@key, 'num').should == '1'
+  end
+
+  it 'stores fields as strings' do
+    @redises.hset(@key, 1, 'one')
+    @redises.hget(@key, '1').should == 'one'
   end
 
-  it "stores fields as strings" do
-    @redises.hset(@key, 1, "one")
-    @redises.hget(@key, "1").should == "one"
+  it 'stores fields sent in a hash' do
+    @redises.hset(@key, { 'k1' => 'v1', 'k2' => 'v2' }).should == 2
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hsetnx_spec.rb

@@ -1,44 +1,44 @@
 require 'spec_helper'
 
-describe "#hsetnx(key, field)" do
+describe '#hsetnx(key, field)' do
   before do
-    @key = "mock-redis-test:hsetnx"
+    @key = 'mock-redis-test:hsetnx'
   end
 
-  it "returns true if the field is absent" do
-    @redises.hsetnx(@key, 'field', 'val').should be_true
+  it 'returns true if the field is absent' do
+    @redises.hsetnx(@key, 'field', 'val').should == true
   end
 
-  it "returns 0 if the field is present" do
+  it 'returns 0 if the field is present' do
     @redises.hset(@key, 'field', 'val')
-    @redises.hsetnx(@key, 'field', 'val').should be_false
+    @redises.hsetnx(@key, 'field', 'val').should == false
   end
 
-  it "leaves the field unchanged if the field is present" do
+  it 'leaves the field unchanged if the field is present' do
     @redises.hset(@key, 'field', 'old')
     @redises.hsetnx(@key, 'field', 'new')
     @redises.hget(@key, 'field').should == 'old'
   end
 
-  it "sets the field if the field is absent" do
+  it 'sets the field if the field is absent' do
     @redises.hsetnx(@key, 'field', 'new')
     @redises.hget(@key, 'field').should == 'new'
   end
 
-  it "creates a hash if there is no such field" do
+  it 'creates a hash if there is no such field' do
     @redises.hsetnx(@key, 'field', 'val')
     @redises.hget(@key, 'field').should == 'val'
   end
 
-  it "stores values as strings" do
-    @redises.hsetnx(@key, "num", 1)
-    @redises.hget(@key, 'num').should == "1"
+  it 'stores values as strings' do
+    @redises.hsetnx(@key, 'num', 1)
+    @redises.hget(@key, 'num').should == '1'
   end
 
-  it "stores fields as strings" do
-    @redises.hsetnx(@key, 1, "one")
-    @redises.hget(@key, "1").should == "one"
+  it 'stores fields as strings' do
+    @redises.hsetnx(@key, 1, 'one')
+    @redises.hget(@key, '1').should == 'one'
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hvals_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-describe "#hvals(key)" do
+describe '#hvals(key)' do
   before do
-    @key = "mock-redis-test:hvals"
+    @key = 'mock-redis-test:hvals'
     @redises.hset(@key, 'k1', 'v1')
     @redises.hset(@key, 'k2', 'v2')
   end
 
-  it "returns the values stored in the hash" do
+  it 'returns the values stored in the hash' do
     @redises.hvals(@key).sort.should == %w[v1 v2]
   end
 
-  it "returns [] when there is no such key" do
+  it 'returns [] when there is no such key' do
     @redises.hvals('mock-redis-test:nonesuch').should == []
   end
 
-  it_should_behave_like "a hash-only command"
+  it_should_behave_like 'a hash-only command'
 end