request-log-analyzer 1.1.1 → 1.2.0

data/spec/unit/controller/log_processor_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'request_log_analyzer/log_processor'
+
+describe RequestLogAnalyzer::LogProcessor, 'stripping log files' do
+
+  include RequestLogAnalyzer::Spec::Helper
+  
+  before(:each) do
+    @log_stripper = RequestLogAnalyzer::LogProcessor.new(testing_format, :strip, {})
+  end
+  
+  it "should remove a junk line" do
+    @log_stripper.strip_line("junk line\n").should be_empty
+  end
+
+  it "should keep a teaser line intact" do
+    @log_stripper.strip_line("processing 1234\n").should be_empty
+  end
+end

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
   
@@ -50,20 +50,31 @@ describe RequestLogAnalyzer::FileFormat, :format_definition do
       line.first_test :regexp => /test/, :captures => []
     end
     
+
     @second_file_format.format_definition do |line|
       line.second_test :regexp => /test/, :captures => []
     end
 
+    @first_file_format.line_definer.should_not eql(@second_file_format.line_definer)
     @first_file_format.new.should have(1).line_definitions    
-    @first_file_format.new.line_definitions[:first_test].should_not be_nil
-    @second_file_format.new.should have(1).line_definitions        
     @second_file_format.new.line_definitions[:second_test].should_not be_nil
   end  
 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/unit/file_format/line_definition_spec.rb

@@ -0,0 +1,64 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::LineDefinition, :parsing do
+  
+  before(:each) do
+    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
+      :teaser   => /Testing /,
+      :regexp   => /Testing (\w+), tries\: (\d+)/,
+      :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer }]
+    })
+  end
+  
+  it "should return false on an unmatching line" do
+    (@line_definition =~ "nonmatching").should be_false
+  end
+  
+  it "should return false when only the teaser matches" do
+    (@line_definition =~ "Testing LineDefinition").should be_false  
+  end
+  
+  it "should return a hash if the line matches" do
+    (@line_definition =~ "Testing LineDefinition, tries: 123").should be_kind_of(Hash)
+  end
+  
+  it "should return a hash with :captures set to an array" do
+    hash = @line_definition.matches("Testing LineDefinition, tries: 123")
+    hash[:captures][0].should == "LineDefinition"
+    hash[:captures][1].should == "123"
+  end
+  
+  it "should return a hash with :line_definition set" do
+    @line_definition.matches("Testing LineDefinition, tries: 123")[:line_definition].should == @line_definition
+  end
+end
+
+describe RequestLogAnalyzer::LineDefinition, :converting do
+
+  include RequestLogAnalyzer::Spec::Helper
+  
+  before(:each) do
+    @file_format = testing_format
+    @request = @file_format.request
+  end
+  
+  it "should convert captures to a hash of converted values" do
+    hash = @file_format.line_definitions[:first].convert_captured_values(["456"], @request)
+    hash[:request_no].should == 456
+  end
+
+  it "should convert captures to a hash" do
+    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))
@@ -29,7 +29,7 @@ describe RequestLogAnalyzer::Source::LogParser, :merb do
     @log_parser.parse_file(log_fixture(:merb)) { |found_request| request ||= found_request }
     
     request.should be_completed
-    #request[:timestamp].should == DateTime.parse('Fri Aug 29 11:10:23 +0200 2008') # FIX ME
+    request[:timestamp].should == 20080829111023 # 'Fri Aug 29 11:10:23 +0200 2008'
     request[:dispatch_time].should == 0.243424
     request[:after_filters_time].should == 6.9e-05
     request[:before_filters_time].should == 0.213213

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,55 +67,63 @@ 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.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].matches("Rendered layouts/_footer (2.9ms)")
+    info = @file_format.line_definitions[:rendered].match_for("Rendered layouts/_footer (2.9ms)", @request)
     info[:render_file].should == 'layouts/_footer'
     info[:render_duration].should == 0.0029
   end
   
   it "should parse a query executed line with colors" do
-    info = @file_format.line_definitions[:query_executed].matches(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ")
+    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].matches(" User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) ")
+    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].matches(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ')
+    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].matches(' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) ')
+    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,22 +16,21 @@ 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
   
   it "should parse all request values when spanned over multiple files" do
     @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)]) do |request|
-      request.lines.should have(4).items
-      
+      request.lines.should have(4).items      
       request[:request_no].should == 1
-      request[:test_capture].should == "amazing"      
+      request[:test_capture].should == "Testing is amazing" # Note the custom converter     
     end
   end  
   
@@ -48,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