mock_redis 0.5.4 → 0.31.0

data/lib/mock_redis.rb

@@ -1,8 +1,10 @@
 require 'set'
+require 'ruby2_keywords'
 
 require 'mock_redis/assertions'
 require 'mock_redis/database'
 require 'mock_redis/expire_wrapper'
+require 'mock_redis/future'
 require 'mock_redis/multi_db_wrapper'
 require 'mock_redis/pipelined_wrapper'
 require 'mock_redis/transaction_wrapper'
@@ -14,14 +16,16 @@ class MockRedis
   attr_reader :options
 
   DEFAULTS = {
-     :scheme => "redis",
-     :host => "127.0.0.1",
-     :port => 6379,
-     :path => nil,
-     :timeout => 5.0,
-     :password => nil,
-     :db => 0,
-  }
+    :scheme => 'redis',
+    :host => '127.0.0.1',
+    :port => 6379,
+    :path => nil,
+    :timeout => 5.0,
+    :password => nil,
+    :logger => nil,
+    :db => 0,
+    :time_class => Time,
+  }.freeze
 
   def self.connect(*args)
     new(*args)
@@ -34,40 +38,62 @@ class MockRedis
       TransactionWrapper.new(
         ExpireWrapper.new(
           MultiDbWrapper.new(
-              Database.new(*args)))))
+            Database.new(self, *args)
+          )
+        )
+      )
+    )
   end
 
   def id
-    "redis://#{self.host}:#{self.port}/#{self.db}"
+    "redis://#{host}:#{port}/#{db}"
   end
-  alias :location :id
+  alias location id
 
-  def call(command, &block)
-     self.send(*command)
+  def call(command, &_block)
+    send(*command)
   end
 
   def host
-    self.options[:host]
+    options[:host]
   end
 
   def port
-    self.options[:port]
+    options[:port]
   end
 
   def db
-    self.options[:db]
+    options[:db]
+  end
+
+  def logger
+    options[:logger]
+  end
+
+  def time_at(timestamp)
+    options[:time_class].at(timestamp)
   end
 
   def client
     self
   end
 
-  def respond_to?(method, include_private=false)
+  def connect
+    self
+  end
+
+  def reconnect
+    self
+  end
+
+  def respond_to?(method, include_private = false)
     super || @db.respond_to?(method, include_private)
   end
 
-  def method_missing(method, *args, &block)
-    @db.send(method, *args, &block)
+  ruby2_keywords def method_missing(method, *args, &block)
+    logging([[method, *args]]) do
+      @db.send(method, *args, &block)
+    end
   end
 
   def initialize_copy(source)
@@ -75,27 +101,26 @@ class MockRedis
     @db = @db.clone
   end
 
-
   protected
 
   def _parse_options(options)
-    return {} if options.nil?
+    return DEFAULTS.dup if options.nil?
 
     defaults = DEFAULTS.dup
 
-    url = options[:url] || ENV["REDIS_URL"]
+    url = options[:url] || ENV['REDIS_URL']
 
     # Override defaults from URL if given
     if url
-      require "uri"
+      require 'uri'
 
       uri = URI(url)
 
-      if uri.scheme == "unix"
-        defaults[:path]   = uri.path
+      if uri.scheme == 'unix'
+        defaults[:path] = uri.path
       else
         # Require the URL to have at least a host
-        raise ArgumentError, "invalid url" unless uri.host
+        raise ArgumentError, 'invalid url' unless uri.host
 
         defaults[:scheme]   = uri.scheme
         defaults[:host]     = uri.host
@@ -108,7 +133,7 @@ class MockRedis
     options = defaults.merge(options)
 
     if options[:path]
-      options[:scheme] = "unix"
+      options[:scheme] = 'unix'
       options.delete(:host)
       options.delete(:port)
     else
@@ -122,4 +147,29 @@ class MockRedis
     options
   end
 
+  def logging(commands)
+    return yield unless logger&.debug?
+
+    begin
+      commands.each do |name, *args|
+        logged_args = args.map do |a|
+          if a.respond_to?(:inspect) then a.inspect
+          elsif a.respond_to?(:to_s) then a.to_s
+          else
+            # handle poorly-behaved descendants of BasicObject
+            klass = a.instance_exec { (class << self; self end).superclass }
+            "\#<#{klass}:#{a.__id__}>"
+          end
+        end
+        logger.debug("[MockRedis] command=#{name.to_s.upcase} args=#{logged_args.join(' ')}")
+      end
+
+      t1 = Time.now
+      yield
+    ensure
+      if t1
+        logger.debug(format('[MockRedis] call_time=%<time>0.2f ms', time: ((Time.now - t1) * 1000)))
+      end
+    end
+  end
 end

data/mock_redis.gemspec

@@ -1,24 +1,32 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "mock_redis/version"
+$LOAD_PATH << File.expand_path('lib', __dir__)
+require 'mock_redis/version'
 
 Gem::Specification.new do |s|
-  s.name        = "mock_redis"
+  s.name        = 'mock_redis'
   s.version     = MockRedis::VERSION
+  s.license     = 'MIT'
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Causes Engineering', 'Samuel Merritt']
-  s.email       = ['eng@causes.com']
-  s.homepage    = "https://github.com/causes/mock_redis"
-  s.summary     = %q{Redis mock that just lives in memory; useful for testing.}
+  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 = %q{Instantiate one with `redis = MockRedis.new` and treat it like you would a normal Redis object. It supports all the usual Redis operations.}
+  s.description = <<-MSG.strip.gsub(/\s+/, ' ')
+   Instantiate one with `redis = MockRedis.new` and treat it like you would a
+   normal Redis object. It supports all the usual Redis operations.
+  MSG
 
   s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
-  s.add_development_dependency "rake", "~> 0.9.2"
-  s.add_development_dependency "redis", "~> 3.0.0"
-  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.required_ruby_version = '>= 2.4'
+
+  s.add_runtime_dependency 'ruby2_keywords'
+
+  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

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe 'client' do
+  context '#reconnect' do
+    it 'reconnects' do
+      redis = MockRedis.new
+      redis.reconnect.should == redis
+    end
+  end
+
+  context '#connect' do
+    it 'connects' do
+      redis = MockRedis.new
+      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/cloning_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe "MockRedis#clone" do
+describe 'MockRedis#clone' do
   before do
     @mock = MockRedis.new
   end
 
-  context "the stored data" do
+  context 'the stored data' do
     before do
       @mock.set('foo', 'bar')
       @mock.hset('foohash', 'bar', 'baz')
@@ -16,60 +16,60 @@ describe "MockRedis#clone" do
       @clone = @mock.clone
     end
 
-    it "copies the stored data to the clone" do
+    it 'copies the stored data to the clone' do
       @clone.get('foo').should == 'bar'
     end
 
-    it "performs a deep copy (string values)" do
+    it 'performs a deep copy (string values)' do
       @mock.del('foo')
       @clone.get('foo').should == 'bar'
     end
 
-    it "performs a deep copy (list values)" do
+    it 'performs a deep copy (list values)' do
       @mock.lpop('foolist')
       @clone.lrange('foolist', 0, 1).should == ['bar']
     end
 
-    it "performs a deep copy (hash values)" do
+    it 'performs a deep copy (hash values)' do
       @mock.hset('foohash', 'bar', 'quux')
-      @clone.hgetall('foohash').should == {'bar' => 'baz'}
+      @clone.hgetall('foohash').should == { 'bar' => 'baz' }
     end
 
-    it "performs a deep copy (set values)" do
+    it 'performs a deep copy (set values)' do
       @mock.srem('fooset', 'bar')
       @clone.smembers('fooset').should == ['bar']
     end
 
-    it "performs a deep copy (zset values)" do
+    it 'performs a deep copy (zset values)' do
       @mock.zadd('foozset', 2, 'bar')
       @clone.zscore('foozset', 'bar').should == 1.0
     end
   end
 
-  context "expiration times" do
+  context 'expiration times' do
     before do
       @mock.set('foo', 1)
-      @mock.expire('foo', 60026)
+      @mock.expire('foo', 60_026)
 
       @clone = @mock.clone
     end
 
-    it "copies the expiration times" do
+    it 'copies the expiration times' do
       @clone.ttl('foo').should > 0
     end
 
-    it "deep-copies the expiration times" do
+    it 'deep-copies the expiration times' do
       @mock.persist('foo')
       @clone.ttl('foo').should > 0
     end
 
-    it "deep-copies the expiration times" do
+    it 'deep-copies the expiration times' do
       @clone.persist('foo')
       @mock.ttl('foo').should > 0
     end
   end
 
-  context "transactional info" do
+  context 'transactional info' do
     before do
       @mock.multi
       @mock.incr('foo')
@@ -79,18 +79,17 @@ describe "MockRedis#clone" do
       @clone = @mock.clone
     end
 
-    it "makes sure the clone is in a transaction" do
+    it 'makes sure the clone is in a transaction' do
       lambda do
         @clone.exec
       end.should_not raise_error
     end
 
-    it "deep-copies the queued commands" do
+    it 'deep-copies the queued commands' do
       @clone.incrby('foo', 8)
       @clone.exec.should == [1, 3, 7, 15]
 
       @mock.exec.should == [1, 3, 7]
     end
   end
-
 end

data/spec/commands/append_spec.rb

@@ -3,22 +3,22 @@ require 'spec_helper'
 describe '#append(key, value)' do
   before { @key = 'mock-redis-test:append' }
 
-  it "returns the new length of the string" do
+  it 'returns the new length of the string' do
     @redises.set(@key, 'porkchop')
     @redises.append(@key, 'sandwiches').should == 18
   end
 
-  it "appends value to the previously-stored value" do
+  it 'appends value to the previously-stored value' do
     @redises.set(@key, 'porkchop')
     @redises.append(@key, 'sandwiches')
 
     @redises.get(@key).should == 'porkchopsandwiches'
   end
 
-  it "treats a missing key as an empty string" do
+  it 'treats a missing key as an empty string' do
     @redises.append(@key, 'foo')
     @redises.get(@key).should == 'foo'
   end
 
-  it_should_behave_like "a string-only command"
+  it_should_behave_like 'a string-only command'
 end

data/spec/commands/auth_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "#auth(password) [mock only]" do
+describe '#auth(password) [mock only]' do
   it "just returns 'OK'" do
     @redises.mock.auth('foo').should == 'OK'
   end

data/spec/commands/bgrewriteaof_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe "#bgrewriteaof [mock only]" do
-  it "just returns a canned string" do
+describe '#bgrewriteaof [mock only]' do
+  it 'just returns a canned string' do
     @redises.mock.bgrewriteaof.should =~ /append/
   end
 end

data/spec/commands/bgsave_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe "#bgsave [mock only]" do
-  it "just returns a canned string" do
+describe '#bgsave [mock only]' do
+  it 'just returns a canned string' do
     @redises.mock.bgsave.should =~ /saving/
   end
 end

data/spec/commands/bitcount_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe '#bitcount(key [, start, end ])' do
+  before do
+    @key = 'mock-redis-test:bitcount'
+    @redises.set(@key, 'foobar')
+  end
+
+  it 'gets the number of set bits from the key' do
+    @redises.bitcount(@key).should == 26
+  end
+
+  it 'gets the number of set bits from the key in an interval' do
+    @redises.bitcount(@key, 0, 1000).should == 26
+    @redises.bitcount(@key, 0, 0).should == 4
+    @redises.bitcount(@key, 1, 1).should == 6
+    @redises.bitcount(@key, 1, -2).should == 18
+  end
+
+  it 'treats nonexistent keys as empty strings' do
+    @redises.bitcount('mock-redis-test:not-found').should == 0
+  end
+
+  it_should_behave_like 'a string-only command'
+end

data/spec/commands/bitfield_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe '#bitfield(*args)' do
+  before :each do
+    @key = 'mock-redis-test:bitfield'
+    @redises.set(@key, '')
+
+    @redises.bitfield(@key, :set, 'i8', 0, 78)
+    @redises.bitfield(@key, :set, 'i8', 8, 104)
+    @redises.bitfield(@key, :set, 'i8', 16, -59)
+    @redises.bitfield(@key, :set, 'u8', 24, 78)
+    @redises.bitfield(@key, :set, 'u8', 32, 84)
+  end
+
+  context 'with a :get command' do
+    it 'gets a signed 8 bit value' do
+      @redises.bitfield(@key, :get, 'i8', 0).should == [78]
+      @redises.bitfield(@key, :get, 'i8', 8).should == [104]
+      @redises.bitfield(@key, :get, 'i8', 16).should == [-59]
+    end
+
+    it 'gets multiple values with multiple command args' do
+      @redises.bitfield(@key, :get, 'i8', 0,
+                              :get, 'i8', 8,
+                              :get, 'i8', 16).should == [78, 104, -59]
+    end
+
+    it 'gets multiple values using positional offsets' do
+      @redises.bitfield(@key, :get, 'i8', '#0',
+                              :get, 'i8', '#1',
+                              :get, 'i8', '#2').should == [78, 104, -59]
+    end
+
+    it 'shows an error with an invalid type' do
+      expect do
+        @redises.bitfield(@key, :get, 'u64', 0)
+      end.to raise_error(Redis::CommandError)
+      expect do
+        @redises.bitfield(@key, :get, 'i128', 0)
+      end.to raise_error(Redis::CommandError)
+    end
+
+    it 'does not throw an error with i64 type' do
+      expect do
+        @redises.bitfield(@key, :get, 'i64', 0)
+      end.to_not raise_error
+    end
+  end
+
+  context 'with a :set command' do
+    it 'sets the bit values for an 8 bit signed integer' do
+      @redises.bitfield(@key, :set, 'i8', 0, 63).should == [78]
+      @redises.bitfield(@key, :set, 'i8', 8, -1).should == [104]
+      @redises.bitfield(@key, :set, 'i8', 16, 123).should == [-59]
+
+      @redises.bitfield(@key, :get, 'i8', 0,
+                              :get, 'i8', 8,
+                              :get, 'i8', 16).should == [63, -1, 123]
+    end
+
+    it 'sets multiple values with multiple command args' do
+      @redises.bitfield(@key, :set, 'i8', 0, 63,
+                              :set, 'i8', 8, -1,
+                              :set, 'i8', 16, 123).should == [78, 104, -59]
+
+      @redises.bitfield(@key, :get, 'i8', 0,
+                              :get, 'i8', 8,
+                              :get, 'i8', 16).should == [63, -1, 123]
+    end
+  end
+
+  context 'with an :incrby command' do
+    it 'returns the incremented by value for an 8 bit signed integer' do
+      @redises.bitfield(@key, :incrby, 'i8', 0, 1).should == [79]
+      @redises.bitfield(@key, :incrby, 'i8', 8, -1).should == [103]
+      @redises.bitfield(@key, :incrby, 'i8', 16, 5).should == [-54]
+    end
+
+    context 'with an overflow of wrap (default)' do
+      context 'for a signed integer' do
+        it 'wraps the overflow to the minimum and increments from there' do
+          @redises.bitfield(@key, :get, 'i8', 24).should == [78]
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'i8', 0, 200).should == [22]
+        end
+
+        it 'wraps the underflow to the maximum value and decrements from there' do
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'i8', 16, -200).should == [-3]
+        end
+      end
+
+      context 'for an unsigned integer' do
+        it 'wraps the overflow back to zero and increments from there' do
+          @redises.bitfield(@key, :get, 'u8', 24).should == [78]
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'u8', 24, 233).should == [55]
+        end
+
+        it 'wraps the underflow to the maximum value and decrements from there' do
+          @redises.bitfield(@key, :get, 'u8', 32).should == [84]
+          @redises.bitfield(@key, :overflow, :wrap,
+                                  :incrby, 'u8', 32, -233).should == [107]
+        end
+      end
+    end
+
+    context 'with an overflow of sat' do
+      it 'sets the overflowed value to the maximum' do
+        @redises.bitfield(@key, :overflow, :sat,
+                                :incrby, 'i8', 0, 256).should == [127]
+      end
+
+      it 'sets the underflowed value to the minimum' do
+        @redises.bitfield(@key, :overflow, :sat,
+                                :incrby, 'i8', 16, -256).should == [-128]
+      end
+    end
+
+    context 'with an overflow of fail' do
+      it 'raises a redis error on an out of range value' do
+        @redises.bitfield(@key, :overflow, :fail,
+                                :incrby, 'i8', 0, 256).should == [nil]
+
+        @redises.bitfield(@key, :overflow, :fail,
+                                :incrby, 'i8', 16, -256).should == [nil]
+      end
+
+      it 'retains the original value after a failed increment' do
+        @redises.bitfield(@key, :get, 'i8', 0).should == [78]
+        @redises.bitfield(@key, :overflow, :fail,
+                                :incrby, 'i8', 0, 256).should == [nil]
+        @redises.bitfield(@key, :get, 'i8', 0).should == [78]
+      end
+    end
+
+    context 'with multiple overflow commands in one transaction' do
+      it 'handles the overflow values correctly' do
+        @redises.bitfield(@key, :overflow, :sat,
+                                :incrby, 'i8', 0, 256,
+                                :incrby, 'i8', 8, -256,
+                                :overflow, :wrap,
+                                :incrby, 'i8', 0, 200,
+                                :incrby, 'i8', 16, -200,
+                                :overflow, :fail,
+                                :incrby, 'i8', 0, 256,
+                                :incrby, 'i8', 16, -256).should == [127, -128, 71, -3, nil, nil]
+      end
+    end
+
+    context 'with an unsupported overflow value' do
+      it 'raises an error' do
+        expect do
+          @redises.bitfield(@key, :overflow, :foo,
+                                  :incrby, 'i8', 0, 256)
+        end.to raise_error(Redis::CommandError)
+      end
+    end
+  end
+
+  context 'with a mixed set of commands' do
+    it 'returns the correct outputs' do
+      @redises.bitfield(@key, :set, 'i8', 0, 38,
+                              :set, 'i8', 8, -99,
+                              :incrby, 'i8', 16, 1,
+                              :get, 'i8', 0).should == [78, 104, -58, 38]
+    end
+  end
+end