redis-objects 0.2.1 → 0.2.4

data/spec/redis_objects_instance_spec.rb

@@ -3,8 +3,10 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 require 'redis/counter'
 require 'redis/list'
-require 'redis/set'
 require 'redis/value'
+require 'redis/lock'
+require 'redis/set'
+require 'redis/sorted_set'
 
 describe Redis::Value do
   before :all do
@@ -36,6 +38,19 @@ describe Redis::Value do
     @value.should be_nil
   end
 
+  it "should support renaming values" do
+    @value.value = 'Peter Pan'
+    @value.key.should == 'spec/value'
+    @value.rename('spec/value2').should be_true
+    @value.key.should == 'spec/value2'
+    @value.should == 'Peter Pan'
+    old = Redis::Value.new('spec/value')
+    old.should be_nil
+    old.value = 'Tuff'
+    @value.renamenx('spec/value').should be_false
+    @value.value.should == 'Peter Pan'
+  end
+
   after :all do
     @value.delete
   end
@@ -131,12 +146,164 @@ describe Redis::List do
     @list.last.should == [1,2,3,[4,5]]
     @list.shift.should == {:json => 'data'}
   end
+  
+  it "should support renaming lists" do
+    @list.should be_empty
+    @list << 'a' << 'b' << 'a' << 3
+    @list.should == ['a','b','a','3']
+    @list.key.should == 'spec/list'
+    @list.rename('spec/list3', false).should be_true
+    @list.key.should == 'spec/list'
+    @list.redis.del('spec/list3')
+    @list << 'a' << 'b' << 'a' << 3
+    @list.rename('spec/list2').should be_true
+    @list.key.should == 'spec/list2'
+    @list.redis.lrange(@list.key, 0, 3).should == ['a','b','a','3']
+    old = Redis::List.new('spec/list')
+    old.should be_empty
+    old << 'Tuff'
+    old.values.should == ['Tuff']
+    @list.renamenx('spec/list').should be_false
+    @list.renamenx(old).should be_false
+    @list.renamenx('spec/foo').should be_true
+    old.values.should == ['Tuff']
+    @list.clear
+    @list.redis.del('spec/list2')
+  end
 
   after :all do
     @list.clear
   end
 end
 
+describe Redis::Counter do
+  before :all do
+    @counter  = Redis::Counter.new('spec/counter')
+    @counter2 = Redis::Counter.new('spec/counter')
+  end
+
+  before :each do
+    @counter.reset
+  end
+
+  it "should support increment/decrement of counters" do
+    @counter.key.should == 'spec/counter'
+    @counter.incr(10)
+    @counter.should == 10
+    
+    # math proxy ops
+    (@counter == 10).should be_true
+    (@counter <= 10).should be_true
+    (@counter < 11).should be_true
+    (@counter > 9).should be_true
+    (@counter >= 10).should be_true
+    "#{@counter}".should == "10"
+
+    @counter.increment.should == 11
+    @counter.increment.should == 12
+    @counter2.increment.should == 13
+    @counter2.increment(2).should == 15
+    @counter.decrement.should == 14
+    @counter2.decrement.should == 13
+    @counter.decrement.should == 12
+    @counter2.decrement(4).should == 8
+    @counter.should == 8
+    @counter.reset.should be_true
+    @counter.should == 0
+    @counter.reset(15).should be_true
+    @counter.should == 15
+  end
+
+  after :all do
+    @counter.delete
+  end
+end
+
+describe Redis::Lock do
+  before :each do
+    $redis.flushall
+  end
+
+  it "should set the value to the expiration" do
+    start = Time.now
+    expiry = 15
+    lock = Redis::Lock.new(:test_lock, :expiration => expiry)
+    lock.lock do
+      expiration = $redis.get("test_lock").to_f
+
+      # The expiration stored in redis should be 15 seconds from when we started
+      # or a little more
+      expiration.should be_close((start + expiry).to_f, 2.0)
+    end
+
+    # key should have been cleaned up
+    $redis.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'
+    end
+
+    # key should have been cleaned up
+    $redis.get("test_lock").should be_nil
+  end
+
+  it "should let lock be gettable when lock is expired" do
+    expiry = 15
+    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))
+
+    gotit = false
+    lock.lock do
+      gotit = true
+    end
+
+    # should get the lock because it has expired
+    gotit.should be_true
+    $redis.get("test_lock").should be_nil
+  end
+
+  it "should not let non-expired locks be gettable" do
+    expiry = 15
+    lock = Redis::Lock.new(:test_lock, :expiration => expiry, :timeout => 0.1)
+
+    # create a fake lock
+    $redis.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.get("test_lock").should_not be_nil
+  end
+
+  it "should not remove the key if lock is held past expiration" do
+    lock = Redis::Lock.new(:test_lock, :expiration => 0.0)
+
+    lock.lock do
+      sleep 1.1
+    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
+  end
+end
+
 describe Redis::Set do
   before :all do
     @set = Redis::Set.new('spec/set')
@@ -191,7 +358,7 @@ describe Redis::Set do
     @set.sort.should == ['a','b','c']
   end
   
-  it "should handle set intersections and unions" do
+  it "should handle set intersections, unions, and diffs" do
     @set_1 << 'a' << 'b' << 'c' << 'd' << 'e'
     @set_2 << 'c' << 'd' << 'e' << 'f' << 'g'
     @set_3 << 'a' << 'd' << 'g' << 'l' << 'm'
@@ -216,6 +383,34 @@ describe Redis::Set do
     @set_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g']
     @set_1.unionstore(UNIONSTORE_KEY, @set_2, @set_3).should == 9
     @set_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g','l','m']
+
+    (@set_1 ^ @set_2).sort.should == ["a", "b"]
+    (@set_1 - @set_2).sort.should == ["a", "b"]
+    (@set_2 - @set_1).sort.should == ["f", "g"]
+    @set_1.difference(@set_2).sort.should == ["a", "b"]
+    @set_1.diff(@set_2).sort.should == ["a", "b"]
+    @set_1.difference(@set_2, @set_3).sort.should == ['b']
+    @set_1.diffstore(DIFFSTORE_KEY, @set_2).should == 2
+    @set_1.redis.smembers(DIFFSTORE_KEY).sort.should == ['a','b']
+    @set_1.diffstore(DIFFSTORE_KEY, @set_2, @set_3).should == 1
+    @set_1.redis.smembers(DIFFSTORE_KEY).sort.should == ['b']
+  end
+
+  it "should support renaming sets" do
+    @set.should be_empty
+    @set << 'a' << 'b' << 'a' << 3
+    @set.sort.should == ['3','a','b']
+    @set.key.should == 'spec/set'
+    @set.rename('spec/set2').should be_true
+    @set.key.should == 'spec/set2'
+    old = Redis::Set.new('spec/set')
+    old.should be_empty
+    old << 'Tuff'
+    @set.renamenx('spec/set').should be_false
+    @set.renamenx(old).should be_false
+    @set.renamenx('spec/foo').should be_true
+    @set.clear
+    @set.redis.del('spec/set2')
   end
 
   after :all do
@@ -226,45 +421,157 @@ describe Redis::Set do
   end
 end
 
-describe Redis::Counter do
+describe Redis::SortedSet do
   before :all do
-    @counter  = Redis::Counter.new('spec/counter')
-    @counter2 = Redis::Counter.new('spec/counter')
+    @set = Redis::SortedSet.new('spec/zset')
+    @set_1 = Redis::SortedSet.new('spec/zset_1')
+    @set_2 = Redis::SortedSet.new('spec/zset_2')
+    @set_3 = Redis::SortedSet.new('spec/zset_3')
   end
 
   before :each do
-    @counter.reset
+    @set.clear
+    @set_1.clear
+    @set_2.clear
+    @set_3.clear
   end
 
-  it "should support increment/decrement of counters" do
-    @counter.key.should == 'spec/counter'
-    @counter.incr(10)
-    @counter.should == 10
+  it "should handle sets of simple values" do
+    @set.should be_empty
+    @set['a'] = 11
+    @set['a'] = 21
+    @set.add('a', 5)
+    @set.score('a').should == 5
+    @set['a'] = 3
+    @set['b'] = 5
+    @set['c'] = 4
+
+    @set[0,-1].should == ['a','c','b']
+    @set.range(0,-1).should == ['a','c','b']
+    @set.revrange(0,-1).should == ['b','c','a']
+    @set[0..1].should == ['a','c']
+    @set[1].should == 'c'
+    @set.at(1).should == 'c'
+    @set.first.should == 'a'
+    @set.last.should == 'b'
+
+    @set.members.should == ['a','c','b']
+    @set.members(:withscores => true).should == [['a',3],['c',4],['b',5]]
+
+    @set['b'] = 5
+    @set['b'] = 6
+    @set.score('b').should == 6
+    @set.delete('c')
+    @set.to_s.should == 'a, b'
+    @set.should == ['a','b']
+    @set.members.should == ['a','b']
+    @set['d'] = 0
     
-    # math proxy ops
-    (@counter == 10).should be_true
-    (@counter <= 10).should be_true
-    (@counter < 11).should be_true
-    (@counter > 9).should be_true
-    (@counter >= 10).should be_true
-    "#{@counter}".should == "10"
+    @set.rangebyscore(0, 4).should == ['d','a']
+    @set.rangebyscore(0, 4, :count => 1).should == ['d']
+    @set.rangebyscore(0, 4, :count => 2).should == ['d','a']
+    @set.rangebyscore(0, 4, :limit => 2).should == ['d','a']
 
-    @counter.increment.should == 11
-    @counter.increment.should == 12
-    @counter2.increment.should == 13
-    @counter2.increment(2).should == 15
-    @counter.decrement.should == 14
-    @counter2.decrement.should == 13
-    @counter.decrement.should == 12
-    @counter2.decrement(4).should == 8
-    @counter.should == 8
-    @counter.reset.should be_true
-    @counter.should == 0
-    @counter.reset(15).should be_true
-    @counter.should == 15
+    # Redis 1.3.5
+    # @set.rangebyscore(0,4, :withscores => true).should == [['d',4],['a',3]]
+    # @set.revrangebyscore(0,4).should == ['d','a']
+    # @set.revrangebyscore(0,4, :count => 2).should == ['a','d']
+    # @set.rank('b').should == 2
+    # @set.revrank('b').should == 3
+
+    @set['f'] = 100
+    @set['g'] = 110
+    @set['h'] = 120
+    @set['j'] = 130
+    @set.incr('h', 20)
+    @set.remrangebyscore(100, 120)
+    @set.members.should == ['d','a','b','j','h']
+
+    # Redis 1.3.5
+    # @set['h'] = 12
+    # @set['j'] = 13
+    # @set.remrangebyrank(4,-1)
+    # @set.members.should == ['d','a','b']
+
+    @set.delete('d')
+    @set['c'] = 200
+    @set.members.should == ['a','b','j','h','c']
+    @set.delete('c')
+    @set.length.should == 4
+    @set.size.should == 4
+  end
+
+  # Not until Redis 1.3.5 with hashes
+  xit "Redis 1.3.5: should handle set intersections, unions, and diffs" do
+    @set_1['a'] = 5
+    @set_2['b'] = 18
+    @set_2['c'] = 12
+
+    @set_2['a'] = 10
+    @set_2['b'] = 15
+    @set_2['c'] = 15
+
+    (@set_1 & @set_2).sort.should == ['c','d','e']
+
+    @set_1 << 'a' << 'b' << 'c' << 'd' << 'e'
+    @set_2 << 'c' << 'd' << 'e' << 'f' << 'g'
+    @set_3 << 'a' << 'd' << 'g' << 'l' << 'm'
+    @set_1.sort.should == %w(a b c d e)
+    @set_2.sort.should == %w(c d e f g)
+    @set_3.sort.should == %w(a d g l m)
+    (@set_1 & @set_2).sort.should == ['c','d','e']
+    @set_1.intersection(@set_2).sort.should == ['c','d','e']
+    @set_1.intersection(@set_2, @set_3).sort.should == ['d']
+    @set_1.intersect(@set_2).sort.should == ['c','d','e']
+    @set_1.inter(@set_2, @set_3).sort.should == ['d']
+    @set_1.interstore(INTERSTORE_KEY, @set_2).should == 3
+    @set_1.redis.smembers(INTERSTORE_KEY).sort.should == ['c','d','e']
+    @set_1.interstore(INTERSTORE_KEY, @set_2, @set_3).should == 1
+    @set_1.redis.smembers(INTERSTORE_KEY).sort.should == ['d']
+
+    (@set_1 | @set_2).sort.should == ['a','b','c','d','e','f','g']
+    (@set_1 + @set_2).sort.should == ['a','b','c','d','e','f','g']
+    @set_1.union(@set_2).sort.should == ['a','b','c','d','e','f','g']
+    @set_1.union(@set_2, @set_3).sort.should == ['a','b','c','d','e','f','g','l','m']
+    @set_1.unionstore(UNIONSTORE_KEY, @set_2).should == 7
+    @set_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g']
+    @set_1.unionstore(UNIONSTORE_KEY, @set_2, @set_3).should == 9
+    @set_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g','l','m']
+
+    (@set_1 ^ @set_2).sort.should == ["a", "b"]
+    (@set_1 - @set_2).sort.should == ["a", "b"]
+    (@set_2 - @set_1).sort.should == ["f", "g"]
+    @set_1.difference(@set_2).sort.should == ["a", "b"]
+    @set_1.diff(@set_2).sort.should == ["a", "b"]
+    @set_1.difference(@set_2, @set_3).sort.should == ['b']
+    @set_1.diffstore(DIFFSTORE_KEY, @set_2).should == 2
+    @set_1.redis.smembers(DIFFSTORE_KEY).sort.should == ['a','b']
+    @set_1.diffstore(DIFFSTORE_KEY, @set_2, @set_3).should == 1
+    @set_1.redis.smembers(DIFFSTORE_KEY).sort.should == ['b']
+  end
+
+  it "should support renaming sets" do
+    @set.should be_empty
+    @set['zynga'] = 151
+    @set['playfish'] = 202
+    @set.members.should == ['zynga','playfish']
+    @set.key.should == 'spec/zset'
+    @set.rename('spec/zset2').should be_true
+    @set.key.should == 'spec/zset2'
+    old = Redis::SortedSet.new('spec/zset')
+    old.should be_empty
+    old['tuff'] = 54
+    @set.renamenx('spec/zset').should be_false
+    @set.renamenx(old).should be_false
+    @set.renamenx('spec/zfoo').should be_true
+    @set.clear
+    @set.redis.del('spec/zset2')
   end
 
   after :all do
-    @counter.delete
+    @set.clear
+    @set_1.clear
+    @set_2.clear
+    @set_3.clear
   end
-end
+end

data/spec/redis_objects_model_spec.rb

@@ -9,12 +9,17 @@ class Roster
   counter :available_slots, :start => 10
   counter :pitchers, :limit => :max_pitchers
   counter :basic
-  counter :all_players_online, :global => true
   lock :resort, :timeout => 2
   value :starting_pitcher
   list :player_stats
   set :outfielders
 
+  # global class counters
+  counter :total_players_online, :global => true
+  list :all_player_stats, :global => true
+  set :all_players_online, :global => true
+  value :last_player, :global => true
+
   def initialize(id=1) @id = id end
   def id; @id; end
   def max_pitchers; 3; end
@@ -43,11 +48,17 @@ describe Redis::Objects do
     @roster_3.outfielders.clear
     @roster.redis.del(UNIONSTORE_KEY)
     @roster.redis.del(INTERSTORE_KEY)
+    @roster.redis.del(DIFFSTORE_KEY)
+    
+    Roster.total_players_online.reset
+    Roster.all_player_stats.clear
+    Roster.all_players_online.clear
+    Roster.last_player.delete
   end
 
   it "should provide a connection method" do
     Roster.redis.should == Redis::Objects.redis
-    Roster.redis.should be_kind_of(Redis)
+    # Roster.redis.should be_kind_of(Redis)
   end
 
   it "should create counter accessors" do
@@ -97,6 +108,24 @@ describe Redis::Objects do
     Roster.get_counter(:available_slots, @roster.id).should == 10
   end
 
+  it "should support class-level increment/decrement of global counters" do
+    Roster.total_players_online.should == 0
+    Roster.total_players_online.increment.should == 1
+    Roster.total_players_online.decrement.should == 0
+    Roster.total_players_online.increment(3).should == 3
+    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
+    Roster.decrement_counter(:total_players_online, nil, 2).should == 2
+    Roster.decrement_counter(:total_players_online).should == 1
+    Roster.reset_counter(:total_players_online).should == true
+    Roster.get_counter(:total_players_online).should == 0
+  end
+
   it "should take an atomic block for increment/decrement" do
     a = false
     @roster.available_slots.should == 10
@@ -253,12 +282,27 @@ describe Redis::Objects do
     end
     error.should be_kind_of(NoMethodError)
   end
+
+  it "should support obtain_lock as a class method" do
+    error = nil
+    begin
+      Roster.obtain_lock(:resort, 2) do
+        Roster.redis.get("roster:2:resort_lock").should_not be_nil
+      end
+    rescue => error
+    end
+
+    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'
     @roster.starting_pitcher.should == 'Trevor Hoffman'
     @roster.starting_pitcher.get.should == 'Trevor Hoffman'
+    @roster.starting_pitcher = 'Tom Selleck'
+    @roster.starting_pitcher.should == 'Tom Selleck'
     @roster.starting_pitcher.del.should be_true
     @roster.starting_pitcher.should be_nil
   end
@@ -409,6 +453,162 @@ describe Redis::Objects do
     @roster_1.redis.smembers(UNIONSTORE_KEY).sort.should == ['a','b','c','d','e','f','g','l','m']
   end
 
+  it "should handle class-level global lists of simple values" do
+    Roster.all_player_stats.should be_empty
+    Roster.all_player_stats << 'a'
+    Roster.all_player_stats.should == ['a']
+    Roster.all_player_stats.get.should == ['a']
+    Roster.all_player_stats.unshift 'b'
+    Roster.all_player_stats.to_s.should == 'b, a'
+    Roster.all_player_stats.should == ['b','a']
+    Roster.all_player_stats.get.should == ['b','a']
+    Roster.all_player_stats.push 'c'
+    Roster.all_player_stats.should == ['b','a','c']
+    Roster.all_player_stats.get.should == ['b','a','c']
+    Roster.all_player_stats.first.should == 'b'
+    Roster.all_player_stats.last.should == 'c'
+    Roster.all_player_stats << 'd'
+    Roster.all_player_stats.should == ['b','a','c','d']
+    Roster.all_player_stats[1].should == 'a'
+    Roster.all_player_stats[0].should == 'b'
+    Roster.all_player_stats[2].should == 'c'
+    Roster.all_player_stats[3].should == 'd'
+    Roster.all_player_stats.include?('c').should be_true
+    Roster.all_player_stats.include?('no').should be_false
+    Roster.all_player_stats.pop.should == 'd'
+    Roster.all_player_stats[0].should == Roster.all_player_stats.at(0)
+    Roster.all_player_stats[1].should == Roster.all_player_stats.at(1)
+    Roster.all_player_stats[2].should == Roster.all_player_stats.at(2)
+    Roster.all_player_stats.should == ['b','a','c']
+    Roster.all_player_stats.get.should == ['b','a','c']
+    Roster.all_player_stats.shift.should == 'b'
+    Roster.all_player_stats.should == ['a','c']
+    Roster.all_player_stats.get.should == ['a','c']
+    Roster.all_player_stats << 'e' << 'f' << 'e'
+    Roster.all_player_stats.should == ['a','c','e','f','e']
+    Roster.all_player_stats.get.should == ['a','c','e','f','e']
+    Roster.all_player_stats.delete('e').should == 2
+    Roster.all_player_stats.should == ['a','c','f']
+    Roster.all_player_stats.get.should == ['a','c','f']
+    Roster.all_player_stats << 'j'
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats[0..2].should == ['a','c','f']
+    Roster.all_player_stats[1, 3].should == ['c','f','j']
+    Roster.all_player_stats.length.should == 4
+    Roster.all_player_stats.size.should == 4
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    i = -1
+    Roster.all_player_stats.each do |st|
+      st.should == Roster.all_player_stats[i += 1]
+    end
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    Roster.all_player_stats.each_with_index do |st,i|
+      st.should == Roster.all_player_stats[i]
+    end
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    coll = Roster.all_player_stats.collect{|st| st}
+    coll.should == ['a','c','f','j']
+    Roster.all_player_stats.should == ['a','c','f','j']
+    Roster.all_player_stats.get.should == ['a','c','f','j']
+
+    Roster.all_player_stats << 'a'
+    coll = Roster.all_player_stats.select{|st| st == 'a'}
+    coll.should == ['a','a']
+    Roster.all_player_stats.should == ['a','c','f','j','a']
+    Roster.all_player_stats.get.should == ['a','c','f','j','a']
+  end
+
+  it "should handle class-level global sets of simple values" do
+    Roster.all_players_online.should be_empty
+    Roster.all_players_online << 'a' << 'a' << 'a'
+    Roster.all_players_online.should == ['a']
+    Roster.all_players_online.get.should == ['a']
+    Roster.all_players_online << 'b' << 'b'
+    Roster.all_players_online.to_s.should == 'a, b'
+    Roster.all_players_online.should == ['a','b']
+    Roster.all_players_online.members.should == ['a','b']
+    Roster.all_players_online.get.should == ['a','b']
+    Roster.all_players_online << 'c'
+    Roster.all_players_online.sort.should == ['a','b','c']
+    Roster.all_players_online.get.sort.should == ['a','b','c']
+    Roster.all_players_online.delete('c')
+    Roster.all_players_online.should == ['a','b']
+    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
+    end
+    i.should == Roster.all_players_online.length
+
+    coll = Roster.all_players_online.collect{|st| st}
+    coll.should == ['a','b']
+    Roster.all_players_online.should == ['a','b']
+    Roster.all_players_online.get.should == ['a','b']
+
+    Roster.all_players_online << 'c'
+    Roster.all_players_online.member?('c').should be_true
+    Roster.all_players_online.include?('c').should be_true
+    Roster.all_players_online.member?('no').should be_false
+    coll = Roster.all_players_online.select{|st| st == 'c'}
+    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'
+    Roster.last_player.should == 'Trevor Hoffman'
+    Roster.last_player.get.should == 'Trevor Hoffman'
+    Roster.last_player = 'Tom Selleck'
+    Roster.last_player.should == 'Tom Selleck'
+    Roster.last_player.del.should be_true
+    Roster.last_player.should be_nil
+  end
+
+  it "should easily enable @object.class.global_objects" do
+    @roster.class.all_players_online.should be_empty
+    @roster.class.all_players_online << 'a' << 'a' << 'a'
+    @roster.class.all_players_online.should == ['a']
+    @roster2.class.all_players_online.should == ['a']
+
+    @roster.all_players_online.should == ['a']
+    @roster2.all_players_online.should == ['a']
+
+    @roster.class.all_player_stats.should be_empty
+    @roster.class.all_player_stats << 'a'
+    @roster.class.all_player_stats.should == ['a']
+    @roster.class.all_player_stats.get.should == ['a']
+    @roster.class.all_player_stats.unshift 'b'
+    @roster.class.all_player_stats.to_s.should == 'b, a'
+    @roster.class.all_player_stats.should == ['b','a']
+    @roster2.class.all_player_stats.should == ['b','a']
+
+    @roster.all_player_stats.should == ['b','a']
+    @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'
+    @roster.last_player.get.should == 'Trevor Hoffman'
+    @roster2.last_player.get.should == 'Trevor Hoffman'
+    @roster2.last_player = 'Tom Selleck'
+    @roster.last_player.should == 'Tom Selleck'
+    @roster.last_player.del.should be_true
+    @roster.last_player.should be_nil
+    @roster2.last_player.should be_nil
+  end
+
   it "should handle lists of complex data types" do
     @roster.player_stats << {:json => 'data'}
     @roster.player_stats << {:json2 => 'data2'}
@@ -448,4 +648,5 @@ describe Redis::Objects do
     error.should_not be_nil
     error.should be_kind_of(Redis::Lock::LockTimeout)
   end
+
 end

data/spec/spec_helper.rb

@@ -5,3 +5,4 @@ $redis = Redis.new(:host => ENV['REDIS_HOST'], :port => ENV['REDIS_PORT'])
 
 UNIONSTORE_KEY = 'test:unionstore'
 INTERSTORE_KEY = 'test:interstore'
+DIFFSTORE_KEY  = 'test:diffstore'