mock_redis 0.19.0 → 0.24.0

data/mock_redis.gemspec

@@ -6,9 +6,9 @@ Gem::Specification.new do |s|
   s.version     = MockRedis::VERSION
   s.license     = 'MIT'
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Brigade Engineering', 'Samuel Merritt']
-  s.email       = ['eng@brigade.com']
-  s.homepage    = 'https://github.com/brigade/mock_redis'
+  s.authors     = ['Shane da Silva', 'Samuel Merritt']
+  s.email       = ['shane@dasilva.io']
+  s.homepage    = 'https://github.com/sds/mock_redis'
   s.summary     = 'Redis mock that just lives in memory; useful for testing.'
 
   s.description = <<-MSG.strip.gsub(/\s+/, ' ')
@@ -21,10 +21,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ['lib']
 
-  s.required_ruby_version = '>= 2.2'
+  s.required_ruby_version = '>= 2.4'
 
-  s.add_development_dependency 'rake', '>= 10', '< 12'
-  s.add_development_dependency 'redis', '~> 3.3.0'
+  s.add_development_dependency 'redis', '~> 4.2.0'
   s.add_development_dependency 'rspec', '~> 3.0'
   s.add_development_dependency 'rspec-its', '~> 1.0'
+  s.add_development_dependency 'timecop', '~> 0.9.1'
 end

data/spec/client_spec.rb

@@ -14,4 +14,16 @@ describe 'client' do
       redis.connect.should == redis
     end
   end
+
+  context '#disconnect!' do
+    it 'responds to disconnect!' do
+      expect(MockRedis.new).to respond_to(:disconnect!)
+    end
+  end
+
+  context '#close' do
+    it 'responds to close' do
+      expect(MockRedis.new).to respond_to(:close)
+    end
+  end
 end

data/spec/commands/blpop_spec.rb

@@ -27,12 +27,6 @@ describe '#blpop(key [, key, ...,], timeout)' do
       [@list1, 'one']
   end
 
-  it 'raises an error on subsecond timeouts' do
-    lambda do
-      @redises.blpop(@list1, @list2, :timeout => 0.5)
-    end.should raise_error(Redis::CommandError)
-  end
-
   it 'raises an error on negative timeout' do
     lambda do
       @redises.blpop(@list1, @list2, :timeout => -1)

data/spec/commands/brpop_spec.rb

@@ -26,11 +26,12 @@ describe '#brpop(key [, key, ...,], timeout)' do
       [@list1, 'two']
   end
 
-  it 'raises an error on subsecond timeouts' do
-    lambda do
-      @redises.brpop(@list1, @list2, :timeout => 0.5)
-    end.should raise_error(Redis::CommandError)
-  end
+  # TODO: Not sure how redis-rb is handling this but they're not raising an error
+  # it 'raises an error on subsecond timeouts' do
+  #   lambda do
+  #     @redises.brpop(@list1, @list2, :timeout => 0.5)
+  #   end.should raise_error(Redis::CommandError)
+  # end
 
   it 'raises an error on negative timeout' do
     lambda do

data/spec/commands/dump_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe '#dump(key)' do
+  before do
+    @key = 'mock-redis-test:45794'
+    # These are mock-only, since our dump/restore implementations
+    # aren't compatible with real redis.
+    @mock = @redises.mock
+  end
+
+  it 'returns nil for keys that do not exist' do
+    @mock.dump(@key).should be_nil
+  end
+
+  it 'returns a serialized value for keys that do exist' do
+    @mock.set(@key, '2')
+    @mock.dump(@key).should == Marshal.dump('2')
+  end
+end

data/spec/commands/exists_spec.rb

@@ -1,14 +1,43 @@
 require 'spec_helper'
 
-describe '#exists(key)' do
-  before { @key = 'mock-redis-test:45794' }
+describe '#exists(*keys)' do
+  before { @key1 = 'mock-redis-test:exists1' }
+  before { @key2 = 'mock-redis-test:exists2' }
+
+  it 'returns 0 for keys that do not exist' do
+    @redises.exists(@key1).should == 0
+    @redises.exists(@key1, @key2).should == 0
+  end
+
+  it 'returns 1 for keys that do exist' do
+    @redises.set(@key1, 1)
+    @redises.exists(@key1).should == 1
+  end
+
+  it 'returns the count of all keys that exist' do
+    @redises.set(@key1, 1)
+    @redises.set(@key2, 1)
+    @redises.exists(@key1, @key2).should == 2
+    @redises.exists(@key1, @key2, 'does-not-exist').should == 2
+  end
+end
+
+describe '#exists?(*keys)' do
+  before { @key1 = 'mock-redis-test:exists1' }
+  before { @key2 = 'mock-redis-test:exists2' }
 
   it 'returns false for keys that do not exist' do
-    @redises.exists(@key).should == false
+    @redises.exists?(@key1).should == false
+    @redises.exists?(@key1, @key2).should == false
   end
 
   it 'returns true for keys that do exist' do
-    @redises.set(@key, 1)
-    @redises.exists(@key).should == true
+    @redises.set(@key1, 1)
+    @redises.exists?(@key1).should == true
+  end
+
+  it 'returns true if any keys exist' do
+    @redises.set(@key2, 1)
+    @redises.exists?(@key1, @key2).should == true
   end
 end

data/spec/commands/future_spec.rb

@@ -3,7 +3,12 @@ require 'spec_helper'
 describe MockRedis::Future do
   let(:command) { [:get, 'foo'] }
   let(:result)  { 'bar' }
-  before        { @future = MockRedis::Future.new(command) }
+  let(:block)   { ->(value) { value.upcase } }
+
+  before do
+    @future = MockRedis::Future.new(command)
+    @future2 = MockRedis::Future.new(command, block)
+  end
 
   it 'remembers the command' do
     @future.command.should eq(command)
@@ -17,4 +22,9 @@ describe MockRedis::Future do
     @future.store_result(result)
     @future.value.should eq(result)
   end
+
+  it 'executes the block on the value if block is passed in' do
+    @future2.store_result(result)
+    @future2.value.should eq('BAR')
+  end
 end

data/spec/commands/geoadd_spec.rb

@@ -33,7 +33,7 @@ describe '#geoadd' do
     context 'when coordinates are not in allowed range' do
       let(:coords) { [181, 86] }
       let(:message) do
-        formatted_coords = coords.map { |c| format('%.6f', c) }
+        formatted_coords = coords.map { |c| format('%<coords>.6f', coords: c) }
         "ERR invalid longitude,latitude pair #{formatted_coords.join(',')}"
       end
 

data/spec/commands/geodist_spec.rb

@@ -80,13 +80,14 @@ describe '#geodist' do
 
     context 'with less than 3 arguments' do
       [1, 2].each do |count|
-        let(:message) { "ERR wrong number of arguments for 'geodist' command" }
-
         context "with #{count} arguments" do
           it 'raises an error' do
             args = list.slice(0, count)
             expect { @redises.geodist(*args) }
-              .to raise_error(Redis::CommandError, message)
+              .to raise_error(
+                ArgumentError,
+                /wrong number of arguments \((given\s)?#{count}(,\sexpected\s|\sfor\s)3?\.\.4\)$/
+              )
           end
         end
       end
@@ -98,7 +99,10 @@ describe '#geodist' do
       it 'raises an error' do
         args = list.slice(0, 5)
         expect { @redises.geodist(*args) }
-          .to raise_error(Redis::CommandError, message)
+          .to raise_error(
+            ArgumentError,
+            /wrong number of arguments \((given\s)?5(,\sexpected\s|\sfor\s)3?\.\.4\)$/
+          )
       end
     end
   end

data/spec/commands/geohash_spec.rb

@@ -17,13 +17,13 @@ describe '#geohash' do
       end
 
       it 'returns decoded coordinates pairs for each point' do
-        results = @redises.geohash(key, 'SF', 'LA')
+        results = @redises.geohash(key, %w[SF LA])
         expect(results).to be == expected_result
       end
 
       context 'with non-existing points only' do
         it 'returns array filled with nils' do
-          results = @redises.geohash(key, 'FF', 'FA')
+          results = @redises.geohash(key, %w[FF FA])
           expect(results).to be == [nil, nil]
         end
       end
@@ -34,7 +34,7 @@ describe '#geohash' do
         end
 
         it 'returns mixture of nil and coordinates pair' do
-          results = @redises.geohash(key, 'SF', 'FA')
+          results = @redises.geohash(key, %w[SF FA])
           expect(results).to be == expected_result
         end
       end
@@ -45,7 +45,7 @@ describe '#geohash' do
     before { @redises.del(key) }
 
     it 'returns empty array' do
-      results = @redises.geohash(key, 'SF', 'LA')
+      results = @redises.geohash(key, %w[SF LA])
       expect(results).to be == [nil, nil]
     end
   end

data/spec/commands/geopos_spec.rb

@@ -20,13 +20,13 @@ describe '#geopos' do
       end
 
       it 'returns decoded coordinates pairs for each point' do
-        coords = @redises.geopos(key, 'SF', 'LA')
+        coords = @redises.geopos(key, %w[SF LA])
         expect(coords).to be == expected_result
       end
 
       context 'with non-existing points only' do
         it 'returns array filled with nils' do
-          coords = @redises.geopos(key, 'FF', 'FA')
+          coords = @redises.geopos(key, %w[FF FA])
           expect(coords).to be == [nil, nil]
         end
       end
@@ -37,7 +37,7 @@ describe '#geopos' do
         end
 
         it 'returns mixture of nil and coordinates pair' do
-          coords = @redises.geopos(key, 'SF', 'FA')
+          coords = @redises.geopos(key, %w[SF FA])
           expect(coords).to be == expected_result
         end
       end
@@ -48,7 +48,7 @@ describe '#geopos' do
     before { @redises.del(key) }
 
     it 'returns empty array' do
-      coords = @redises.geopos(key, 'SF', 'LA')
+      coords = @redises.geopos(key, %w[SF LA])
       expect(coords).to be == [nil, nil]
     end
   end

data/spec/commands/get_spec.rb

@@ -24,6 +24,7 @@ describe '#get(key)' do
 
     @redises.set(key, 'hello')
     @redises.get(key.to_s).should == 'hello'
+    @redises.get(key).should == 'hello'
   end
 
   it_should_behave_like 'a string-only command'

data/spec/commands/hdel_spec.rb

@@ -39,16 +39,32 @@ describe '#hdel(key, field)' do
   end
 
   it 'supports a variable number of arguments' do
-    @redises.hdel(@key, %w[k1 k2])
+    @redises.hdel(@key, 'k1', 'k2')
     @redises.get(@key).should be_nil
   end
 
   it 'treats variable arguments as strings' do
     field = 2
     @redises.hset(@key, field, 'two')
-    @redises.hdel(@key, [field])
+    @redises.hdel(@key, field)
     @redises.hget(@key, field).should be_nil
   end
 
+  it 'supports a variable number of fields as array' do
+    @redises.hdel(@key, %w[k1 k2]).should == 2
+
+    @redises.hget(@key, 'k1').should be_nil
+    @redises.hget(@key, 'k2').should be_nil
+    @redises.get(@key).should be_nil
+  end
+
+  it 'supports a list of fields in various way' do
+    @redises.hdel(@key, ['k1'], 'k2').should == 2
+
+    @redises.hget(@key, 'k1').should be_nil
+    @redises.hget(@key, 'k2').should be_nil
+    @redises.get(@key).should be_nil
+  end
+
   it_should_behave_like 'a hash-only command'
 end

data/spec/commands/hmset_spec.rb

@@ -39,5 +39,31 @@ describe '#hmset(key, field, value [, field, value ...])' do
     end.should raise_error(Redis::CommandError)
   end
 
+  # 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/hset_spec.rb

@@ -5,18 +5,18 @@ describe '#hset(key, field)' do
     @key = 'mock-redis-test:hset'
   end
 
-  it 'returns true if the key does not exist' 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 'returns true if the key exists but the field does not' 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 == true
+    @redises.hset(@key, 'k2', 'v2').should == 1
   end
 
-  it 'returns false if the field already exists' do
+  it 'returns 0 if the field already exists' do
     @redises.hset(@key, 'k1', 'v1')
-    @redises.hset(@key, 'k1', 'v1').should == false
+    @redises.hset(@key, 'k1', 'v1').should == 0
   end
 
   it 'creates a hash there is no such field' do

data/spec/commands/keys_spec.rb

@@ -29,6 +29,7 @@ describe '#keys()' do
 
       @redises.set('mock-redis-test:special-key?', 'true')
       @redises.set('mock-redis-test:special-key*', 'true')
+      @redises.set('mock-redis-test:special-key-!?*', 'true')
     end
 
     describe 'the ? character' do
@@ -53,6 +54,22 @@ describe '#keys()' do
           'mock-redis-test:special-key?',
         ]
       end
+
+      context 'multiple ? characters' do
+        it "properly handles multiple consequtive '?' characters" do
+          @redises.keys('mock-redis-test:special-key-???').sort.should == [
+            'mock-redis-test:special-key-!?*',
+          ]
+        end
+
+        context '\\? as a literal ' do
+          it 'handles multiple ? as both literal and special character' do
+            @redises.keys('mock-redis-test:special-key-?\??').sort.should == [
+              'mock-redis-test:special-key-!?*',
+            ]
+          end
+        end
+      end
     end
 
     describe 'the * character' do

data/spec/commands/mget_spec.rb

@@ -9,26 +9,45 @@ describe '#mget(key [, key, ...])' do
     @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 nil for missing keys' do
-    @redises.mget(@key1, 'mock-redis-test:not-found', @key2).
-      should == ['1', nil, '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'
+    it 'returns nil for non-string keys' do
+      list = 'mock-redis-test:mget-list'
 
-    @redises.lpush(list, 'bork bork bork')
+      @redises.lpush(list, 'bork bork bork')
 
-    @redises.mget(@key1, @key2, list).should == ['1', '2', nil]
+      @redises.mget([@key1, @key2, list]).should == ['1', '2', nil]
+    end
   end
 
-  it 'raises an error if you pass it 0 arguments' do
-    lambda do
-      @redises.mget
-    end.should raise_error(Redis::CommandError)
+  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
+
+    it 'raises an error if you pass it 0 arguments' do
+      lambda do
+        @redises.mget
+      end.should raise_error(Redis::CommandError)
+    end
   end
 end