redis-objects 0.6.1 → 0.7.0

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/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/redis-objects.gemspec

@@ -5,24 +5,24 @@
 
 Gem::Specification.new do |s|
   s.name = "redis-objects"
-  s.version = "0.6.1"
+  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,8 +42,10 @@ 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"

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
+
+

data/spec/redis_objects_instance_spec.rb

@@ -1,13 +1,7 @@
 
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-require 'redis/counter'
-require 'redis/list'
-require 'redis/value'
-require 'redis/lock'
-require 'redis/set'
-require 'redis/sorted_set'
-require 'redis/hash_key'
+require 'redis/objects'
 
 describe Redis::Value do
   before do
@@ -27,6 +21,8 @@ describe Redis::Value do
     @value.get.should == 'Trevor Hoffman'
     @value.del.should == 1
     @value.should.be.nil
+    @value.value = 42
+    @value.value.should == '42'
   end
 
   it "should handle complex marshaled values" do
@@ -100,7 +96,6 @@ describe Redis::List do
   describe "as a bounded list" do
     before do
       @list = Redis::List.new('spec/bounded_list',
-                              $redis,
                               :maxlength => 10)
       1.upto(10) do |i|
         @list << i
@@ -330,7 +325,7 @@ end
 
 describe Redis::Lock do
   before do
-    $redis.flushall
+    REDIS_HANDLE.flushall
   end
 
   it "should set the value to the expiration" do
@@ -338,7 +333,7 @@ describe Redis::Lock do
     expiry = 15
     lock = Redis::Lock.new(:test_lock, :expiration => expiry)
     lock.lock do
-      expiration = $redis.get("test_lock").to_f
+      expiration = REDIS_HANDLE.get("test_lock").to_f
 
       # The expiration stored in redis should be 15 seconds from when we started
       # or a little more
@@ -346,17 +341,17 @@ describe Redis::Lock do
     end
 
     # key should have been cleaned up
-    $redis.get("test_lock").should.be.nil
+    REDIS_HANDLE.get("test_lock").should.be.nil
   end
 
   it "should set value to 1 when no expiration is set" do
     lock = Redis::Lock.new(:test_lock)
     lock.lock do
-      $redis.get('test_lock').should == '1'
+      REDIS_HANDLE.get('test_lock').should == '1'
     end
 
     # key should have been cleaned up
-    $redis.get("test_lock").should.be.nil
+    REDIS_HANDLE.get("test_lock").should.be.nil
   end
 
   it "should let lock be gettable when lock is expired" do
@@ -364,7 +359,7 @@ describe Redis::Lock do
     lock = Redis::Lock.new(:test_lock, :expiration => expiry, :timeout => 0.1)
 
     # create a fake lock in the past
-    $redis.set("test_lock", Time.now-(expiry + 60))
+    REDIS_HANDLE.set("test_lock", Time.now-(expiry + 60))
 
     gotit = false
     lock.lock do
@@ -373,7 +368,7 @@ describe Redis::Lock do
 
     # should get the lock because it has expired
     gotit.should.be.true
-    $redis.get("test_lock").should.be.nil
+    REDIS_HANDLE.get("test_lock").should.be.nil
   end
 
   it "should not let non-expired locks be gettable" do
@@ -381,7 +376,7 @@ describe Redis::Lock do
     lock = Redis::Lock.new(:test_lock, :expiration => expiry, :timeout => 0.1)
 
     # create a fake lock
-    $redis.set("test_lock", (Time.now + expiry).to_f)
+    REDIS_HANDLE.set("test_lock", (Time.now + expiry).to_f)
 
     gotit = false
     error = nil
@@ -398,7 +393,7 @@ describe Redis::Lock do
     gotit.should.not.be.true
 
     # lock value should still be set
-    $redis.get("test_lock").should.not.be.nil
+    REDIS_HANDLE.get("test_lock").should.not.be.nil
   end
 
   it "should not remove the key if lock is held past expiration" do
@@ -409,7 +404,7 @@ describe Redis::Lock do
     end
 
     # lock value should still be set since the lock was held for more than the expiry
-    $redis.get("test_lock").should.not.be.nil
+    REDIS_HANDLE.get("test_lock").should.not.be.nil
   end
 end
 
@@ -417,8 +412,7 @@ end
 describe Redis::HashKey do
   describe "With Marshal" do
     before do
-      @hash = Redis::HashKey.new('test_hash', $redis,
-                                {:marshal_keys=>{'created_at'=>true}})
+      @hash = Redis::HashKey.new('test_hash', {:marshal_keys=>{'created_at'=>true}})
       @hash.clear
     end
 
@@ -449,7 +443,7 @@ describe Redis::HashKey do
   end
 
   before do
-    @hash  = Redis::HashKey.new('test_hash')
+    @hash = Redis::HashKey.new('test_hash')
     @hash.clear
   end
   

data/spec/redis_objects_model_spec.rb

@@ -2,7 +2,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/objects'
-Redis::Objects.redis = $redis
 
 class Roster
   include Redis::Objects
@@ -20,7 +19,7 @@ class Roster
   counter :total_players_online, :global => true
   set :all_players_online, :global => true
   value :last_player, :global => true
-  
+
   # custom keys
   counter :player_totals, :key => 'players/#{username}/total'
   list :all_player_stats, :key => 'players:all_stats', :global => true
@@ -52,14 +51,14 @@ class MethodRoster
   def increment(attribute, by=1)
     42
   end
-  
+
   def initialize(id=1) @id = id end
   def id; @id; end
 end
 
 class CustomMethodRoster < MethodRoster
   include Redis::Objects
-  
+
   attr_accessor :counter
   counter :basic
 end
@@ -68,7 +67,7 @@ describe Redis::Objects do
   before do
     @roster  = Roster.new
     @roster2 = Roster.new
-    
+
     @roster_1 = Roster.new(1)
     @roster_2 = Roster.new(2)
     @roster_3 = Roster.new(3)
@@ -96,7 +95,7 @@ describe Redis::Objects do
     Roster.all_players_online.clear
     Roster.last_player.delete
     Roster.weird_key.clear
-    
+
     @roster.player_totals.clear
     @roster.all_player_stats.clear
     @roster.total_wins.clear
@@ -173,11 +172,11 @@ describe Redis::Objects do
        @roster.respond_to?(m).should == true
      end
   end
-  
+
   it "should support increment/decrement of counters" do
     @roster.available_slots.key.should == 'roster:1:available_slots'
     @roster.available_slots.should == 10
-    
+
     # math proxy ops
     (@roster.available_slots == 10).should.be.true
     (@roster.available_slots <= 10).should.be.true
@@ -204,7 +203,7 @@ describe Redis::Objects do
     @roster2.basic.decrement.should == 0
     @roster.basic.get.should == 0
   end
-  
+
   it "should support class-level increment/decrement of counters" do
     Roster.get_counter(:available_slots, @roster.id).should == 10
     Roster.increment_counter(:available_slots, @roster.id).should == 11
@@ -225,7 +224,7 @@ describe Redis::Objects do
     Roster.total_players_online.decrement(2).should == 1
     Roster.total_players_online.reset.should.be.true
     Roster.total_players_online.should == 0
-    
+
     Roster.get_counter(:total_players_online).should == 0
     Roster.increment_counter(:total_players_online).should == 1
     Roster.increment_counter(:total_players_online, nil, 3).should == 4
@@ -247,21 +246,28 @@ describe Redis::Objects do
     end
     @roster.available_slots.should == 9
     a.should.be.true
-    
+
     @roster.available_slots.should == 9
     @roster.available_slots.decr do |cnt|
       @roster.available_slots.should == 8
       false
     end
     @roster.available_slots.should == 8
-    
+
     @roster.available_slots.should == 8
     @roster.available_slots.decr do |cnt|
       @roster.available_slots.should == 7
       nil  # should rewind
     end
     @roster.available_slots.should == 8
-    
+
+    @roster.available_slots.should == 8
+    @roster.available_slots.decr(4) do |cnt|
+      @roster.available_slots.should == 4
+      nil  # should rewind
+    end
+    @roster.available_slots.should == 8
+
     @roster.available_slots.should == 8
     @roster.available_slots.incr do |cnt|
       if 1 == 2  # should rewind
@@ -270,6 +276,14 @@ describe Redis::Objects do
     end
     @roster.available_slots.should == 8
 
+    @roster.available_slots.should == 8
+    @roster.available_slots.incr(5) do |cnt|
+      if 1 == 2  # should rewind
+        true
+      end
+    end
+    @roster.available_slots.should == 8
+
     @roster.available_slots.should == 8
     @roster.available_slots.incr do |cnt|
       @roster.available_slots.should == 9
@@ -286,7 +300,7 @@ describe Redis::Objects do
     rescue
     end
     @roster.available_slots.should == 9
-    
+
     # check return value from the block
     value =
       @roster.available_slots.decr do |cnt|
@@ -322,6 +336,13 @@ describe Redis::Objects do
     end
     Roster.get_counter(:available_slots, @roster.id).should == 8
 
+    Roster.get_counter(:available_slots, @roster.id).should == 8
+    Roster.decrement_counter(:available_slots, @roster.id, 4) do |cnt|
+      Roster.get_counter(:available_slots, @roster.id).should == 4
+      nil  # should rewind
+    end
+    Roster.get_counter(:available_slots, @roster.id).should == 8
+
     Roster.get_counter(:available_slots, @roster.id).should == 8
     Roster.increment_counter(:available_slots, @roster.id) do |cnt|
       if 1 == 2  # should rewind
@@ -330,6 +351,14 @@ describe Redis::Objects do
     end
     Roster.get_counter(:available_slots, @roster.id).should == 8
 
+    Roster.get_counter(:available_slots, @roster.id).should == 8
+    Roster.increment_counter(:available_slots, @roster.id, 4) do |cnt|
+      if 1 == 2  # should rewind
+        true
+      end
+    end
+    Roster.get_counter(:available_slots, @roster.id).should == 8
+
     Roster.get_counter(:available_slots, @roster.id).should == 8
     Roster.increment_counter(:available_slots, @roster.id) do |cnt|
       Roster.get_counter(:available_slots, @roster.id).should == 9
@@ -406,7 +435,7 @@ describe Redis::Objects do
     error.should.be.nil
     Roster.redis.get("roster:2:resort_lock").should.be.nil
   end
-  
+
   it "should handle simple values" do
     @roster.starting_pitcher.should == nil
     @roster.starting_pitcher = 'Trevor Hoffman'
@@ -515,7 +544,7 @@ describe Redis::Objects do
     @roster.outfielders.get.sort.should == ['a','b']
     @roster.outfielders.length.should == 2
     @roster.outfielders.size.should == 2
-    
+
     i = 0
     @roster.outfielders.each do |st|
       i += 1
@@ -535,7 +564,7 @@ describe Redis::Objects do
     coll.should == ['c']
     @roster.outfielders.sort.should == ['a','b','c']
   end
-  
+
   it "should handle set intersections and unions" do
     @roster_1.outfielders << 'a' << 'b' << 'c' << 'd' << 'e'
     @roster_2.outfielders << 'c' << 'd' << 'e' << 'f' << 'g'
@@ -651,7 +680,7 @@ describe Redis::Objects do
     Roster.all_players_online.get.sort.should == ['a','b']
     Roster.all_players_online.length.should == 2
     Roster.all_players_online.size.should == 2
-    
+
     i = 0
     Roster.all_players_online.each do |st|
       i += 1
@@ -671,7 +700,7 @@ describe Redis::Objects do
     coll.should == ['c']
     Roster.all_players_online.sort.should == ['a','b','c']
   end
-  
+
   it "should handle class-level global values" do
     Roster.last_player.should == nil
     Roster.last_player = 'Trevor Hoffman'
@@ -705,7 +734,7 @@ describe Redis::Objects do
     @roster2.all_player_stats.should == ['b','a']
     @roster2.all_player_stats << 'b'
     @roster.all_player_stats.should == ['b','a','b']
-    
+
     @roster.last_player.should == nil
     @roster.class.last_player = 'Trevor Hoffman'
     @roster.last_player.should == 'Trevor Hoffman'
@@ -727,7 +756,7 @@ describe Redis::Objects do
     @roster.player_stats.last.should == [1,2,3,[4,5]]
     @roster.player_stats.shift.should == {:json => 'data'}
   end
-  
+
   it "should handle sets of complex data types" do
     @roster.outfielders << {:a => 1}
     @roster.outfielders.members.should == [{:a => 1}]
@@ -747,7 +776,7 @@ describe Redis::Objects do
     end
     a.should.be.true
   end
-  
+
   it "should raise an exception if the timeout is exceeded" do
     @roster.redis.set(@roster.resort_lock.key, 1)
     error = nil
@@ -799,7 +828,7 @@ describe Redis::Objects do
   it "should handle new subclass objects" do
     @custom_roster.special.increment.should == 1
   end
-  
+
   it "should allow passing of increment/decrement to super class" do
     @custom_method_roster = CustomMethodRoster.new
     @custom_method_roster.counter.should.be.nil
@@ -814,4 +843,55 @@ describe Redis::Objects do
     @custom_method_roster.basic.should == 0
     @custom_method_roster.basic.should.be.kind_of(Redis::Counter)
   end
+
+  it "should pick up class methods from superclass automatically" do
+    CounterRoster = Class.new(Roster)
+    CounterRoster.counter :extended_counter
+    extended_roster = CounterRoster.new
+    extended_roster.basic.should.be.kind_of(Redis::Counter)
+    extended_roster.extended_counter.should.be.kind_of(Redis::Counter)
+    @roster.respond_to?(:extended_counter).should == false
+
+    HashKeyRoster = Class.new(Roster)
+    HashKeyRoster.hash_key :extended_hash_key
+    extended_roster = HashKeyRoster.new
+    extended_roster.contact_information.should.be.kind_of(Redis::HashKey)
+    extended_roster.extended_hash_key.should.be.kind_of(Redis::HashKey)
+    @roster.respond_to?(:extended_hash_key).should == false
+
+    LockRoster = Class.new(Roster)
+    LockRoster.lock :extended
+    extended_roster = LockRoster.new
+    extended_roster.resort_lock.should.be.kind_of(Redis::Lock)
+    extended_roster.extended_lock.should.be.kind_of(Redis::Lock)
+    @roster.respond_to?(:extended_lock).should == false
+
+    ValueRoster = Class.new(Roster)
+    ValueRoster.value :extended_value
+    extended_roster = ValueRoster.new
+    extended_roster.starting_pitcher.should.be.kind_of(Redis::Value)
+    extended_roster.extended_value.should.be.kind_of(Redis::Value)
+    @roster.respond_to?(:extended_value).should == false
+
+    ListRoster = Class.new(Roster)
+    ListRoster.list :extended_list
+    extended_roster = ListRoster.new
+    extended_roster.player_stats.should.be.kind_of(Redis::List)
+    extended_roster.extended_list.should.be.kind_of(Redis::List)
+    @roster.respond_to?(:extended_list).should == false
+
+    SetRoster = Class.new(Roster)
+    SetRoster.set :extended_set
+    extended_roster = SetRoster.new
+    extended_roster.outfielders.should.be.kind_of(Redis::Set)
+    extended_roster.extended_set.should.be.kind_of(Redis::Set)
+    @roster.respond_to?(:extended_set).should == false
+
+    SortedSetRoster = Class.new(Roster)
+    SortedSetRoster.sorted_set :extended_sorted_set
+    extended_roster = SortedSetRoster.new
+    extended_roster.rank.should.be.kind_of(Redis::SortedSet)
+    extended_roster.extended_sorted_set.should.be.kind_of(Redis::SortedSet)
+    @roster.respond_to?(:extended_sorted_set).should == false
+  end
 end