redis-objects 1.4.3 → 1.6.0

data/lib/redis/value.rb

@@ -6,11 +6,6 @@ class Redis
   # Class representing a simple value.  You can use standard Ruby operations on it.
   #
   class Value < BaseObject
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
     def value=(val)
       allow_expiration do
         if val.nil?

data/redis-objects.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Only fix this one version or else tests break
-  spec.add_dependency "redis", "~> 4.0"
+  spec.add_dependency "redis", "< 4.6"
 
   # Ignore gemspec warnings on these.  Trying to fix them to versions breaks TravisCI
   spec.add_development_dependency "bundler"
@@ -29,6 +29,10 @@ Gem::Specification.new do |spec|
 
   # Compatibility testing
   spec.add_development_dependency "redis-namespace"
+  spec.add_development_dependency "activesupport"
   spec.add_development_dependency "activerecord"
   spec.add_development_dependency "sqlite3"
+
+  # Code coverage
+  spec.add_development_dependency "simplecov-cobertura"
 end

data/spec/redis_autoload_objects_spec.rb

@@ -4,7 +4,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 # tests whether autoload functionality works correctly; had issues previously
 
 require 'redis/objects'
-# $redis used automatically
+Redis::Objects.redis = REDIS_HANDLE
 
 describe 'Redis::Objects' do
   it "should autoload everything" do

data/spec/redis_objects_conn_spec.rb

@@ -5,6 +5,7 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
 require 'connection_pool'
+Redis::Objects.redis = REDIS_HANDLE
 
 BAD_REDIS = "totally bad bogus redis handle"
 
@@ -95,13 +96,13 @@ describe 'Connection tests' do
   end
 
   it "should support local handles with a vanilla redis connection" do
-    Redis.current = nil  # reset from other tests
+    # Redis.current = nil  # reset from other tests
     Redis::Objects.redis = nil
     @redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
 
     # Redis.current is lazily auto-populated to touch 6379
     # This why we choose the weird 9212 port to avoid
-    Redis.current.inspect.should == Redis.new.inspect
+    # Redis.current.inspect.should == Redis.new.inspect
     Redis::Objects.redis.inspect.should == Redis.new.inspect
 
     v = Redis::Value.new('conn/value', @redis_handle)
@@ -140,13 +141,13 @@ describe 'Connection tests' do
   end
 
   it "should support local handles with a connection_pool" do
-    Redis.current = nil  # reset from other tests
+    # Redis.current = nil  # reset from other tests
     Redis::Objects.redis = nil
     @redis_handle = ConnectionPool.new { Redis.new(:host => REDIS_HOST, :port => REDIS_PORT) }
 
     # Redis.current is lazily auto-populated to touch 6379
     # This why we choose the weird 9212 port to avoid
-    Redis.current.inspect.should == Redis.new.inspect
+    # Redis.current.inspect.should == Redis.new.inspect
     Redis::Objects.redis.inspect.should == Redis.new.inspect
 
     v = Redis::Value.new('conn/value', @redis_handle)
@@ -184,24 +185,19 @@ describe 'Connection tests' do
     c.decr(1)
   end
 
-  it "should support Redis.current" do
-    Redis.current = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
-
-    Redis::Value.new('conn/value').should == 'yay'
-    Redis::HashKey.new('conn/hash').keys.should == ['k']
-    Redis::List.new('conn/list').sort.should  == ['3', '4', '5']
-    Redis::Set.new('conn/set').sort.should    == ['5', '6', '7']
-    Redis::SortedSet.new('conn/zset').should  == ['d', 'b', 'a', 'c']
-    Redis::Counter.new('conn/counter').should == 2
+  it "should properly support fallback handle variables" do
+    # Redis.current is lazily auto-populated to touch 6379
+    # This why we choose the weird 9212 port to avoid
+    old_redis = $redis
+    $redis = BAD_REDIS
+    Redis::Objects.redis.should == BAD_REDIS
+    $redis = old_redis
   end
 
   it "should support Redis::Objects.redis= with a connection_pool" do
+    # reset redis
     @redis_handle = ConnectionPool.new { Redis.new(:host => REDIS_HOST, :port => REDIS_PORT) }
-
-    # Redis.current is lazily auto-populated to touch 6379
-    # This why we choose the weird 9212 port to avoid
-    Redis.current = BAD_REDIS
-    Redis::Objects.redis.should == BAD_REDIS
+    Redis::Objects.redis = @redis_handle
 
     # This set of tests sucks, it fucks up the per-data-type handles
     # because Redis.current is then set to a BS value, and the lazy
@@ -229,13 +225,8 @@ describe 'Connection tests' do
 
   it "should support Redis::Objects.redis= with a vanilla redis connection" do
     # reset redis
-    Redis::Objects.redis = nil
     @redis_handle = Redis.new(:host => REDIS_HOST, :port => REDIS_PORT)
-
-    # Redis.current is lazily auto-populated to touch 6379
-    # This why we choose the weird 9212 port to avoid
-    Redis.current = BAD_REDIS
-    Redis::Objects.redis.should == BAD_REDIS
+    Redis::Objects.redis = @redis_handle
 
     # This set of tests sucks, it fucks up the per-data-type handles
     # because Redis.current is then set to a BS value, and the lazy
@@ -260,7 +251,7 @@ describe 'Connection tests' do
     Redis::Counter.new('conn/counter').should == 2
 
     # Fix for future tests
-    Redis.current = @redis_handle
+    # Redis.current = @redis_handle
   end
 
   it "should support pipelined changes" do

data/spec/redis_objects_custom_serializer.rb

@@ -0,0 +1,199 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+Redis::Objects.redis = REDIS_HANDLE
+
+class CustomSerializer
+  class << self
+    attr_accessor :dump_called, :load_called, :dump_args, :load_args
+  end
+
+  def self.dump(value, *args, **kargs)
+    @dump_called = true
+    @dump_args = [args, kargs]
+    Marshal.dump(value)
+  end
+
+  def self.load(value, *args, **kargs)
+    @load_called = true
+    @load_args = [args, kargs]
+    Marshal.load(value)
+  end
+
+  def self.reset!
+    @dump_called = nil
+    @load_called = nil
+  end
+end
+
+describe 'with custom serialization' do
+  before do
+    CustomSerializer.reset!
+  end
+
+  describe Redis::Value do
+    before do
+      @value = Redis::Value.new(
+        'spec/value_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @value.clear
+    end
+
+    it 'uses custom serializer' do
+      @value.value = { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @value.value.should == { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @value.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @value.value = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @value.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @value.value = 1
+      @value.value.should == 1
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::List do
+    before do
+      @list = Redis::List.new(
+        'spec/list_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @list.clear
+    end
+
+    it 'uses custom serializer' do
+      @list << { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @list.should == [{ json: 'data' }]
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @list.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @list << 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @list.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @list << 1
+      @list.values.should == [1]
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::HashKey do
+    before do
+      @hash = Redis::HashKey.new(
+        'spec/hash_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @hash.clear
+    end
+
+    it 'uses custom serializer' do
+      @hash['a'] = 1
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @hash.value.should == { 'a' => 1 }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @hash.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @hash['a'] = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @hash.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @hash['a'] = 1
+      @hash.value.should == { 'a' => 1 }
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::Set do
+    before do
+      @set = Redis::Set.new(
+        'spec/set_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @set.clear
+    end
+
+    it 'uses custom serializer' do
+      @set << 'a'
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @set.members.should == ['a']
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @set.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @set << 'a'
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @set.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @set << 'a'
+      @set.members.should == ['a']
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::SortedSet do
+    before do
+      @set = Redis::SortedSet.new(
+        'spec/zset_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @set.clear
+    end
+
+    it 'uses custom serializer' do
+      @set['a'] = 1
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @set.members.should == ['a']
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @set.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @set['a'] = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @set.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @set['a'] = 1
+      @set.members.should == ['a']
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+end

data/spec/redis_objects_instance_spec.rb

@@ -2,6 +2,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
+Redis::Objects.redis = REDIS_HANDLE
 
 describe Redis::Value do
   before do
@@ -19,6 +20,21 @@ describe Redis::Value do
     @value.value.should == false
   end
 
+  it "should handle simple values" do
+    @value.should == nil
+    @value.value = 'Trevor Hoffman'
+    @value.should == 'Trevor Hoffman'
+    @value.get.should == 'Trevor Hoffman'
+    @value.exists?.should == true
+    @value.exists.should == 1
+    @value.del.should == 1
+    @value.should.be.nil
+    @value.exists?.should == false
+    @value.exists.should == 0
+    @value.value = 42
+    @value.value.should == '42'
+  end
+
   it "should compress non marshaled values" do
     @value = Redis::Value.new('spec/value', compress: true)
     @value.value = 'Trevor Hoffman'
@@ -39,17 +55,8 @@ describe Redis::Value do
     @value.value.should == nil
     @value.value = ''
     @value.value.should == ''
-  end
-
-  it "should handle simple values" do
-    @value.should == nil
-    @value.value = 'Trevor Hoffman'
-    @value.should == 'Trevor Hoffman'
-    @value.get.should == 'Trevor Hoffman'
-    @value.del.should == 1
-    @value.should.be.nil
-    @value.value = 42
-    @value.value.should == '42'
+    @value.delete
+    @value.value.should.be.nil
   end
 
   it "should handle complex marshaled values" do
@@ -88,7 +95,7 @@ describe Redis::Value do
     marshalled_string = Marshal.dump({json: 'marshal'})
     @value = Redis::Value.new('spec/marshal', :default => marshalled_string, :marshal => true)
     @value.value.should == marshalled_string
-    @value.clear
+    @value.delete
   end
 
   it "should support renaming values" do
@@ -499,23 +506,56 @@ describe Redis::Counter do
     @counter.incrbyfloat 2.0e2
     @counter.to_f.should == 5214.31
     @counter.clear
+    @counter.should.be.nil
   end
 
   it "should support an atomic block" do
     @counter = Redis::Counter.new("spec/block_counter")
     @counter.should == 0
     @counter.increment(1)
-    # The block is never executed.
-    @updated =
-      @counter.increment(1) do |updated|
-        if updated == 2
-          'yep'
-        else
-          raise("test failed")
-        end
-      end
+
+    # successfully increments
+    @updated = @counter.increment(1) { |updated| updated == 2 ? 'yep' : nil }
+    @updated.should == 'yep'
+    @counter.should == 2
+
+    # fails to increment
+    @updated = @counter.increment(1) { |updated| updated == 2 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 2
+
+    # successfully increments by float
+    @updated = @counter.incrbyfloat(1.5) { |updated| updated == 3.5 ? 'yep' : nil }
+    @updated.should == 'yep'
+    @counter.should == 3.5
+
+    # fails to increment by float
+    @updated = @counter.incrbyfloat(2.5) { |updated| updated == 5 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 3.5
+
+    # fails to decrement by float
+    @updated = @counter.decrbyfloat(0.5) { |updated| updated == 5 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 3.5
+
+    # successfully decrements by float
+    @updated = @counter.decrbyfloat(0.5) { |updated| updated == 3 ? 'yep' : nil }
+    @updated.should == 'yep'
+    @counter.should == 3
+
+    # fails to decrement
+    @updated = @counter.decrement(1) { |updated| updated == 3 ? 'yep' : nil }
+    @updated.should == nil
+    @counter.should == 3
+
+    # successfully decrements
+    @updated = @counter.decrement(1) { |updated| updated == 2 ? 'yep' : nil }
     @updated.should == 'yep'
     @counter.should == 2
+
+    @counter.value = nil
+    @counter.should == 0
   end
 
   it "should support #to_json" do
@@ -615,7 +655,7 @@ describe Redis::Lock do
     REDIS_HANDLE.get("test_lock").should.be.nil
   end
 
-  it "should not let non-expired locks be gettable" do
+  it "should not let blocks execute if they timeout" do
     expiry = 15
     lock = Redis::Lock.new(:test_lock, :expiration => expiry, :timeout => 0.1)
 
@@ -640,19 +680,68 @@ describe Redis::Lock do
     REDIS_HANDLE.get("test_lock").should.not.be.nil
   end
 
+  it "should handle a timeout of 0" do
+    expiry = 15
+    lock = Redis::Lock.new(:test_lock, :timeout => 0)
+
+    # create a fake lock
+    REDIS_HANDLE.set("test_lock", (Time.now + expiry).to_f)
+
+    gotit = false
+    error = nil
+    begin
+      lock.lock do
+        gotit = true
+      end
+    rescue => error
+    end
+
+    error.should.be.kind_of(Redis::Lock::LockTimeout)
+
+    # should not have the lock
+    gotit.should.not.be.true
+
+    # lock value should still be set
+    REDIS_HANDLE.get("test_lock").should.not.be.nil
+  end
+
+  it "should properly keep the lock across threads" do
+    lock = Redis::Lock.new(:test_lock0)
+
+    t1 = Thread.new do
+      lock.lock do
+        lock.exists?.should.be.true if RUNNING_LOCALLY
+        REDIS_HANDLE.exists?("test_lock0").should.be.true if RUNNING_LOCALLY
+        sleep 1.0  # hang onto the lock across other thread
+      end
+    end
+
+    t2 = Thread.new do
+      # check for the lock from another thread
+      lock.exists?.should.be.true if RUNNING_LOCALLY
+      REDIS_HANDLE.exists?("test_lock0").should.be.true if RUNNING_LOCALLY
+    end
+
+    t1.join
+    t2.join
+
+    # lock value should not be set since the lock was held for more than the expiry
+    lock.exists?.should.be.false
+    REDIS_HANDLE.exists?("test_lock0").should.be.false
+  end
+
   it "Redis should remove the key if lock is held past expiration" do
-    lock = Redis::Lock.new(:test_lock, :expiration => 0.1)
+    lock = Redis::Lock.new(:test_lock1, :expiration => 0.1)
 
     lock.lock do
-      REDIS_HANDLE.exists("test_lock").should.be.true
-      sleep 0.3
-      # technically undefined behavior because we don't have a BG thread
-      # running and deleting lock keys - that is only triggered on block exit
-      #REDIS_HANDLE.exists("test_lock").should.be.false
+      lock.exists?.should.be.true
+      REDIS_HANDLE.exists?("test_lock1").should.be.true
+      sleep 1.0  # hang onto the lock > expiry
     end
 
     # lock value should not be set since the lock was held for more than the expiry
-    REDIS_HANDLE.exists("test_lock").should.be.false
+    lock.exists?.should.be.false
+    REDIS_HANDLE.exists?("test_lock1").should.be.false
   end
 
 
@@ -660,9 +749,9 @@ describe Redis::Lock do
     lock = Redis::Lock.new(:test_lock2, :expiration => 0.1)
 
     lock.lock do
-      REDIS_HANDLE.exists("test_lock2").should.be.true
-      sleep 0.3 # expired, key is deleted
-      REDIS_HANDLE.exists("test_lock2").should.be.false
+      REDIS_HANDLE.exists?("test_lock2").should.be.true
+      sleep 1.0 # expired, key is deleted
+      REDIS_HANDLE.exists?("test_lock2").should.be.false
       REDIS_HANDLE.set("test_lock2", "foo") # this is no longer a lock key, name is a coincidence
     end
 
@@ -670,17 +759,17 @@ describe Redis::Lock do
   end
 
   it "should manually delete the key if finished before expiration" do
-    lock = Redis::Lock.new(:test_lock3, :expiration => 0.5)
+    lock = Redis::Lock.new(:test_lock3, :expiration => 10.0)
 
     lock.lock do
-      REDIS_HANDLE.exists("test_lock3").should.be.true
+      REDIS_HANDLE.exists?("test_lock3").should.be.true
       sleep 0.1
-      REDIS_HANDLE.exists("test_lock3").should.be.true
+      REDIS_HANDLE.exists?("test_lock3").should.be.true
     end
 
-    # should delete the key because the lock block is done, regardless of time
+    # should delete the key because the lock block is done, regardless of expiry
     # for some strange reason, I have seen this test fail randomly, which is worrisome.
-    #REDIS_HANDLE.exists("test_lock3").should.be.false
+    REDIS_HANDLE.exists?("test_lock3").should.be.false
   end
 
 
@@ -900,6 +989,13 @@ describe Redis::HashKey do
     hsh['foo'].should == 'bar'
   end
 
+  it "should return multiple items via bulk_values" do
+    @hash['taco'] = 42
+    @hash['burrito'] = 99
+    res = @hash.bulk_values('taco', 'burrito')
+    res.should == ['42', '99']  # hashes don't convert
+  end
+
   it "should increment field" do
     @hash.incr('counter')
     @hash.incr('counter')
@@ -1007,7 +1103,9 @@ describe Redis::Set do
 
   it "should handle sets of simple values" do
     @set.should.be.empty
-    @set << 'a' << 'a' << 'a'
+    @set << 'a'
+    @set.randmember.should == 'a'
+    @set << 'a' << 'a'
     @set.should == ['a']
     @set.to_s.should == 'a'
     @set.get.should == ['a']
@@ -1048,11 +1146,13 @@ describe Redis::Set do
     coll = @set.select{|st| st == 'c'}
     coll.should == ['c']
     @set.sort.should == ['a','b','c']
+    @set.randmember.should.not == 'd'
     @set.delete_if{|m| m == 'c'}
     @set.sort.should == ['a','b']
 
     @set << nil
     @set.include?("").should.be.true
+    @set.sort.should == ['','a','b']
   end
 
   it "should handle empty array adds" do
@@ -1168,6 +1268,12 @@ describe Redis::Set do
     @set_1.value.should == ['a']
   end
 
+  it "should support moving between sets" do
+    @set_1 << 'X' << 'Y' << 'Z'
+    @set_1.move('X', @set_2)
+    @set_2.should == ['X']
+  end
+
   it "should respond to #to_json" do
     @set_1 << 'a'
     JSON.parse(@set_1.to_json)['value'].should == ['a']
@@ -1267,6 +1373,9 @@ describe Redis::SortedSet do
     @set.to_s.should == 'a, b'
     @set.should == ['a','b']
     @set.members.should == ['a','b']
+    @set.member?('a').should == true
+    @set.member?('b').should == true
+    @set.member?('c').should == false
     @set['d'] = 0
 
     @set.rangebyscore(0, 4).should == ['d','a']
@@ -1316,6 +1425,10 @@ describe Redis::SortedSet do
 
     @set.delete_if{|m| m == 'b'}
     @set.size.should == 3
+
+    # this is destructive so must come last
+    res = @set.remrangebyrank(0, 2)
+    res.should == 3
   end
 
   it "should handle inserting multiple values at once" do