redis-objects 0.6.0 → 0.7.0

data/lib/redis/list.rb

@@ -13,7 +13,7 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
 
     # Works like push.  Can chain together: list << 'a' << 'b'
     def <<(value)
@@ -21,10 +21,10 @@ class Redis
       self  # for << 'a' << 'b'
     end
 	
-		# Add a member before or after pivot in the list. Redis: LINSERT
-		def insert(where,pivot,value)
-			redis.linsert(key,where,to_redis(pivot),to_redis(value))
-		end
+    # Add a member before or after pivot in the list. Redis: LINSERT
+    def insert(where,pivot,value)
+      redis.linsert(key,where,to_redis(pivot),to_redis(value))
+    end
 
     # Add a member to the end of the list. Redis: RPUSH
     def push(value)

data/lib/redis/lock.rb

@@ -11,12 +11,12 @@ class Redis
   class Lock < BaseObject
     class LockTimeout < StandardError; end #:nodoc:
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
       @options[:timeout] ||= 5
       @options[:init] = false if @options[:init].nil? # default :init to false
-      @redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
+      redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 
     # Clear the lock.  Should only be needed if there's a server crash

data/lib/redis/objects/counters.rb

@@ -22,7 +22,7 @@ class Redis
         def counter(name, options={})
           options[:start] ||= 0
           options[:type]  ||= options[:start] == 0 ? :increment : :decrement
-          @redis_objects[name.to_sym] = options.merge(:type => :counter)
+          redis_objects[name.to_sym] = options.merge(:type => :counter)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -60,7 +60,7 @@ class Redis
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.incrby(redis_field_key(name, id), by).to_i
-          block_given? ? rewindable_block(:decrement_counter, name, id, value, &block) : value
+          block_given? ? rewindable_block(:decrement_counter, name, id, by, value, &block) : value
         end
 
         # Decrement a counter with the specified name and id.  Accepts a block
@@ -71,13 +71,13 @@ class Redis
           verify_counter_defined!(name, id)
           initialize_counter!(name, id)
           value = redis.decrby(redis_field_key(name, id), by).to_i
-          block_given? ? rewindable_block(:increment_counter, name, id, value, &block) : value
+          block_given? ? rewindable_block(:increment_counter, name, id, by, value, &block) : value
         end
 
         # Reset a counter to its starting value.
         def reset_counter(name, id=nil, to=nil)
           verify_counter_defined!(name, id)
-          to = @redis_objects[name][:start] if to.nil?
+          to = redis_objects[name][:start] if to.nil?
           redis.set(redis_field_key(name, id), to.to_i)
           true
         end
@@ -85,7 +85,7 @@ class Redis
         # Set a counter to its starting value and return the old value.
         def getset_counter(name, id=nil, to=nil)
           verify_counter_defined!(name, id)
-          to = @redis_objects[name][:start] if to.nil?
+          to = redis_objects[name][:start] if to.nil?
           redis.getset(redis_field_key(name, id), to.to_i).to_i
         end
 
@@ -93,35 +93,35 @@ class Redis
 
         def verify_counter_defined!(name, id) #:nodoc:
           raise NoMethodError, "Undefined counter :#{name} for class #{self.name}" unless counter_defined?(name)
-          if id.nil? and !@redis_objects[name][:global]
+          if id.nil? and !redis_objects[name][:global]
             raise Redis::Objects::MissingID, "Missing ID for non-global counter #{self.name}##{name}"
           end
         end
 
         def counter_defined?(name) #:nodoc:
-          @redis_objects && @redis_objects.has_key?(name)
+          redis_objects && redis_objects.has_key?(name)
         end
 
         def initialize_counter!(name, id) #:nodoc:
           key = redis_field_key(name, id)
           unless @initialized_counters[key]
-            redis.setnx(key, @redis_objects[name][:start])
+            redis.setnx(key, redis_objects[name][:start])
           end
           @initialized_counters[key] = true
         end
 
         # Implements increment/decrement blocks on a class level
-        def rewindable_block(rewind, name, id, value, &block) #:nodoc:
+        def rewindable_block(rewind, name, id, by, value, &block) #:nodoc:
           # Unfortunately this is almost exactly duplicated from Redis::Counter
           raise ArgumentError, "Missing block to rewindable_block somehow" unless block_given?
           ret = nil
           begin
             ret = yield value
           rescue
-            send(rewind, name, id)
+            send(rewind, name, id, by)
             raise
           end
-          send(rewind, name, id) if ret.nil?
+          send(rewind, name, id, by) if ret.nil?
           ret
         end
       end

data/lib/redis/objects/hashes.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new hash key.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def hash_key(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :dict)
+          redis_objects[name.to_sym] = options.merge(:type => :dict)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods

data/lib/redis/objects/lists.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def list(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :list)
+          redis_objects[name.to_sym] = options.merge(:type => :list)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -42,4 +42,4 @@ class Redis
       end
     end
   end
-end
+end

data/lib/redis/objects/locks.rb

@@ -17,7 +17,7 @@ class Redis
         def lock(name, options={})
           options[:timeout] ||= 5  # seconds
           lock_name = "#{name}_lock"
-          @redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
+          redis_objects[lock_name.to_sym] = options.merge(:type => :lock)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -46,7 +46,7 @@ class Redis
           verify_lock_defined!(name)
           raise ArgumentError, "Missing block to #{self.name}.obtain_lock" unless block_given?
           lock_name = "#{name}_lock"
-          Redis::Lock.new(redis_field_key(lock_name, id), redis, @redis_objects[lock_name.to_sym]).lock(&block)
+          Redis::Lock.new(redis_field_key(lock_name, id), redis, redis_objects[lock_name.to_sym]).lock(&block)
         end
 
         # Clear the lock.  Use with care - usually only in an Admin page to clear
@@ -57,9 +57,9 @@ class Redis
         end
 
         private
-        
+
         def verify_lock_defined!(name)
-          unless @redis_objects.has_key?("#{name}_lock".to_sym)
+          unless redis_objects.has_key?("#{name}_lock".to_sym)
             raise Redis::Objects::UndefinedLock, "Undefined lock :#{name} for class #{self.name}"
           end
         end

data/lib/redis/objects/sets.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def set(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :set)
+          redis_objects[name.to_sym] = options.merge(:type => :set)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -34,7 +34,7 @@ class Redis
               end
             EndMethods
           end
-          
+
         end
       end
 
@@ -43,4 +43,4 @@ class Redis
       end
     end
   end
-end
+end

data/lib/redis/objects/sorted_sets.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new list.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def sorted_set(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :sorted_set)
+          redis_objects[name.to_sym] = options.merge(:type => :sorted_set)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -42,4 +42,4 @@ class Redis
       end
     end
   end
-end
+end

data/lib/redis/objects/values.rb

@@ -14,7 +14,7 @@ class Redis
         # Define a new simple value.  It will function like a regular instance
         # method, so it can be used alongside ActiveRecord, DataMapper, etc.
         def value(name, options={})
-          @redis_objects[name.to_sym] = options.merge(:type => :value)
+          redis_objects[name.to_sym] = options.merge(:type => :value)
           klass_name = '::' + self.name
           if options[:global]
             instance_eval <<-EndMethods
@@ -43,13 +43,13 @@ class Redis
               end
             EndMethods
           end
-          
+
         end
       end
-      
+
       # Instance methods that appear in your class when you include Redis::Objects.
       module InstanceMethods
       end
     end
   end
-end
+end

data/lib/redis/objects.rb

@@ -1,7 +1,16 @@
 # Redis::Objects - Lightweight object layer around redis-rb
 # See README.rdoc for usage and approach.
 require 'redis'
+
 class Redis
+  autoload :Counter,   'redis/counter'
+  autoload :List,      'redis/list'
+  autoload :Lock,      'redis/lock'
+  autoload :Set,       'redis/set'
+  autoload :SortedSet, 'redis/sorted_set'
+  autoload :Value,     'redis/value'
+  autoload :HashKey,   'redis/hash_key'
+
   #
   # Redis::Objects enables high-performance atomic operations in your app
   # by leveraging the atomic features of the Redis server.  To use Redis::Objects,
@@ -17,7 +26,7 @@ class Redis
   #     lock :archive_game
   #     set :player_ids
   #   end
-  # 
+  #
   # The, you can use these counters both for bookeeping and as atomic actions:
   #
   #   @game = Game.find(id)
@@ -38,30 +47,33 @@ class Redis
   module Objects
     dir = File.expand_path(__FILE__.sub(/\.rb$/,''))
 
-    autoload :Counters, File.join(dir, 'counters')
-    autoload :Lists, File.join(dir, 'lists')
-    autoload :Locks, File.join(dir, 'locks')
-    autoload :Sets, File.join(dir, 'sets')
-    autoload :SortedSets, File.join(dir, 'sorted_sets')
-    autoload :Values, File.join(dir, 'values')
-    autoload :Hashes, File.join(dir, 'hashes')
+    autoload :Counters,   'redis/objects/counters'
+    autoload :Lists,      'redis/objects/lists'
+    autoload :Locks,      'redis/objects/locks'
+    autoload :Sets,       'redis/objects/sets'
+    autoload :SortedSets, 'redis/objects/sorted_sets'
+    autoload :Values,     'redis/objects/values'
+    autoload :Hashes,     'redis/objects/hashes'
 
     class NotConnected < StandardError; end
     class NilObjectId  < StandardError; end
 
     class << self
-      def redis=(conn) @redis = conn end
+      def redis=(conn)
+        @redis = conn
+      end
       def redis
-        @redis ||= $redis || Redis.current || raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
+        @redis || $redis || Redis.current ||
+          raise(NotConnected, "Redis::Objects.redis not set to a Redis.new connection")
       end
 
       def included(klass)
         # Core (this file)
-        klass.instance_variable_set('@redis', @redis)
+        klass.instance_variable_set('@redis', nil)
         klass.instance_variable_set('@redis_objects', {})
         klass.send :include, InstanceMethods
         klass.extend ClassMethods
-        
+
         # Pull in each object type
         klass.send :include, Redis::Objects::Counters
         klass.send :include, Redis::Objects::Lists
@@ -75,9 +87,17 @@ class Redis
 
     # Class methods that appear in your class when you include Redis::Objects.
     module ClassMethods
-      attr_writer   :redis
-      attr_accessor :redis_objects
-      def redis() @redis ||= Objects.redis end
+      # Enable per-class connections (eg, User and Post can use diff redis-server)
+      attr_writer :redis
+      def redis
+        @redis || Objects.redis
+      end
+
+      # Internal list of objects
+      attr_writer :redis_objects
+      def redis_objects
+        @redis_objects ||= {}
+      end
 
       # Set the Redis redis_prefix to use. Defaults to model_name
       def redis_prefix=(redis_prefix) @redis_prefix = redis_prefix end

data/lib/redis/set.rb

@@ -12,7 +12,7 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
 
     # Works like add.  Can chain together: list << 'a' << 'b'
     def <<(value)

data/lib/redis/sorted_set.rb

@@ -12,7 +12,7 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
 
     # How to add values using a sorted set.  The key is the member, eg,
     # "Peter", and the value is the score, eg, 163.  So:

data/lib/redis/value.rb

@@ -10,10 +10,10 @@ class Redis
     require 'redis/helpers/serialize'
     include Redis::Helpers::Serialize
 
-    attr_reader :key, :options, :redis
+    attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
-      @redis.setnx(key, to_redis(@options[:default])) if @options[:default]
+      redis.setnx(key, to_redis(@options[:default])) if @options[:default]
     end
 
     def value=(val)

data/lib/redis-objects.rb

@@ -0,0 +1 @@
+require 'redis/objects'

data/redis-objects.gemspec

@@ -5,24 +5,24 @@
 
 Gem::Specification.new do |s|
   s.name = "redis-objects"
-  s.version = "0.6.0"
+  s.version = "0.7.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nate Wiger"]
-  s.date = "2012-10-24"
+  s.date = "2013-02-27"
   s.description = "Map Redis types directly to Ruby objects. Works with any class or ORM."
-  s.email = "nate@wiger.org"
+  s.email = "nwiger@gmail.com"
   s.extra_rdoc_files = [
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     "ATOMICITY.rdoc",
     "CHANGELOG.rdoc",
     "Gemfile",
-    "Gemfile.lock",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
+    "lib/redis-objects.rb",
     "lib/redis/base_object.rb",
     "lib/redis/counter.rb",
     "lib/redis/hash_key.rb",
@@ -42,15 +42,16 @@ Gem::Specification.new do |s|
     "lib/redis/sorted_set.rb",
     "lib/redis/value.rb",
     "redis-objects.gemspec",
+    "spec/redis_autoload_objects_spec.rb",
     "spec/redis_namespace_compat_spec.rb",
     "spec/redis_objects_active_record_spec.rb",
+    "spec/redis_objects_conn_spec.rb",
     "spec/redis_objects_instance_spec.rb",
     "spec/redis_objects_model_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/nateware/redis-objects"
   s.require_paths = ["lib"]
-  s.requirements = ["redis, v3.0.2 or greater"]
   s.rubygems_version = "1.8.24"
   s.summary = "Map Redis types directly to Ruby objects"
 
@@ -59,32 +60,17 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<redis>, [">= 3.0.2"])
-      s.add_runtime_dependency(%q<redis-namespace>, [">= 0"])
-      s.add_runtime_dependency(%q<bacon>, [">= 0"])
-      s.add_runtime_dependency(%q<jeweler>, [">= 0"])
-      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
       s.add_development_dependency(%q<bacon>, [">= 0"])
       s.add_development_dependency(%q<redis-namespace>, [">= 1.2.0"])
-      s.add_runtime_dependency(%q<redis>, [">= 3.0.2"])
     else
       s.add_dependency(%q<redis>, [">= 3.0.2"])
-      s.add_dependency(%q<redis-namespace>, [">= 0"])
-      s.add_dependency(%q<bacon>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-      s.add_dependency(%q<activerecord>, [">= 0"])
       s.add_dependency(%q<bacon>, [">= 0"])
       s.add_dependency(%q<redis-namespace>, [">= 1.2.0"])
-      s.add_dependency(%q<redis>, [">= 3.0.2"])
     end
   else
     s.add_dependency(%q<redis>, [">= 3.0.2"])
-    s.add_dependency(%q<redis-namespace>, [">= 0"])
-    s.add_dependency(%q<bacon>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 0"])
-    s.add_dependency(%q<activerecord>, [">= 0"])
     s.add_dependency(%q<bacon>, [">= 0"])
     s.add_dependency(%q<redis-namespace>, [">= 1.2.0"])
-    s.add_dependency(%q<redis>, [">= 3.0.2"])
   end
 end
 

data/spec/redis_autoload_objects_spec.rb

@@ -0,0 +1,46 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# tests whether autoload functionality works correctly; had issues previously
+
+require 'redis/objects'
+# $redis used automatically
+
+describe 'Redis::Objects' do
+  it "should autoload everything" do
+    defined?(::Redis::Counter).should == "constant"
+    x = Redis::Counter.new('x')
+    x.class.name.should == "Redis::Counter"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::HashKey).should == "constant"
+    x = Redis::HashKey.new('x')
+    x.class.name.should == "Redis::HashKey"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::List).should == "constant"
+    x = Redis::List.new('x')
+    x.class.name.should == "Redis::List"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::Lock).should == "constant"
+    x = Redis::Lock.new('x')
+    x.class.name.should == "Redis::Lock"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::Set).should == "constant"
+    x = Redis::Set.new('x')
+    x.class.name.should == "Redis::Set"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::SortedSet).should == "constant"
+    x = Redis::SortedSet.new('x')
+    x.class.name.should == "Redis::SortedSet"
+    x.redis.should == REDIS_HANDLE
+
+    defined?(::Redis::Value).should == "constant"
+    x = Redis::Value.new('x')
+    x.class.name.should == "Redis::Value"
+    x.redis.should == REDIS_HANDLE
+  end
+end

data/spec/redis_namespace_compat_spec.rb

@@ -1,7 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
-Redis::Objects.redis = $redis
+Redis::Objects.redis = REDIS_HANDLE
 
 $LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../../redis-namespace/lib')
 begin
@@ -9,7 +9,7 @@ begin
 
   describe 'Redis::Namespace compat' do
     it "tests the compatibility of Hash and ::Hash conflicts" do
-      ns = Redis::Namespace.new("resque", :redis => $redis)
+      ns = Redis::Namespace.new("resque", :redis => REDIS_HANDLE)
       ns.instance_eval { rem_namespace({"resque:x" => nil}) }.should == {"x"=>nil}
       class Foo
         include Redis::Objects

data/spec/redis_objects_active_record_spec.rb

@@ -2,7 +2,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
-Redis::Objects.redis = $redis
+# $redis used automatically
 
 begin
   require 'active_record'

data/spec/redis_objects_conn_spec.rb

@@ -0,0 +1,104 @@
+#
+# Connection tests - a bit ugly but important
+#
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+
+BAD_REDIS = "totally bad bogus redis handle"
+
+# Grab a global handle
+describe 'Connection tests' do
+  it "should support local handles" do
+    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::Objects.redis.inspect.should == Redis.new.inspect
+
+    v = Redis::Value.new('conn/value', @redis_handle)
+    v.clear
+    v.value = 'yay'
+    v.value.should == 'yay'
+
+    h = Redis::HashKey.new('conn/hash', @redis_handle)
+    h.clear
+    h['k'] = 'v'
+
+    l = Redis::List.new('conn/list', @redis_handle)
+    l.clear
+    l << 3
+    l << 4
+    l << 5
+
+    s = Redis::Set.new('conn/set', @redis_handle)
+    s.clear
+    s << 5
+    s << 5
+    s << 6
+    s << 7
+
+    z = Redis::SortedSet.new('conn/zset', @redis_handle)
+    z.clear
+    z['a'] = 8
+    z['b'] = 7
+    z['c'] = 9
+    z['d'] = 6
+
+    c = Redis::Counter.new('conn/counter', @redis_handle)
+    c.reset
+    c.incr(3)
+    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
+  end
+
+  it "should support Redis::Objects.redis=" do
+    @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
+
+    # 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
+    # init code in redis-rb will keep that value until we clear it.
+    # This ends up fucking any sequential tests.
+    raises_exception{ Redis::Value.new('conn/value').should.be.nil       }
+    raises_exception{ Redis::HashKey.new('conn/hash').keys.should == []  }
+    raises_exception{ Redis::List.new('conn/list').sort.should == []     }
+    raises_exception{ Redis::Set.new('conn/set').sort.should == []       }
+    raises_exception{ Redis::SortedSet.new('conn/zset').should == []     }
+    raises_exception{ Redis::Counter.new('conn/counter').get.should == 0 }
+
+    Redis::Objects.redis = @redis_handle
+    Redis::Value.new('fart').redis.should == @redis_handle
+
+    # These should now get the correct handle
+    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
+
+    # Fix for future tests
+    Redis.current = @redis_handle
+  end
+
+end
+
+