sir_tracks_alot 0.4.0 → 0.6.2

data/spec/activity_spec.rb

@@ -15,7 +15,7 @@ describe SirTracksAlot::Activity do
     it "should store valid activities" do
       @activity.should be_valid
     end
-
+  
     it "should not store invalid activities" do
       activity = SirTracksAlot::Activity.create({})
       activity.should_not be_valid
@@ -46,10 +46,10 @@ describe SirTracksAlot::Activity do
       SirTracksAlot::Activity.all.size.should == 8
     end        
     
-    it "should purge counted" do
+    it "should purge counted, not touching first 500 (by default)" do
       SirTracksAlot::Activity.all.each{|a| a.counted!}
-      SirTracksAlot::Activity.purge!
-      SirTracksAlot::Activity.all.size.should == 0
+      SirTracksAlot::Activity.purge!()
+      SirTracksAlot::Activity.all.size.should == 8
     end
     
     it "should purge counted by range" do
@@ -68,15 +68,15 @@ describe SirTracksAlot::Activity do
     it "should find activities matching attribute regex" do
       SirTracksAlot::Activity.filter(:owner => 'owner', :target => /categories/).size.should == 1
     end
-
+  
     it "should find activities matching attribute string" do
       SirTracksAlot::Activity.filter(:owner => 'owner', :category => 'category').size.should == 1
     end
-
+  
     it "should find activities matching attribute string and attribute regex" do
       SirTracksAlot::Activity.filter(:owner => 'owner', :category => 'category', :target => /categories/).size.should == 1
     end
-
+  
     it "should not find activities matching attribute string but not attribute regex" do
       SirTracksAlot::Activity.filter(:owner => 'owner', :category => 'category', :target => /not_there/).size.should == 0
     end
@@ -91,8 +91,12 @@ describe SirTracksAlot::Activity do
       @activities.each{|a| SirTracksAlot.record(a)}
     end
     
+    it "should filter by members which are regex's" do 
+      # SirTracksAlot::Activity.filter(:owner => 'owner', :target => [/categories/, /\/categories\//]).size.should == 3
+    end    
+
     it "should filter by members of one array" do
-      SirTracksAlot::Activity.filter(:owner => 'owner', :target => ['/categories/item1', '/categories/item2']).size.should == 3
+      SirTracksAlot::Activity.filter(:owner => 'owner', :target => ['/categories/item1', '/categories/item2']).size.should == 3 
     end    
     
     it "should filter by combinations of arrays" do
@@ -115,53 +119,8 @@ describe SirTracksAlot::Activity do
     
     it "should purge counted by range, sorting to most recent by last event" do
       SirTracksAlot::Activity.recent({:owner => 'owner'}, :start => 1).first.last_event.should == '1279709941'
-    end            
-    
-  end
-  
-  context 'when counting' do
-    before do 
-      @mock_activity = mock(SirTracksAlot::Activity, :visits => 1, :views => 2)
-      SirTracksAlot::Activity.stub!(:find => [@mock_activity])
-    end
-    
-    # it "should look for activities using find options" do
-    #   SirTracksAlot::Activity.should_receive(:find).with(:owner => 'owner').and_return([@mock_activity])
-    #   SirTracksAlot::Activity.count(:views, :owner => 'owner')
-    # end
-    # 
-    # it "should look for views when counting views" do
-    #   @mock_activity.should_receive(:views).once.and_return(1)
-    #   SirTracksAlot::Activity.count(:views, :owner => 'owner')
-    # end    
-    # 
-    # it "should not look for views when counting visits" do
-    #   @mock_activity.should_receive(:views).never
-    #   SirTracksAlot::Activity.count(:visits, :owner => 'owner')
-    # end
-    # 
-    # it "should return views and visits" do            
-    #   SirTracksAlot::Activity.count([:visits, :views], :owner => 'owner').should == [1,2]
-    # end
-    # 
-    # it "should return visits" do    
-    #   SirTracksAlot::Activity.count([:visits], :owner => 'owner').should == 1
-    # end
-    # 
-    # it "should ignore empty only" do
-    #   SirTracksAlot::Activity.count([:visits], :owner => 'owner', :only => {}).should == 1      
-    # end
-    # 
-    # it "should filter by category" do
-    #   @mock_activity.should_receive(:category).once.and_return('category')
-    #   SirTracksAlot::Activity.count([:visits], :owner => 'owner', :category => /category/)
-    # end
-    # 
-    # it "should filter by category and match returning correct count" do
-    #   @mock_activity.stub!(:category => 'category')
-    #   SirTracksAlot::Activity.count([:visits], :owner => 'owner', :category => /category/).should == 1      
-    # end
-  end
+    end                
+  end  
   
   context 'when counting views' do
     before do
@@ -177,11 +136,11 @@ describe SirTracksAlot::Activity do
     it "should return grouped counts" do
       @activity.views(:daily).should be_kind_of(Hash)      
     end
-
+  
     it "should return count as hash value" do
       @activity.views(:daily).values.should == [1]
     end
-
+  
     it "should return count key'd by date" do
       key = Time.at(@now).utc.strftime(SirTracksAlot::Activity::DATE_FORMATS[:daily])
       @activity.views(:daily).keys.should == [key]
@@ -203,13 +162,13 @@ describe SirTracksAlot::Activity do
       200.times{@activity.events << SirTracksAlot::Clock.now}
       @activity.visits.should == 1
     end
-
+  
     it "should count 2 visits separated by greater than default session duration as 2 visits" do
       @activity.events << SirTracksAlot::Clock.now 
       @activity.events << SirTracksAlot::Clock.now + 2000
       @activity.visits.should == 2
     end
-
+  
     it "should count 2 visits separated by greater than default session duration as 2, and a 3rd" do
       5.times{@activity.events << SirTracksAlot::Clock.now}
       @activity.events << SirTracksAlot::Clock.now + 2000

data/spec/count_spec.rb

@@ -4,14 +4,13 @@ describe SirTracksAlot::Count do
   include DataHelper
   
   before do 
-    RedisSpecHelper.reset
-    
+    RedisSpecHelper.reset    
     @set_activities.each{|a| SirTracksAlot.record(a)}
   end  
   
   context 'when creating' do
     before do 
-      @count_attributes = [{:owner => 'owner', :actor => '/users/user1', :target => '/categories/item1', :views => 1, :visits => 2, :date => '07/01/2010', :hour => 5}]
+      @count_attributes = [{:owner => 'owner', :actor => '/users/user1', :target => '/categories/item1'}]
     end
     
     it 'should create valid count' do
@@ -22,6 +21,10 @@ describe SirTracksAlot::Count do
       SirTracksAlot::Count.create(@count_attributes[0])
       SirTracksAlot::Count.create(@count_attributes[0]).should_not be_valid
     end
+    
+    it "should have a to_hash with attributes" do
+      SirTracksAlot::Count.create(@count_attributes[0]).to_hash.should == {:owner=>"owner", :target=>"/categories/item1", :id=>"1", :category=>nil, :actor=>"/users/user1"}
+    end
   end
   
   context 'when filtering' do
@@ -29,8 +32,16 @@ describe SirTracksAlot::Count do
       SirTracksAlot::Count.count(:owner => 'owner')
     end
     
+    it "should build rows" do
+      SirTracksAlot::Count.rows(:owner => 'owner').should == [["/categories", 1, 1], ["/categories/item1", 4, 4], ["/categories/item2", 1, 1], ["/other_categories", 2, 2], ["/other_categories/item", 2, 2]]
+    end    
+    
+    it "should build rows with custom title" do
+      SirTracksAlot::Count.rows({:owner => 'owner'}, 'title').should == [["title", 10, 10]]
+    end
+    
     it 'should filter by string attribute' do
-      SirTracksAlot::Count.filter(:owner => 'owner').size.should == 13
+      SirTracksAlot::Count.filter(:owner => 'owner').size.should == 5
     end
     
     it 'should filter by array of strings' do
@@ -39,7 +50,7 @@ describe SirTracksAlot::Count do
 
     it 'should include all targets when filtering just by ower' do
       SirTracksAlot::Count.filter(:owner => 'owner').collect{|c| c.target}.compact.sort.should == 
-        ["/categories", "/categories/item1", "/categories/item1", "/categories/item1", "/categories/item2", "/other_categories", "/other_categories/item"].sort
+        ["/categories", "/categories/item1", "/categories/item2", "/other_categories", "/other_categories/item"].sort
     end
 
     it 'should include only filtered targets' do
@@ -48,15 +59,39 @@ describe SirTracksAlot::Count do
     end    
   end
   
-  context 'when counting' do
+  context 'when summarizing' do
     before do
-      @counts = SirTracksAlot::Count.count(:owner => 'owner', :category => ['categories'], :action => ['view'])
+      SirTracksAlot::Count.count(:owner => 'owner')
     end
     
-    it "should count all activities for owner" do      
+     it "should summarize daily counts" do
+       SirTracksAlot::Count.summarize.should == {"2010/07/21"=>[2, 2], "2010/07/22"=>[8, 8]}
+     end
+     
+     it "should summarize daily counts with find options" do
+       SirTracksAlot::Count.summarize(:daily, :target => /.+/).should == {"2010/07/21"=>[2, 2], "2010/07/22"=>[8, 8]}
+     end
+     
+     it "should summarize hourly counts" do
+       SirTracksAlot::Count.summarize(:hourly).should == {"2010/07/21 17:00 UTC"=>[1, 1], "2010/07/21 20:00 UTC"=>[1, 1], "2010/07/22 01:00 UTC"=>[8, 8]}
+     end
+     
+  end
+  
+  context 'when totalling' do
+    before do 
       SirTracksAlot::Count.count(:owner => 'owner')
-      SirTracksAlot::Count.find(:owner => 'owner').size.should == 13 # one for each unique target, time combo
     end
+        
+    it "should total views and visits" do
+      SirTracksAlot::Count.total([:views, :visits], :owner => 'owner').should == [10,10]
+    end
+  end
+  
+  context 'when counting hourly' do
+    before do
+      @counts = SirTracksAlot::Count.count(:owner => 'owner') 
+    end    
 
     it "should set to counted all activities counted" do      
       SirTracksAlot::Count.count(:owner => 'owner')
@@ -65,24 +100,20 @@ describe SirTracksAlot::Count do
     
     it "should only count activities once" do
       SirTracksAlot::Count.count(:owner => 'owner', :category => ['categories'], :action => ['view']).should be_empty
+    end    
+
+    it "should include summaries" do
+      @counts[0].summaries.size.should == 3
+    end    
+  end
+  
+  context 'when counting daily' do
+    before do
+      @counts = SirTracksAlot::Count.count({:owner => 'owner'}, {}, :daily) 
     end
     
-    context 'views' do    
-      it "should include counts by hour" do
-        @counts[0].hour.should == '18'        
-      end
-    
-      it "should not include counts not requested" do
-        @counts.collect{|c| c.target}.should_not include("/other_categories") 
-      end
+    it "should count all activities for owner" do            
+      SirTracksAlot::Count.find(:owner => 'owner').size.should == 5 # one for each unique target
     end
-    
-    context 'visits' do
-      it 'should include counts by hour' do
-        # @counts[1].should == {"/categories"=>{"2010/07/21 18"=>1}, 
-        #   "/categories/item1"=>{"2010/07/21 18"=>2, "2010/07/21 10"=>1, "2010/07/21 13"=>1}, 
-        #   "/categories/item2"=>{"2010/07/21 18"=>1}}
-      end
-    end    
   end
 end

data/spec/queue/report_queue_spec.rb

@@ -16,17 +16,17 @@ describe SirTracksAlot::Queue::ReportQueue do
     before do
       @config = mock(SirTracksAlot::Queue::ReportConfig, :options => {}, :options= => true, :id => 1)
       @activities.each{|a| SirTracksAlot.record(a)}
-      SirTracksAlot::Queue::ReportQueue.push('owner', :actor_report, {})      
+      SirTracksAlot::Queue::ReportQueue.push('owner', :actor_report, 'report', {})      
     end
   
     it "should create a new queue" do      
       SirTracksAlot::Queue::ReportQueue.should_receive(:find_or_create).with(:name => SirTracksAlot::Queue::ReportQueue::QUEUE_NAME).and_return(@queue)
-      SirTracksAlot::Queue::ReportQueue.push('owner', 'report', {})
+      SirTracksAlot::Queue::ReportQueue.push('owner', 'report', 'report', {})
     end    
     
     it "should create report config" do
-      SirTracksAlot::Queue::ReportConfig.should_receive(:find_or_create).with(:owner => 'owner', :report => 'report').once.and_return(@config)
-      SirTracksAlot::Queue::ReportQueue.push('owner', 'report', {})
+      SirTracksAlot::Queue::ReportConfig.should_receive(:find_or_create).with(:owner => 'owner', :report => 'report', :name => 'report').once.and_return(@config)
+      SirTracksAlot::Queue::ReportQueue.push('owner', 'report', 'report', {})
     end    
   end
   
@@ -34,7 +34,7 @@ describe SirTracksAlot::Queue::ReportQueue do
     before do      
       @cache = mock(SirTracksAlot::Queue::ReportCache, :update => true)      
       @activities.each{|a| SirTracksAlot.record(a)}
-      SirTracksAlot::Queue::ReportQueue.push('owner', :target_report, {:category => ['categories', 'other_categories']})
+      SirTracksAlot::Queue::ReportQueue.push('owner', :target_report, 'report', {:filters => {:category => ['/categories', '/other_categories']}})
     end
     
     it "should find existing queue" do
@@ -43,7 +43,7 @@ describe SirTracksAlot::Queue::ReportQueue do
     end
     
     it "should create report cache" do
-      SirTracksAlot::Queue::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'target_report').and_return(@cache)
+      SirTracksAlot::Queue::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'target_report', :name => 'report').and_return(@cache)
       SirTracksAlot::Queue::ReportQueue.pop      
     end
     
@@ -52,8 +52,8 @@ describe SirTracksAlot::Queue::ReportQueue do
       SirTracksAlot::Queue::ReportQueue.pop
     end        
     
-    it "should build report HTML" do      
-      SirTracksAlot::Queue::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'target_report').and_return(@cache)
+    it "should build report HTML" do
+      SirTracksAlot::Queue::ReportCache.should_receive(:find_or_create).with(:owner => 'owner', :report => 'target_report', :name => 'report').and_return(@cache)
       @cache.should_receive(:update) do |options|
         options[:html].should have_tag('td.target', /\/categories\/item1/)
       end

data/spec/redis_spec_helper.rb

@@ -0,0 +1,8 @@
+class RedisSpecHelper
+  TEST_OPTIONS = {:db => 13}
+  
+  def self.reset   
+    Ohm.connect(TEST_OPTIONS)
+    Ohm.flush
+  end
+end

data/spec/reports/actor_report_spec.rb

@@ -10,24 +10,24 @@ describe SirTracksAlot::Reports::ActorReport do
   
   context 'building HTML' do
     before do 
-      @counts = SirTracksAlot::Count.count(OpenStruct.new(:owner => 'owner', :roots => ['categories']))
+      @counts = SirTracksAlot::Count.count(:owner => 'owner')
       @html = SirTracksAlot::Reports::ActorReport.render_html(:counts => @counts)
     end
     
-    it "include target row" do
-      @html.should have_tag('td.actor',/\/users\/user1/)
-    end
-
-    it "include count row" do      
-      @html.should have_tag('td.count', /1/)
-    end
-
-    it "include page views" do      
-      @html.should have_tag('td.page_views', /2/)
-    end
-  
-    it "should ignore other owners" do
-      @html.should_not have_tag('td.actor', '/users/user')
-    end
+    # it "include target row" do
+    #   @html.should have_tag('td.actor',/\/users\/user1/)
+    # end
+    # 
+    # it "include count row" do      
+    #   @html.should have_tag('td.count', /1/)
+    # end
+    # 
+    # it "include page views" do      
+    #   @html.should have_tag('td.page_views', /2/)
+    # end
+    #   
+    # it "should ignore other owners" do
+    #   @html.should_not have_tag('td.actor', '/users/user')
+    # end
   end
 end

data/spec/reports/filter_report_spec.rb

@@ -7,7 +7,7 @@ describe SirTracksAlot::Reports::FilterReport do
     RedisSpecHelper.reset
     @report_options = {:owner => 'owner'}
     @activities.each{|a| SirTracksAlot.record(a)}
-    SirTracksAlot::Count.count(OpenStruct.new(:owner => 'owner', :roots => ['categories']))
+    SirTracksAlot::Count.count(:owner => 'owner')
   end  
   
   context 'filtering things with only' do

data/spec/reports/report_spec.rb

@@ -0,0 +1,15 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe SirTracksAlot::Reports::Report do 
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    @activities.each{|a| SirTracksAlot.record(a)}
+    SirTracksAlot::Count.count(:owner => 'owner')
+  end    
+  
+  it "should " do
+    SirTracksAlot::Reports::Report.build_rows([{:owner => 'owner'}]).to_a.sort.should == [["/categories", 1, 1], ["/categories/item1", 1, 1], ["/categories/item2", 1, 1], ["/other_categories", 2, 2], ["/other_categories/item", 2, 2]].sort
+  end
+end

data/spec/reports/root_stem_report_spec.rb

@@ -6,7 +6,7 @@ describe SirTracksAlot::Reports::RootStemReport do
   before do 
     RedisSpecHelper.reset
     @activities.each{|a| SirTracksAlot.record(a)}
-    SirTracksAlot::Count.count(OpenStruct.new(:owner => 'owner', :roots => ['categories']))    
+    SirTracksAlot::Count.count(:owner => 'owner')    
   end  
   
   context 'building HTML with categories' do

data/spec/reports/simple_report_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe SirTracksAlot::Reports::SimpleReport do 
+  include DataHelper
+  
+  before do 
+    RedisSpecHelper.reset
+    @activities.each{|a| SirTracksAlot.record(a)}
+    SirTracksAlot::Count.count(:owner => 'owner')
+  end  
+  
+  context 'building HTML' do    
+    context 'using filters' do
+      it "should use regular expressions" do
+        SirTracksAlot::Reports::SimpleReport.render_html(:filters => [{:owner => 'owner', :target => /.+/}], 
+          :report_class => 'customClass').should_not have_tag('td.target', /\/users\/user1/)
+      end
+    end
+    
+    context 'for table reports' do
+      before do             
+        @html = SirTracksAlot::Reports::SimpleReport.render_html(:filters => [{:owner => 'owner'}], 
+          :report_class => 'customClass')
+      end
+    
+      it_should_behave_like 'all reports'
+      
+      it "should include target row" do    
+        @html.should have_tag('td.target', /\/categories\/item/)
+      end
+    
+      it "should have custom class" do    
+        @html.should have_tag('div.customClass')
+      end
+    
+      it "should include count row" do      
+        @html.should have_tag('td.count', /1/)
+      end
+    
+      it "should ignore other owners" do
+        @html.should_not have_tag('td.target', '/other_categories/item')
+      end
+    end
+    
+    context 'for table reports' do
+      before do             
+        @html = SirTracksAlot::Reports::SimpleReport.render_html(:filters => [{:owner => 'owner'}], 
+          :group => 'target',
+          :column_names => ['target', 'column 1', 'column 2'],
+          :report_class => 'customClass')
+      end
+    
+      it "should include target group" do
+        @html.should have_tag('h2', /\/categories\/item/)
+      end
+    
+      it "should include custom column names" do
+        @html.should have_tag('th.column_1')
+      end      
+      
+    end
+  end
+end