request-log-analyzer 1.0.2 → 1.6.3

data/spec/unit/file_format/rails_format_spec.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::FileFormat::Rails do
+
+  describe '.create' do
+
+    context 'without providing a lines argument' do
+      before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails) }
+
+      it "should create a valid file format" do
+        @rails.should be_valid
+      end
+
+      it "should parse the production lines" do
+        production_rails = RequestLogAnalyzer::FileFormat.load(:rails, 'production')
+        @rails.line_definitions.should == production_rails.line_definitions
+      end
+    end
+
+    context 'using a comma separated list of lines as argument' do
+      before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails, 'minimal,failure') }
+
+      it "should return a valid language" do
+        @rails.should be_valid
+      end
+
+      it "should at least parse :processing and :completed lines" do
+        @rails.line_definitions.should include(:processing, :completed, :failure)
+      end
+    end
+
+    RequestLogAnalyzer::FileFormat::Rails::LINE_COLLECTIONS.keys.each do |constant|
+
+      context "using the '#{constant}' line collection constant" do
+        before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails, constant) }
+
+        it "should return a valid language" do
+          @rails.should be_valid
+        end
+
+        it "should at least parse :processing and :completed lines" do
+          @rails.line_definitions.should include(:processing, :completed)
+        end
+      end
+    end
+  end
+
+  describe '#parse_line' do
+    before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails, :all) }
+
+    {'with prefix' => 'LINE PREFIX: ', 'without prefix' => '' }.each do |context, prefix|
+      context context do
+        it "should parse a :processing line correctly" do
+          line = prefix + 'Processing PeopleController#index (for 1.1.1.1 at 2008-08-14 21:16:30) [GET]'
+          @rails.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '1.1.1.1')
+        end
+        
+        it "should parse a :processing line correctly when it contains ipv6 localhost address" do
+           line = prefix + 'Processing PeopleController#index (for ::1 at 2008-08-14 21:16:30) [GET]'
+           @rails.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '::1')
+        end
+
+        it "should parse a :processing line correctly when it contains ipv6 address" do
+           line = prefix + 'Processing PeopleController#index (for 3ffe:1900:4545:3:200:f8ff:fe21:67cf at 2008-08-14 21:16:30) [GET]'
+           @rails.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '3ffe:1900:4545:3:200:f8ff:fe21:67cf')
+        end
+
+        it "should parse a Rails 2.1 style :completed line correctly" do
+          line = prefix + 'Completed in 0.21665 (4 reqs/sec) | Rendering: 0.00926 (4%) | DB: 0.00000 (0%) | 200 OK [http://demo.nu/employees]'
+          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.21665, :db => 0.0, :view => 0.00926, :status => 200, :url => 'http://demo.nu/employees')
+        end
+
+        it "should parse a Rails 2.2 style :completed line correctly" do
+          line = prefix + 'Completed in 614ms (View: 120, DB: 31) | 200 OK [http://floorplanner.local/demo]'
+          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.614, :db => 0.031, :view => 0.120, :status => 200, :url => 'http://floorplanner.local/demo')
+        end
+
+        it "should parse a :failure line with exception correctly" do
+          line = prefix + "NoMethodError (undefined method `update_domain_account' for nil:NilClass):"
+          @rails.should parse_line(line).as(:failure).and_capture(:error => 'NoMethodError', :message => "undefined method `update_domain_account' for nil:NilClass")
+        end
+
+        it "should parse a :cache_hit line correctly with an filter instance reference" do
+          line = prefix + 'Filter chain halted as [#<ActionController::Filters::AroundFilter:0x2a999ad120 @identifier=nil, @kind=:filter, @options={:only=>#<Set: {"cached"}>, :if=>:not_logged_in?, :unless=>nil}, @method=#<ActionController::Caching::Actions::ActionCacheFilter:0x2a999ad620 @check=nil, @options={:store_options=>{}, :layout=>nil, :cache_path=>#<Proc:0x0000002a999b8890@/app/controllers/cached_controller.rb:8>}>>] did_not_yield.'
+          @rails.should parse_line(line).as(:cache_hit)
+        end
+
+        it "should parse a :cache_hit line correctly with an proc instance reference" do
+          line = prefix + 'Filter chain halted as [#<ActionController::Filters::AroundFilter:0x2a9a923e38 @method=#<Proc:0x0000002a9818b3f8@/usr/local/lib/ruby/gems/1.8/gems/actionpack-2.3.5/lib/action_controller/caching/actions.rb:64>, @kind=:filter, @identifier=nil, @options={:unless=>nil, :if=>nil, :only=>#<Set: {"show"}>}>] did_not_yield.'          
+          @rails.should parse_line(line).as(:cache_hit)
+        end
+
+
+        it "should parse a :parameters line correctly" do
+          line = prefix + '  Parameters: {"action"=>"cached", "controller"=>"cached"}'
+          @rails.should parse_line(line).as(:parameters).and_capture(:params => {:action => 'cached', :controller => 'cached'})
+        end
+
+        it "should parse a :rendered line correctly" do
+          line = prefix + 'Rendered layouts/_footer (2.9ms)'
+          @rails.should parse_line(line).as(:rendered).and_capture(:render_file => 'layouts/_footer', :render_duration => 0.0029)
+        end
+
+        it "should parse a :query_executed line with colors" do
+          line = prefix + ' User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) '
+          @rails.should parse_line(line).as(:query_executed).and_capture(:query_class => 'User', :query_duration => 0.0004, :query_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+        end
+
+        it "should parse a :query_executed line without colors" do
+          line = prefix + ' User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) '
+          @rails.should parse_line(line).as(:query_executed).and_capture(:query_class => 'User', :query_duration => 0.0004, :query_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+        end
+
+        it "should parse a :query_cached line with colors" do
+          line = prefix + ' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) '
+          @rails.should parse_line(line).as(:query_cached).and_capture(:cached_duration => 0.0, :cached_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+        end
+
+        it "should parse a :query_cached line without colors" do
+          line = prefix + ' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) '
+          @rails.should parse_line(line).as(:query_cached).and_capture(:cached_duration => 0.0, :cached_sql => 'SELECT * FROM users WHERE (users.id = :int)')
+        end
+
+        it "should not parse an unsupported line" do
+          line = prefix + 'nonsense line that should not be parsed as anything'
+          @rails.should_not parse_line(line)
+        end
+      end
+    end
+  end
+
+  describe '#parse_io' do
+    before(:each) do
+      @log_parser = RequestLogAnalyzer::Source::LogParser.new(
+            RequestLogAnalyzer::FileFormat.load(:rails), :parse_strategy => 'cautious')
+    end
+
+    it "should parse a Rails 2.1 style log and find valid Rails requests without warnings" do
+      request_counter.should_receive(:hit!).exactly(4).times
+      @log_parser.should_not_receive(:warn)
+      
+      @log_parser.parse_file(log_fixture(:rails_1x)) do |request|
+        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
+      end
+    end
+
+    it "should parse a Rails 2.2 style log and find valid Rails requests without warnings" do
+      request_counter.should_receive(:hit!).once
+      @log_parser.should_not_receive(:warn)
+      
+      @log_parser.parse_file(log_fixture(:rails_22)) do |request|
+        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
+      end
+    end
+
+    it "should parse a Rails SyslogLogger file with prefix and find valid requests without warnings" do
+      request_counter.should_receive(:hit!).once
+      @log_parser.should_not_receive(:warn)
+      
+      @log_parser.parse_file(log_fixture(:syslog_1x)) do |request|
+        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
+      end
+    end
+
+    it "should parse cached requests" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.parse_file(log_fixture(:rails_22_cached)) do |request|
+        request.should be_completed
+        request =~ :cache_hit
+      end
+    end
+
+    it "should detect unordered requests in the logs" do
+      @log_parser.should_not_receive(:handle_request)
+      @log_parser.should_receive(:warn).with(:unclosed_request, anything).once
+      @log_parser.should_receive(:warn).with(:no_current_request, anything).twice
+      @log_parser.parse_file(log_fixture(:rails_unordered))
+    end
+  end
+end

data/spec/unit/filter/anonymize_filter_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Anonymize, 'anonymize request' do
+
+  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,66 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Field, 'string in accept mode' do
+
+  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
+
+  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
+
+  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/filter_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Base, 'base filter' do
+
+  before(:each) do
+    @filter = RequestLogAnalyzer::Filter::Base.new(testing_format)
+  end
+
+  it "should return everything" do
+    @filter.filter(request(:ip => '123.123.123.123'))[:ip].should eql('123.123.123.123')
+  end
+
+  it "should return nil on nil request" do
+    @filter.filter(nil).should be_nil
+  end
+
+end

data/spec/unit/filter/timespan_filter_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Filter::Timespan, 'both before and after'  do
+
+  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
+
+  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
+
+  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/unit/mailer_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe RequestLogAnalyzer::Mailer, 'mailer' do
+
+  it "should initialize correctly" do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true) 
+    @mailer.host.should eql("localhost")
+    @mailer.port.should eql(25)
+  end
+  
+  it "should allow alternate port settings" do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost:2525', :debug => true) 
+    @mailer.host.should eql("localhost")
+    @mailer.port.should eql("2525")
+  end
+
+  it "should store printed data" do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true)
+
+    @mailer << 'test1'
+    @mailer.puts 'test2'
+    
+    @mailer.data.should eql(['test1', 'test2'])
+  end
+
+  it "should send mail" do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true)
+
+    @mailer << 'test1'
+    @mailer.puts 'test2'
+
+    mail = @mailer.mail
+    
+    mail[0].should include("contact@railsdoctors.com")
+    mail[0].should include("test1")
+    mail[0].should include("test2")
+
+    mail[1].should include("contact@railsdoctors.com")
+    mail[2].should include("alfa@beta.com")
+  end
+
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe RequestLogAnalyzer::Request do
+
+  before(:each) do
+    @request = testing_format.request
+  end
+
+  it "should be empty without any captured lines in it" do
+    @request.should be_empty
+  end
+
+  context :incomplete do
+
+    before(:each) do
+      @request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
+    end
+
+    it "should be single if only one line has been added" do
+      @request.should_not be_empty
+    end
+
+    it "should not be a completed request" do
+      @request.should_not be_completed
+    end
+
+    it "should take the line type of the first line as global line_type" do
+      @request.lines[0][:line_type].should == :test
+      @request.should =~ :test
+    end
+
+    it "should return the first field value" do
+      @request[:test_capture].should == 'awesome!'
+    end
+
+    it "should return nil if no such field is present" do
+      @request[:nonexisting].should be_nil
+    end
+  end
+
+  context :completed do
+
+    before(:each) do
+      @request << { :line_type => :first, :lineno =>  1, :name => 'first line!' }
+      @request << { :line_type => :test,  :lineno =>  4, :test_capture => 'testing' }
+      @request << { :line_type => :test,  :lineno =>  7, :test_capture => 'testing some more' }
+      @request << { :line_type => :last,  :lineno => 10, :time => 0.03 }
+    end
+
+    it "should not be empty when multiple liness are added" do
+      @request.should_not be_empty
+    end
+
+    it "should be a completed request" do
+      @request.should be_completed
+    end
+
+    it "should recognize all line types" do
+      [:first, :test, :last].each { |type| @request.should =~ type }
+    end
+
+    it "should detect the correct field value" do
+      @request[:name].should == 'first line!'
+      @request[:time].should == 0.03
+    end
+
+    it "should detect the first matching field value" do
+      @request.first(:test_capture).should == 'testing'
+    end
+
+    it "should detect the every matching field value" do
+      @request.every(:test_capture).should == ['testing', "testing some more"]
+    end
+
+    it "should set the first_lineno for a request to the lowest lineno encountered" do
+      @request.first_lineno.should eql(1)
+    end
+
+    it "should set the first_lineno for a request if a line with a lower lineno is added" do
+      @request << { :line_type => :test, :lineno =>  0 }
+      @request.first_lineno.should eql(0)
+    end
+
+    it "should set the last_lineno for a request to the highest encountered lineno" do
+      @request.last_lineno.should eql(10)
+    end
+
+    it "should not set the last_lineno for a request if a line with a lower lineno is added" do
+      @request << { :line_type => :test, :lineno =>  7 }
+      @request.last_lineno.should eql(10)
+    end
+
+    it "should not have a timestamp if no such field is captured" do
+      @request.timestamp.should be_nil
+    end
+
+    it "should set return a timestamp field if such a field is captured" do
+      @request << { :line_type => :first, :lineno =>  1, :name => 'first line!', :timestamp => Time.now}
+      @request.timestamp.should_not be_nil
+    end
+  end
+
+  context 'single line' do
+    # combined is both a header and a footer line
+    before(:each) { @request << { :line_type => :combined, :lineno => 1 } }
+
+    it "should be a completed request if the line is both header and footer" do
+      @request.should be_completed
+    end
+  end
+end

data/spec/unit/source/log_parser_spec.rb

@@ -0,0 +1,119 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Source::LogParser, :requests do
+
+  before(:each) do
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format)
+  end
+
+  it "should have multiple line definitions" do
+    @log_parser.file_format.line_definitions.length.should >= 2
+  end
+
+  it "should have a valid language" do
+    @log_parser.file_format.should be_valid
+  end
+
+  it "should set the :source for every parsed line" do
+    @log_parser.parse_file(log_fixture(:rails_22)) do |request|
+      request.lines.all? { |line| line[:source] == log_fixture(:rails_22) }.should be_true
+    end
+  end
+
+  it "should set the :lineno for every parsed line" do
+    @log_parser.parse_file(log_fixture(:rails_22)) do |request|
+      request.lines.all? { |line| line.has_key?(:lineno) }.should be_true
+    end
+  end
+
+  it "should parse more lines than requests" do
+    @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(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[:request_no].should == 1
+      request[:test_capture].should == "Testing is amazing" # Note the custom converter
+    end
+  end
+
+  it "should parse a stream and find valid requests" do
+    io = File.new(log_fixture(:test_file_format), 'rb')
+    @log_parser.parse_io(io) do |request|
+      request.should be_kind_of(RequestLogAnalyzer::Request)
+      request.should =~ :test
+      request[:test_capture].should_not be_nil
+    end
+    io.close
+  end
+
+  it "should parse a request that only consists of one line" do
+    @log_parser.parse_file(log_fixture(:header_and_footer))
+    @log_parser.parsed_requests.should == 2
+  end
+end
+
+describe RequestLogAnalyzer::Source::LogParser, :warnings do
+
+  before(:each) do
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(testing_format, :parse_strategy => 'cautious')
+  end
+
+  it "should warn about teaser matching problems" do
+    @log_parser.should_receive(:warn).with(:teaser_check_failed, anything).exactly(5).times
+    @log_parser.parse_file(log_fixture(:test_file_format))
+  end
+
+  it "should warn about unmatching request headers and footers" do
+    @log_parser.should_receive(:warn).with(:unclosed_request, anything).at_least(1).times
+    @log_parser.should_receive(:warn).with(:no_current_request, anything).at_least(1).times
+    @log_parser.should_not_receive(:handle_request)
+    @log_parser.parse_file(log_fixture(:test_order))
+  end
+end
+
+describe RequestLogAnalyzer::Source::LogParser, :decompression do
+
+  before(:each) do
+    @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat::Rails.create)
+  end
+
+  it "should parse a rails gzipped log file" do
+    @log_parser.should_receive(:handle_request).once
+    @log_parser.parse_file(log_fixture(:decompression, "log.gz"))
+    @log_parser.parsed_lines.should > 0
+  end
+
+  it "should parse a rails tar gzipped log folder" do
+    @log_parser.should_receive(:handle_request).twice
+    @log_parser.parse_file(log_fixture(:decompression, "tar.gz"))
+    @log_parser.parsed_lines.should > 1
+  end
+
+  it "should parse a rails tar gzipped log folder" do
+    @log_parser.should_receive(:handle_request).twice
+    @log_parser.parse_file(log_fixture(:decompression, "tgz"))
+    @log_parser.parsed_lines.should > 1
+  end
+
+  it "should parse a rails bz2 zipped log file" do
+    @log_parser.should_receive(:handle_request).once
+    @log_parser.parse_file(log_fixture(:decompression, "log.bz2"))
+    @log_parser.parsed_lines.should > 0
+  end
+
+  it "should parse a rails zipped log file" do
+    @log_parser.should_receive(:handle_request).once
+    @log_parser.parse_file(log_fixture(:decompression, "log.zip"))
+    @log_parser.parsed_lines.should > 0
+  end
+
+end

data/spec/unit/tracker/duration_tracker_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe RequestLogAnalyzer::Tracker::Duration do
+
+  describe '#report' do
+
+    before(:each) do
+      @tracker = RequestLogAnalyzer::Tracker::Duration.new(:category => :category, :value => :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
+
+    it "should generate a YAML output" do
+      @tracker.update(request(:category => 'a', :duration => 0.2))
+      @tracker.update(request(:category => 'b', :duration => 0.2))
+      @tracker.to_yaml_object.should == {"a"=>{:hits=>1, :min=>0.2, :mean=>0.2, :max=>0.2, :sum_of_squares=>0.0, :sum=>0.2}, "b"=>{:hits=>1, :min=>0.2, :mean=>0.2, :max=>0.2, :sum_of_squares=>0.0, :sum=>0.2}}
+    end
+  end
+  
+  describe '#display_value' do
+    before(:each) { @tracker = RequestLogAnalyzer::Tracker::Duration.new(:category => :category, :value => :duration) }
+    
+    it "should only display seconds when time < 60" do
+      @tracker.display_value(33.12).should == '33.12s'
+    end
+
+    it "should display minutes and wholeseconds when time > 60" do
+      @tracker.display_value(63.12).should == '1m03s'
+    end
+
+    it "should display minutes and wholeseconds when time > 60" do
+      @tracker.display_value(3601.12).should == '1h00m01s'
+    end
+  end
+end