request-log-analyzer 1.1.2 → 1.2.0

data/spec/{file_format_spec.rb → unit/file_format/file_format_api_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::FileFormat, :format_definition do
   
@@ -63,7 +63,18 @@ end
 
 describe RequestLogAnalyzer::FileFormat, :load do
 
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
+
+  it "should return an instance of a FileFormat class" do
+    @file_format = RequestLogAnalyzer::FileFormat.load(TestingFormat)
+    @file_format.should be_kind_of(TestingFormat)
+  end
+
+
+  it "should return itself if it already is a FileFormat::Base instance" do
+    @file_format = RequestLogAnalyzer::FileFormat.load(testing_format)
+    @file_format.should be_kind_of(TestingFormat)
+  end
 
   it "should load a predefined file format from the /file_format dir" do
     @file_format = RequestLogAnalyzer::FileFormat.load(:rails)
@@ -71,8 +82,9 @@ describe RequestLogAnalyzer::FileFormat, :load do
   end
   
   it "should load a provided format file" do
-    @file_format = RequestLogAnalyzer::FileFormat.load(format_file(:spec_format))
-    @file_format.should be_kind_of(SpecFormat)
+    format_filename = File.dirname(__FILE__) + '/../../lib/testing_format.rb'
+    @file_format = RequestLogAnalyzer::FileFormat.load(format_filename)
+    @file_format.should be_kind_of(TestingFormat)
   end
   
 end

data/spec/{line_definition_spec.rb → unit/file_format/line_definition_spec.rb}

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::LineDefinition, :parsing do
   
@@ -35,11 +35,11 @@ end
 
 describe RequestLogAnalyzer::LineDefinition, :converting do
 
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @file_format = spec_format
-    @request = @file_format.create_request
+    @file_format = testing_format
+    @request = @file_format.request
   end
   
   it "should convert captures to a hash of converted values" do
@@ -48,10 +48,17 @@ describe RequestLogAnalyzer::LineDefinition, :converting do
   end
 
   it "should convert captures to a hash" do
-    hash = @file_format.line_definitions[:test].convert_captured_values(["willem", nil], @request)
-    hash[:test_capture].should == 'Testing is willem'
+    hash = @file_format.line_definitions[:test].convert_captured_values(["great", nil], @request)
+    hash[:test_capture].should == 'Testing is great'
     hash[:duration].should be_nil
   end
+  
+  it "should merge a hash capture into the line hash" do
+    hash = @file_format.line_definitions[:eval].convert_captured_values(["{ 'greating' => 'hello', 'what' => 'world'}"], @request)
+    hash[:evaluated].should == { :greating => "hello", :what => "world"}
+    hash[:greating].should == 'hello'
+    hash[:what].should == 'world'    
+  end  
 
   
 end

data/spec/{merb_format_spec.rb → unit/file_format/merb_format_spec.rb}

@@ -1,7 +1,7 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, :merb do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
     @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:merb))

data/spec/{rails_format_spec.rb → unit/file_format/rails_format_spec.rb}

@@ -1,10 +1,11 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, "Rails" do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:rails))
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(
+          RequestLogAnalyzer::FileFormat.load(:rails), :parse_strategy => 'cautious')
   end
   
   it "should have a valid language definitions" do
@@ -66,27 +67,34 @@ describe RequestLogAnalyzer::Source::LogParser, "Rails" do
   end
   
   it "should detect unordered requests in the logs" do
+    # No valid request should be found in cautious mode
     @log_parser.should_not_receive(:handle_request)
     # the first Processing-line will not give a warning, but the next one will
     @log_parser.should_receive(:warn).with(:unclosed_request, anything).once
-    # Both Completed ;ines will give a warning
+    # Both Completed lines will give a warning
     @log_parser.should_receive(:warn).with(:no_current_request, anything).twice
+    
     @log_parser.parse_file(log_fixture(:rails_unordered))
   end  
 end
 
-describe "RequestLogAnalyzer::FileFormat::RailsDevelopment - Rails with development details" do
-  include RequestLogAnalyzerSpecHelper
+describe RequestLogAnalyzer::FileFormat::RailsDevelopment, "Rails with development details" do
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
     @file_format = RequestLogAnalyzer::FileFormat.load(:rails_development)
-    @request = @file_format.create_request
+    @request = @file_format.request
   end
   
   it "should have a valid language definitions" do
     @file_format.should be_valid
   end
   
+  it "should have a different line definer than Rails" do
+    rails = RequestLogAnalyzer::FileFormat.load(:rails)
+    rails.class.line_definer.should_not == @file_format.class.line_definer
+  end
+  
   it "should parse a rendered line" do
     info = @file_format.line_definitions[:rendered].match_for("Rendered layouts/_footer (2.9ms)", @request)
     info[:render_file].should == 'layouts/_footer'
@@ -97,25 +105,25 @@ describe "RequestLogAnalyzer::FileFormat::RailsDevelopment - Rails with developm
     info = @file_format.line_definitions[:query_executed].match_for(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ", @request)
     info[:query_class].should == 'User'
     info[:query_duration].should == 0.0004
-    info[:query_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 18205844)'
+    info[:query_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'
   end  
   
   it "should parse a query executed line without colors" do
     info = @file_format.line_definitions[:query_executed].match_for(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ", @request)
     info[:query_class].should == 'User'
     info[:query_duration].should == 0.0004
-    info[:query_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 18205844)'    
+    info[:query_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'
   end  
   
   it "should parse a cached query line with colors" do
     info = @file_format.line_definitions[:query_cached].match_for(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ', @request)
     info[:cached_duration].should == 0.0
-    info[:cached_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 0)'   
+    info[:cached_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'   
   end
   
   it "should parse a cached query line without colors" do
     info = @file_format.line_definitions[:query_cached].match_for(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ', @request)
     info[:cached_duration].should == 0.0
-    info[:cached_sql].should == 'SELECT * FROM `users` WHERE (`users`.`id` = 0)'   
+    info[:cached_sql].should == 'SELECT * FROM users WHERE (users.id = :int)'  
   end  
 end

data/spec/unit/filter/anonymize_filter_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Anonymize, 'anonymize request' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Anonymize.new(testing_format)
+  end
+  
+  it "should anonimize ip" do
+    @filter.filter(request(:ip => '123.123.123.123'))[:ip].should_not eql('123.123.123.123')
+  end
+
+  it "should anonimize url" do
+    @filter.filter(request(:url => 'https://test.mysite.com/employees'))[:url].should eql('http://example.com/employees')
+  end
+
+  it "should fuzz durations" do
+    @filter.filter(request(:duration => 100))[:duration].should_not eql(100)
+  end
+  
+end

data/spec/unit/filter/field_filter_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Field, 'string in accept mode' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :select)
+  end
+  
+  it "should reject a request if the field value does not match" do
+    @filter.filter(request(:test => 'not test')).should be_nil
+  end
+  
+  it "should reject a request if the field name does not match" do
+    @filter.filter(request(:testing => 'test')).should be_nil
+  end
+
+  it "should accept a request if the both name and value match" do
+    @filter.filter(request(:test => 'test')).should_not be_nil
+  end 
+    
+  it "should accept a request if the value is not the first value" do
+    @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should_not be_nil
+  end  
+end
+
+describe RequestLogAnalyzer::Filter::Field, 'string in reject mode' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :reject)
+  end
+  
+  it "should accept a request if the field value does not match" do
+    @filter.filter(request(:test => 'not test')).should_not be_nil
+  end
+  
+  it "should accept a request if the field name does not match" do
+    @filter.filter(request(:testing => 'test')).should_not be_nil
+  end
+
+  it "should reject a request if the both name and value match" do
+    @filter.filter(request(:test => 'test')).should be_nil
+  end 
+    
+  it "should reject a request if the value is not the first value" do
+    @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should be_nil
+  end  
+end
+
+describe RequestLogAnalyzer::Filter::Field, 'regexp in accept mode' do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => '/test/', :mode => :select)
+  end
+  
+  it "should reject a request if the field value does not match" do
+    @filter.filter(request(:test => 'a working test')).should_not be_nil
+  end
+  
+  it "should reject a request if the field name does not match" do
+    @filter.filter(request(:testing => 'test')).should be_nil
+  end
+
+  it "should accept a request if the value is not the first value" do
+    @filter.filter(request([{:test => 'ignore'}, {:test => 'testing 123'}])).should_not be_nil
+  end  
+end

data/spec/unit/filter/timespan_filter_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Timespan, 'both before and after'  do
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'), :before => DateTime.parse('2009-02-02'))
+  end
+  
+  it "should reject a request before the after date" do
+    @filter.filter(request(:timestamp => 20081212000000)).should be_nil
+  end
+  
+  it "should reject a request after the before date" do
+    @filter.filter(request(:timestamp => 20090303000000)).should be_nil
+  end
+  
+  it "should accept a request between the after and before dates" do
+    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  end
+end
+
+describe RequestLogAnalyzer::Filter::Timespan, 'only before'  do
+  include RequestLogAnalyzer::Spec::Helper
+  
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :before => DateTime.parse('2009-02-02'))    
+  end
+  
+  it "should accept a request before the after date" do
+    @filter.filter(request(:timestamp => 20081212000000)).should_not be_nil
+  end
+  
+  it "should reject a request after the before date" do
+    @filter.filter(request(:timestamp => 20090303000000)).should be_nil
+  end
+  
+  it "should accept a request between the after and before dates" do
+    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  end   
+end
+
+describe RequestLogAnalyzer::Filter::Timespan, 'only after'  do  
+  include RequestLogAnalyzer::Spec::Helper 
+  
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'))
+  end
+  
+  it "should reject a request before the after date" do
+    @filter.filter(request(:timestamp => 20081212000000)).should be_nil
+  end
+  
+  it "should accept a request after the before date" do
+    @filter.filter(request(:timestamp => 20090303000000)).should_not be_nil
+  end
+  
+  it "should accept a request between the after and before dates" do
+    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  end  
+end

data/spec/{log_parser_spec.rb → unit/source/log_parser_spec.rb}

@@ -1,10 +1,10 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Source::LogParser, :requests do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(spec_format)
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)
   end
   
   it "should have multiple line definitions" do
@@ -16,13 +16,13 @@ describe RequestLogAnalyzer::Source::LogParser, :requests do
   end
   
   it "should parse more lines than requests" do
-    @log_parser.should_receive(:handle_request).with(an_instance_of(SpecFormat::Request)).twice
+    @log_parser.should_receive(:handle_request).with(an_instance_of(TestingFormat::Request)).twice
     @log_parser.parse_file(log_fixture(:test_language_combined))
     @log_parser.parsed_lines.should > 2    
   end
   
   it "should parse requests spanned over multiple files" do
-    @log_parser.should_receive(:handle_request).with(an_instance_of(SpecFormat::Request)).once
+    @log_parser.should_receive(:handle_request).with(an_instance_of(TestingFormat::Request)).once
     @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)])
   end
   
@@ -47,10 +47,10 @@ describe RequestLogAnalyzer::Source::LogParser, :requests do
 end
 
 describe RequestLogAnalyzer::Source::LogParser, :warnings do
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(spec_format)
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format, :parse_strategy => 'cautious')
   end
     
   it "should warn about teaser matching problems" do

data/spec/{request_spec.rb → unit/source/request_spec.rb}

@@ -1,11 +1,11 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::Request, :incomplete_request do
   
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @incomplete_request = spec_format.create_request
+    @incomplete_request = testing_format.request
     @incomplete_request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
   end
   
@@ -34,10 +34,10 @@ end
 
 describe RequestLogAnalyzer::Request, :completed_request do
   
-  include RequestLogAnalyzerSpecHelper
+  include RequestLogAnalyzer::Spec::Helper
   
   before(:each) do
-    @completed_request = spec_format.create_request
+    @completed_request = testing_format.request
     @completed_request << { :line_type => :first, :lineno =>  1, :name => 'first line!' }    
     @completed_request << { :line_type => :test,  :lineno =>  4, :test_capture => 'testing' }        
     @completed_request << { :line_type => :test,  :lineno =>  7, :test_capture => 'testing some more' }            

data/spec/unit/tracker/duration_tracker_spec.rb

@@ -0,0 +1,99 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Tracker::Duration, 'static category' do
+  
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @tracker = RequestLogAnalyzer::Tracker::Duration.new(:duration => :duration, :category => :category)
+    @tracker.prepare
+  end
+
+  it "should register a request in the right category" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.categories.keys.should include('a')
+  end
+ 
+  it "should register a hit in the right category" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.update(request(:category => 'b', :duration => 0.3))
+    @tracker.update(request(:category => 'b', :duration => 0.4))
+    
+    @tracker.hits('a').should == 1
+    @tracker.hits('b').should == 2
+  end
+  
+  it "should sum the durations of the same category as cumulative duration" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.update(request(:category => 'b', :duration => 0.3))
+    @tracker.update(request(:category => 'b', :duration => 0.4))      
+    
+    @tracker.cumulative_duration('a').should == 0.2
+    @tracker.cumulative_duration('b').should == 0.7
+  end
+  
+  it "should calculate the average duration correctly" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.update(request(:category => 'b', :duration => 0.3))
+    @tracker.update(request(:category => 'b', :duration => 0.4))      
+    
+    @tracker.average_duration('a').should == 0.2
+    @tracker.average_duration('b').should == 0.35
+  end
+  
+  it "should set min and max duration correctly" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.update(request(:category => 'b', :duration => 0.3))
+    @tracker.update(request(:category => 'b', :duration => 0.4))      
+    
+    @tracker.min_duration('b').should == 0.3
+    @tracker.max_duration('b').should == 0.4
+  end  
+  
+end
+
+describe RequestLogAnalyzer::Tracker::Duration, 'dynamic category' do
+  
+  include RequestLogAnalyzer::Spec::Helper
+  
+  before(:each) do
+    @categorizer = Proc.new { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
+    @tracker = RequestLogAnalyzer::Tracker::Duration.new(:duration => :duration, :category => @categorizer)
+    @tracker.prepare
+  end
+  
+  it "should use the categorizer to determine the right category" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.update(request(:category => 'b', :duration => 0.3))
+    @tracker.update(request(:category => 'b', :duration => 0.4)) 
+    
+    @tracker.cumulative_duration('fast').should == 0.2
+    @tracker.cumulative_duration('slow').should == 0.7     
+  end
+  
+end
+
+describe RequestLogAnalyzer::Tracker::Duration, 'reporting' do
+ 
+  include RequestLogAnalyzer::Spec::Helper
+ 
+  before(:each) do
+    @tracker = RequestLogAnalyzer::Tracker::Duration.new(:category => :category, :duration => :duration)
+    @tracker.prepare
+  end
+  
+  it "should generate a report without errors when one category is present" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+
+  it "should generate a report without errors when no category is present" do
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+
+  it "should generate a report without errors when multiple categories are present" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.update(request(:category => 'b', :duration => 0.2))    
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+end

data/spec/unit/tracker/frequency_tracker_spec.rb

@@ -0,0 +1,83 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Tracker::Frequency, 'static category' do
+  
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+    @tracker.prepare
+  end
+  
+  
+  it "should register a request in the right category" do
+    @tracker.update(request(:category => 'a', :blah => 0.2))
+    @tracker.frequencies.keys.should include('a')
+  end
+  
+  it "should register a request in the right category" do
+    @tracker.update(request(:category => 'a', :blah => 0.2))
+    @tracker.update(request(:category => 'b', :blah => 0.2))
+    @tracker.update(request(:category => 'b', :blah => 0.2))
+    
+    @tracker.frequency('a').should == 1
+    @tracker.frequency('b').should == 2
+    @tracker.overall_frequency.should == 3
+  end
+
+  it "should sort correctly by frequency" do
+    @tracker.update(request(:category => 'a', :blah => 0.2))
+    @tracker.update(request(:category => 'b', :blah => 0.2))
+    @tracker.update(request(:category => 'b', :blah => 0.2))
+
+    @tracker.sorted_by_frequency.should == [['b', 2], ['a', 1]]
+  end
+end
+
+describe RequestLogAnalyzer::Tracker::Frequency, 'dynamic category' do
+  
+  include RequestLogAnalyzer::Spec::Helper
+  
+  before(:each) do
+    @categorizer = Proc.new { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
+    @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => @categorizer)
+    @tracker.prepare
+  end
+  
+  it "should use the categorizer to determine the right category" do
+    @tracker.update(request(:category => 'a', :duration => 0.2))
+    @tracker.update(request(:category => 'b', :duration => 0.3))
+    @tracker.update(request(:category => 'b', :duration => 0.4)) 
+    
+    @tracker.frequency('fast').should == 1
+    @tracker.frequency('slow').should == 2
+    @tracker.frequency('moderate').should == 0
+  end
+  
+end
+
+
+describe RequestLogAnalyzer::Tracker::Frequency, 'reporting' do
+ 
+  include RequestLogAnalyzer::Spec::Helper
+ 
+  before(:each) do
+    @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+    @tracker.prepare
+  end
+  
+  it "should generate a report without errors when one category is present" do
+    @tracker.update(request(:category => 'a', :blah => 0.2))
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+
+  it "should generate a report without errors when no category is present" do
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+
+  it "should generate a report without errors when multiple categories are present" do
+    @tracker.update(request(:category => 'a', :blah => 0.2))
+    @tracker.update(request(:category => 'b', :blah => 0.2))    
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+end

data/spec/unit/tracker/hourly_spread_spec.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Tracker::HourlySpread do
+
+  include RequestLogAnalyzer::Spec::Helper
+
+  before(:each) do
+    @tracker = RequestLogAnalyzer::Tracker::HourlySpread.new
+    @tracker.prepare
+  end
+
+  it "should store timestamps correctly" do
+    @tracker.update(request(:timestamp => 20090102000000))
+    @tracker.update(request(:timestamp => 20090101000000))    
+    @tracker.update(request(:timestamp => 20090103000000))        
+    
+    @tracker.request_time_graph[0].should eql(3)
+  end
+
+  it "should count the number of timestamps correctly" do
+    @tracker.update(request(:timestamp => 20090102000000))
+    @tracker.update(request(:timestamp => 20090101000000))    
+    @tracker.update(request(:timestamp => 20090103000000))        
+    @tracker.update(request(:timestamp => 20090103010000))        
+    
+    @tracker.total_requests.should eql(4)
+  end
+
+  it "should set the first request timestamp correctly" do
+    @tracker.update(request(:timestamp => 20090102000000))
+    @tracker.update(request(:timestamp => 20090101000000))    
+    @tracker.update(request(:timestamp => 20090103000000))        
+    
+    @tracker.first_timestamp.should == DateTime.parse('Januari 1, 2009 00:00:00')
+  end
+
+  it "should set the last request timestamp correctly" do
+    @tracker.update(request(:timestamp => 20090102000000))
+    @tracker.update(request(:timestamp => 20090101000000))    
+    @tracker.update(request(:timestamp => 20090103000000))        
+
+    @tracker.last_timestamp.should == DateTime.parse('Januari 3, 2009 00:00:00')
+  end
+
+  it "should return the correct timespan in days when multiple requests are given" do
+    @tracker.update(request(:timestamp => 20090102000000))
+    @tracker.update(request(:timestamp => 20090101000000))    
+    @tracker.update(request(:timestamp => 20090103000000))  
+    
+    @tracker.timespan.should == 2          
+  end
+
+end
+
+describe RequestLogAnalyzer::Tracker::HourlySpread, 'reporting' do
+ 
+  include RequestLogAnalyzer::Spec::Helper
+ 
+  before(:each) do
+    @tracker = RequestLogAnalyzer::Tracker::HourlySpread.new
+    @tracker.prepare
+  end
+
+  it "should generate a report without errors when no request was tracked" do
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+
+  it "should generate a report without errors when multiple requests were tracked" do
+    @tracker.update(request(:timestamp => 20090102000000))
+    @tracker.update(request(:timestamp => 20090101000000))    
+    @tracker.update(request(:timestamp => 20090103000000))        
+    @tracker.update(request(:timestamp => 20090103010000))
+    lambda { @tracker.report(mock_output) }.should_not raise_error
+  end
+end