redistat 0.3.0 → 0.4.0

data/spec/finder_spec.rb

@@ -2,21 +2,21 @@ require "spec_helper"
 
 describe Redistat::Finder do
   include Redistat::Database
-  
+
   before(:each) do
     db.flushdb
     @scope = "PageViews"
     @label = "about_us"
     @date = Time.now
     @key = Redistat::Key.new(@scope, @label, @date, {:depth => :day})
-    @stats = {"views" => 3, "visitors" => 2}    
+    @stats = {"views" => 3, "visitors" => 2}
     @two_hours_ago = 2.hours.ago
     @one_hour_ago = 1.hour.ago
   end
-  
+
   it "should initialize properly" do
     options = {:scope => "PageViews", :label => "Label", :from => @two_hours_ago, :till => @one_hour_ago, :depth => :hour, :interval => :hour}
-    
+
     finder = Redistat::Finder.new
     finder.send(:set_options, options)
     finder.options[:scope].should be_a(Redistat::Scope)
@@ -24,31 +24,31 @@ describe Redistat::Finder do
     finder.options[:label].should be_a(Redistat::Label)
     finder.options[:label].to_s.should == options[:label]
     finder.options.should == options.merge(:scope => finder.options[:scope], :label => finder.options[:label])
-    
+
     finder = Redistat::Finder.scope("hello")
     finder.options[:scope].to_s.should == "hello"
     finder.scope.to_s.should == "hello"
-    
+
     finder = Redistat::Finder.label("hello")
     finder.options[:label].to_s.should == "hello"
     finder.label.to_s.should == "hello"
-    
+
     finder = Redistat::Finder.dates(@two_hours_ago, @one_hour_ago)
     finder.options[:from].should == @two_hours_ago
     finder.options[:till].should == @one_hour_ago
-    
+
     finder = Redistat::Finder.from(@two_hours_ago)
     finder.options[:from].should == @two_hours_ago
     finder.from.should == @two_hours_ago
-    
+
     finder = Redistat::Finder.till(@one_hour_ago)
     finder.options[:till].should == @one_hour_ago
     finder.till.should == @one_hour_ago
-    
+
     finder = Redistat::Finder.depth(:hour)
     finder.options[:depth].should == :hour
     finder.depth.should == :hour
-    
+
     finder = Redistat::Finder.interval(true)
     finder.options[:interval].should be_true
     finder.interval.should be_true
@@ -56,24 +56,24 @@ describe Redistat::Finder do
     finder.options[:interval].should be_false
     finder.interval.should be_false
   end
-  
+
   it "should fetch stats properly" do
     first_stat, last_stat = create_example_stats
-    
+
     stats = Redistat::Finder.find({:from => first_stat, :till => last_stat, :scope => @scope, :label => @label, :depth => :hour})
     stats.from.should  == first_stat
     stats.till.should  == last_stat
     stats.depth.should == :hour
-    
+
     stats.total.should == { "views" => 12, "visitors" => 8 }
     stats.total.from.should == first_stat
     stats.total.till.should == last_stat
     stats.first.should == stats.total
   end
-  
+
   it "should fetch data per unit when interval option is specified" do
     first_stat, last_stat = create_example_stats
-    
+
     stats = Redistat::Finder.find(:from => first_stat, :till => last_stat, :scope => @scope, :label => @label, :depth => :hour, :interval => :hour)
     stats.from.should == first_stat
     stats.till.should == last_stat
@@ -89,22 +89,22 @@ describe Redistat::Finder do
     stats[4].should == {}
     stats[4].date.should == Time.parse("2010-05-14 16:00")
   end
-  
+
   it "should return empty hash when attempting to fetch non-existent results" do
     stats = Redistat::Finder.find({:from => 3.hours.ago, :till => 2.hours.from_now, :scope => @scope, :label => @label, :depth => :hour})
     stats.total.should == {}
   end
-  
+
   it "should throw error on invalid options" do
     lambda { Redistat::Finder.find(:from => 3.hours.ago) }.should raise_error(Redistat::InvalidOptions)
   end
-  
+
   describe "Grouping" do
     before(:each) do
       @options = {:scope => "PageViews", :label => "message/public", :from => @two_hours_ago, :till => @one_hour_ago, :depth => :hour, :interval => :hour}
       @finder = Redistat::Finder.new(@options)
     end
-    
+
     it "should return parent finder" do
       @finder.instance_variable_get("@parent").should be_nil
       @finder.parent.should be_a(Redistat::Finder)
@@ -116,7 +116,7 @@ describe Redistat::Finder do
       @finder.parent.options[:label].should be_nil
       @finder.parent.parent.should be_nil
     end
-    
+
     it "should find children" do
       Redistat::Key.new("PageViews", "message/public/die").update_index
       Redistat::Key.new("PageViews", "message/public/live").update_index
@@ -130,25 +130,25 @@ describe Redistat::Finder do
       subs.should include('fester')
     end
   end
-  
+
   describe "Lazy-Loading" do
-    
+
     before(:each) do
       @first_stat, @last_stat = create_example_stats
 
       @finder = Redistat::Finder.new
       @finder.from(@first_stat).till(@last_stat).scope(@scope).label(@label).depth(:hour)
-      
+
       @match = [{}, {"visitors"=>"4", "views"=>"6"},
                     {"visitors"=>"2", "views"=>"3"},
                     {"visitors"=>"2", "views"=>"3"}, {}]
     end
-    
+
     it "should lazy-load" do
       @finder.instance_variable_get("@result").should be_nil
       stats = @finder.all
       @finder.instance_variable_get("@result").should_not be_nil
-      
+
       stats.should == @finder.find # find method directly fetches results
       stats.total.should == @finder.total
       stats.total.should == { "views" => 12, "visitors" => 8 }
@@ -163,35 +163,35 @@ describe Redistat::Finder do
       stats = @finder.all
       stats.total.should == { "views" => 6, "visitors" => 4 }
     end
-    
+
     it "should handle #map" do
       @finder.interval(:hour)
       @finder.map { |r| r }.should == @match
     end
-    
+
     it "should handle #each" do
       @finder.interval(:hour)
-      
+
       res = []
       @finder.each { |r| res << r }
       res.should == @match
     end
-    
+
     it "should handle #each_with_index" do
       @finder.interval(:hour)
-      
+
       res = {}
       match = {}
       @finder.each_with_index { |r, i| res[i] = r }
       @match.each_with_index { |r, i| match[i] = r }
       res.should == match
     end
-    
+
   end # "Lazy-Loading"
-  
-  
+
+
   # helper methods
-  
+
   def create_example_stats
     key = Redistat::Key.new(@scope, @label, (first = Time.parse("2010-05-14 13:43")))
     Redistat::Summary.send(:update_fields, key, @stats, :hour)
@@ -203,5 +203,5 @@ describe Redistat::Finder do
     Redistat::Summary.send(:update_fields, key, @stats, :hour)
     [first - 1.hour, last + 1.hour]
   end
-  
+
 end

data/spec/key_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Redistat::Key do
   include Redistat::Database
-  
+
   before(:each) do
     db.flushdb
     @scope = "PageViews"
@@ -11,7 +11,7 @@ describe Redistat::Key do
     @date = Time.now
     @key = Redistat::Key.new(@scope, @label, @date, {:depth => :hour})
   end
-  
+
   it "should initialize properly" do
     @key.scope.to_s.should == @scope
     @key.label.to_s.should == @label
@@ -20,7 +20,7 @@ describe Redistat::Key do
     @key.date.should be_instance_of(Redistat::Date)
     @key.date.to_time.to_s.should == @date.to_s
   end
-  
+
   it "should convert to string properly" do
     @key.to_s.should == "#{@scope}/#{@label}:#{@key.date.to_s(:hour)}"
     props = [:year, :month, :day, :hour, :min, :sec]
@@ -31,19 +31,19 @@ describe Redistat::Key do
     key = Redistat::Key.new(@scope, nil, @date, {:depth => :hour})
     key.to_s.should == "#{@scope}:#{key.date.to_s(:hour)}"
   end
-  
+
   it "should abide to hashed_label option" do
     @key = Redistat::Key.new(@scope, @label, @date, {:depth => :hour, :hashed_label => true})
     @key.to_s.should == "#{@scope}/#{@label_hash}:#{@key.date.to_s(:hour)}"
     @key = Redistat::Key.new(@scope, @label, @date, {:depth => :hour, :hashed_label => false})
     @key.to_s.should == "#{@scope}/#{@label}:#{@key.date.to_s(:hour)}"
   end
-  
+
   it "should have default depth option" do
     @key = Redistat::Key.new(@scope, @label, @date)
     @key.depth.should == :hour
   end
-  
+
   it "should allow changing attributes" do
     # scope
     @key.scope.to_s.should == @scope
@@ -64,13 +64,13 @@ describe Redistat::Key do
     @key.label.to_s.should == @label
     @key.label_hash == @label_hash
   end
-  
+
   describe "Grouping" do
     before(:each) do
       @label = "message/public/offensive"
       @key = Redistat::Key.new(@scope, @label, @date, {:depth => :hour})
     end
-    
+
     it "should create a group of keys from label group" do
       label = 'message/public/offensive'
       result = [ "message/public/offensive",
@@ -81,49 +81,49 @@ describe Redistat::Key do
 
       key.groups.map { |k| k.label.to_s }.should == result
     end
-    
+
     it "should know it's parent" do
       @key.parent.should be_a(Redistat::Key)
       @key.parent.label.to_s.should == 'message/public'
       Redistat::Key.new(@scope, 'hello', @date).parent.should be_nil
     end
-    
+
     it "should update label index and return children" do
       db.smembers("#{@scope}#{Redistat::LABEL_INDEX}#{@key.label.parent}").should == []
       @key.children.should have(0).items
-      
+
       @key.update_index                                                  # indexing 'message/publish/offensive'
       Redistat::Key.new("PageViews", "message/public/die").update_index  # indexing 'message/publish/die'
       Redistat::Key.new("PageViews", "message/public/live").update_index # indexing 'message/publish/live'
-      
+
       members = db.smembers("#{@scope}#{Redistat::LABEL_INDEX}#{@key.label.parent}") # checking 'message/public'
       members.should have(3).item
       members.should include('offensive')
       members.should include('live')
       members.should include('die')
-      
+
       key = @key.parent
       key.children.first.should be_a(Redistat::Key)
       key.children.should have(3).item
       key.children.map { |k| k.label.me }.should == members
-      
+
       members = db.smembers("#{@scope}#{Redistat::LABEL_INDEX}#{key.label.parent}") # checking 'message'
       members.should have(1).item
       members.should include('public')
-      
+
       key = key.parent
       key.children.should have(1).item
       key.children.map { |k| k.label.me }.should == members
-      
+
       members = db.smembers("#{@scope}#{Redistat::LABEL_INDEX}") # checking ''
       members.should have(1).item
       members.should include('message')
-      
+
       key.parent.should be_nil
       key = Redistat::Key.new("PageViews")
       key.children.should have(1).item
       key.children.map { |k| k.label.me }.should include('message')
     end
   end
-  
-end
+
+end

data/spec/label_spec.rb

@@ -2,29 +2,29 @@ require "spec_helper"
 
 describe Redistat::Label do
   include Redistat::Database
-  
+
   before(:each) do
     db.flushdb
     @name = "about_us"
     @label = Redistat::Label.new(@name)
   end
-  
+
   it "should initialize properly and SHA1 hash the label name" do
     @label.name.should == @name
     @label.hash.should == Digest::SHA1.hexdigest(@name)
   end
-  
+
   it "should store a label hash lookup key" do
     label = Redistat::Label.new(@name, {:hashed_label => true}).save
     label.saved?.should be_true
     db.hget(Redistat::KEY_LABELS, label.hash).should == @name
-    
+
     name = "contact_us"
     label = Redistat::Label.create(name, {:hashed_label => true})
     label.saved?.should be_true
     db.hget(Redistat::KEY_LABELS, label.hash).should == name
   end
-  
+
   it "should join labels" do
     include Redistat
     label = Label.join('email', 'message', 'public')
@@ -37,18 +37,18 @@ describe Redistat::Label do
     label.should be_a(Label)
     label.to_s.should == 'email/message/public'
   end
-  
+
   describe "Grouping" do
     before(:each) do
       @name = "message/public/offensive"
       @label = Redistat::Label.new(@name)
     end
-    
+
     it "should know it's parent label group" do
       @label.parent.to_s.should == 'message/public'
       Redistat::Label.new('hello').parent.should be_nil
     end
-    
+
     it "should separate label names into groups" do
       @label.name.should == @name
       @label.groups.map { |l| l.to_s }.should == [ "message/public/offensive",
@@ -67,5 +67,5 @@ describe Redistat::Label do
       @label.groups.map { |l| l.to_s }.should == [ "message" ]
     end
   end
-  
-end
+
+end

data/spec/model_helper.rb

@@ -2,29 +2,30 @@ require "redistat"
 
 class ModelHelper1
   include Redistat::Model
-  
-  
+
+
 end
 
 class ModelHelper2
   include Redistat::Model
-  
+
   depth :day
   store_event true
   hashed_label true
-  
+
 end
 
 class ModelHelper3
   include Redistat::Model
-  
+
   connect_to :port => 8379, :db => 14
-  
+
 end
 
 class ModelHelper4
   include Redistat::Model
-  
+
   scope "FancyHelper"
-  
-end
+  expire :hour => 24*3600
+
+end

data/spec/model_spec.rb

@@ -3,7 +3,7 @@ require "model_helper"
 
 describe Redistat::Model do
   include Redistat::Database
-  
+
   before(:each) do
     @time = Time.utc(2010, 8, 28, 12, 0, 0)
     ModelHelper1.redis.flushdb
@@ -11,12 +11,12 @@ describe Redistat::Model do
     ModelHelper3.redis.flushdb
     ModelHelper4.redis.flushdb
   end
-  
+
   it "should should name itself correctly" do
     ModelHelper1.send(:name).should == "ModelHelper1"
     ModelHelper2.send(:name).should == "ModelHelper2"
   end
-  
+
   it "should return a Finder" do
     two_hours_ago = 2.hours.ago
     one_hour_ago  = 1.hour.ago
@@ -27,18 +27,19 @@ describe Redistat::Model do
     finder.options[:from].should  == two_hours_ago
     finder.options[:till].should  == one_hour_ago
   end
-  
+
   it "should #find_event" do
     Redistat::Event.should_receive(:find).with('ModelHelper1', 1)
     ModelHelper1.find_event(1)
   end
-  
+
   it "should listen to model-defined options" do
     ModelHelper2.depth.should == :day
     ModelHelper2.store_event.should == true
     ModelHelper2.hashed_label.should == true
     ModelHelper2.scope.should be_nil
-    
+    ModelHelper2.expire.should be_nil
+
     ModelHelper1.depth.should == nil
     ModelHelper1.store_event.should == nil
     ModelHelper1.hashed_label.should == nil
@@ -54,134 +55,135 @@ describe Redistat::Model do
     ModelHelper1.depth.should == nil
     ModelHelper1.store_event.should == nil
     ModelHelper1.hashed_label.should == nil
-    
+
     ModelHelper4.scope.should == "FancyHelper"
     ModelHelper4.send(:name).should == "FancyHelper"
+    ModelHelper4.expire.should == {:hour => 24*3600}
   end
-  
+
   it "should store and fetch stats" do
     ModelHelper1.store("sheep.black", {:count => 6, :weight => 461}, @time.hours_ago(4))
     ModelHelper1.store("sheep.black", {:count => 2, :weight => 156}, @time)
-    
+
     stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(2), @time.hours_since(1))
     stats.total["count"].should == 2
     stats.total["weight"].should == 156
     stats.first.should == stats.total
-    
+
     stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1))
     stats.total[:count].should == 8
     stats.total[:weight].should == 617
     stats.first.should == stats.total
-    
+
     ModelHelper1.store("sheep.white", {:count => 5, :weight => 393}, @time.hours_ago(4))
     ModelHelper1.store("sheep.white", {:count => 4, :weight => 316}, @time)
-    
+
     stats = ModelHelper1.fetch("sheep.white", @time.hours_ago(2), @time.hours_since(1))
     stats.total[:count].should == 4
     stats.total[:weight].should == 316
     stats.first.should == stats.total
-    
+
     stats = ModelHelper1.fetch("sheep.white", @time.hours_ago(5), @time.hours_since(1))
     stats.total[:count].should == 9
     stats.total[:weight].should == 709
     stats.first.should == stats.total
   end
-  
+
   it "should store and fetch grouping enabled stats" do
     ModelHelper1.store("sheep/black", {:count => 6, :weight => 461}, @time.hours_ago(4))
     ModelHelper1.store("sheep/black", {:count => 2, :weight => 156}, @time)
     ModelHelper1.store("sheep/white", {:count => 5, :weight => 393}, @time.hours_ago(4))
     ModelHelper1.store("sheep/white", {:count => 4, :weight => 316}, @time)
-    
+
     stats = ModelHelper1.fetch("sheep/black", @time.hours_ago(2), @time.hours_since(1))
     stats.total["count"].should == 2
     stats.total["weight"].should == 156
     stats.first.should == stats.total
-    
+
     stats = ModelHelper1.fetch("sheep/black", @time.hours_ago(5), @time.hours_since(1))
     stats.total[:count].should == 8
     stats.total[:weight].should == 617
     stats.first.should == stats.total
-    
+
     stats = ModelHelper1.fetch("sheep/white", @time.hours_ago(2), @time.hours_since(1))
     stats.total[:count].should == 4
     stats.total[:weight].should == 316
     stats.first.should == stats.total
-    
+
     stats = ModelHelper1.fetch("sheep/white", @time.hours_ago(5), @time.hours_since(1))
     stats.total[:count].should == 9
     stats.total[:weight].should == 709
     stats.first.should == stats.total
-    
+
     stats = ModelHelper1.fetch("sheep", @time.hours_ago(2), @time.hours_since(1))
     stats.total[:count].should == 6
     stats.total[:weight].should == 472
     stats.first.should == stats.total
-    
+
     stats = ModelHelper1.fetch("sheep", @time.hours_ago(5), @time.hours_since(1))
     stats.total[:count].should == 17
     stats.total[:weight].should == 1326
     stats.first.should == stats.total
   end
-  
+
   it "should connect to different Redis servers on a per-model basis" do
     ModelHelper3.redis.client.db.should == 14
-    
+
     ModelHelper3.store("sheep.black", {:count => 6, :weight => 461}, @time.hours_ago(4), :label_indexing => false)
     ModelHelper3.store("sheep.black", {:count => 2, :weight => 156}, @time, :label_indexing => false)
-    
+
     db.keys("*").should be_empty
     ModelHelper1.redis.keys("*").should be_empty
     db("ModelHelper3").keys("*").should have(5).items
     ModelHelper3.redis.keys("*").should have(5).items
-    
+
     stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(2), @time.hours_since(1), :label_indexing => false)
     stats.total["count"].should == 2
     stats.total["weight"].should == 156
     stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
     stats.total[:count].should == 8
     stats.total[:weight].should == 617
-    
+
     ModelHelper3.connect_to(:port => 8379, :db => 13)
     ModelHelper3.redis.client.db.should == 13
-    
+
     stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
     stats.total.should == {}
-    
+
     ModelHelper3.connect_to(:port => 8379, :db => 14)
     ModelHelper3.redis.client.db.should == 14
-    
+
     stats = ModelHelper3.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1), :label_indexing => false)
     stats.total[:count].should == 8
     stats.total[:weight].should == 617
   end
-  
+
   describe "Write Buffer" do
     before(:each) do
       Redistat.buffer_size = 20
     end
-    
+
     after(:each) do
       Redistat.buffer_size = 0
     end
-    
+
     it "should buffer calls in memory before committing to Redis" do
       14.times do
         ModelHelper1.store("sheep.black", {:count => 1, :weight => 461}, @time.hours_ago(4))
       end
       ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).total.should == {}
-      
+
       5.times do
         ModelHelper1.store("sheep.black", {:count => 1, :weight => 156}, @time)
       end
       ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).total.should == {}
-      
+
       ModelHelper1.store("sheep.black", {:count => 1, :weight => 156}, @time)
       stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1))
       stats.total["count"].should == 20
       stats.total["weight"].should == 7390
     end
-    
+
     it "should force flush buffer when #flush(true) is called" do
       ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).total.should == {}
       14.times do
@@ -189,16 +191,11 @@ describe Redistat::Model do
       end
       ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1)).total.should == {}
       Redistat.buffer.flush(true)
-      
+
       stats = ModelHelper1.fetch("sheep.black", @time.hours_ago(5), @time.hours_since(1))
       stats.total["count"].should == 14
       stats.total["weight"].should == 6454
     end
   end
-  
-end
-
-
-
-
 
+end