request-log-analyzer 1.3.7 → 1.4.0

data/spec/unit/file_format/amazon_s3_format_spec.rb

@@ -7,24 +7,24 @@ describe RequestLogAnalyzer::FileFormat::AmazonS3 do
     @log_parser  = RequestLogAnalyzer::Source::LogParser.new(@file_format)
     @sample = '2f88111968424e6306bf4d292c0188ccb94ff9374ea2836b50a1a79f7cd656e1 sample-bucket [06/Oct/2006:01:42:14 +0000] 207.171.172.6 65a011a29cdf8ec533ec3d1ccaae921c C980091AD89C936A REST.GET.OBJECT object.png "GET /sample-bucket/object.png HTTP/1.1" 200 - 1243 1243 988 987 "-" "aranhabot"'
   end
-  
+
   it "should be a valid file format" do
     @file_format.should be_valid
   end
-  
+
   it "should parse access lines and capture all of its fields" do
     @file_format.should have_line_definition(:access).capturing(:bucket_owner, :bucket, :timestamp, :remote_ip, :requester,
           :key, :operation, :total_time, :turnaround_time, :bytes_sent, :object_size, :referer, :user_agent)
   end
-  
+
   it "should match the sample line" do
     @file_format.parse_line(@sample).should include(:line_definition, :captures)
   end
-  
+
   it "should not match a nonsense line" do
     @file_format.parse_line('dsadasdas dsaadsads dsaadsads').should be_nil
   end
-  
+
   it "should parse and convert the sample fields correctly" do
     @log_parser.parse_io(StringIO.new(@sample)) do |request|
       request[:bucket_owner].should    == '2f88111968424e6306bf4d292c0188ccb94ff9374ea2836b50a1a79f7cd656e1'

data/spec/unit/file_format/apache_format_spec.rb

@@ -23,7 +23,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
     it "should make it a footer line" do
       @line_definition.should be_footer
     end
-    
+
     it "should capture :duration" do
       @line_definition.captures?(:duration).should be_true
     end
@@ -43,7 +43,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
     it "should be a valid file format" do
       @format.should be_valid
     end
-    
+
     it "should setup report trackers" do
       @format.report_trackers.should_not be_empty
     end
@@ -60,7 +60,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
     it "should have a valid language definitions" do
       @file_format.should be_valid
     end
-    
+
     it "should parse a valid access log line" do
       @file_format.line_definitions[:access].matches(@sample_1).should be_kind_of(Hash)
     end
@@ -68,7 +68,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
     it "should not parse a valid access log line" do
       @file_format.line_definitions[:access].matches('addasdsasadadssadasd').should be_false
     end
-    
+
     it "should read the correct values from a valid HTTP/1.0 access log line" do
       @log_parser.parse_io(StringIO.new(@sample_1)) do |request|
         request[:remote_host].should  == '1.129.119.13'
@@ -80,7 +80,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
         request[:user].should         == nil
       end
     end
-    
+
     it "should read the correct values from a valid 200 access log line" do
       @log_parser.parse_io(StringIO.new(@sample_2)) do |request|
         request[:remote_host].should  == '1.82.235.29'
@@ -91,7 +91,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
         request[:bytes_sent].should   == 23414
         request[:user].should         == nil
       end
-    end    
+    end
 
     it "should parse 10 request from fixture access log" do
       counter = mock('counter')
@@ -99,18 +99,18 @@ describe RequestLogAnalyzer::FileFormat::Apache do
       @log_parser.parse_file(log_fixture(:apache_common)) { counter.hit! }
     end
   end
-  
+
   context '"Rack" access log parser' do
     before(:each) do
       @file_format = RequestLogAnalyzer::FileFormat.load(:rack)
       @log_parser  = RequestLogAnalyzer::Source::LogParser.new(@file_format)
       @sample_1 = '127.0.0.1 - - [16/Sep/2009 06:40:08] "GET /favicon.ico HTTP/1.1" 500 63183 0.0453'
     end
-    
+
     it "should create a kind of an Apache file format" do
       @file_format.should be_kind_of(RequestLogAnalyzer::FileFormat::Apache)
     end
-    
+
     it "should have a valid language definitions" do
       @file_format.should be_valid
     end
@@ -136,7 +136,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
       end
     end
   end
- 
+
   context '"Combined" access log parsing' do
 
     before(:all) do
@@ -171,7 +171,7 @@ describe RequestLogAnalyzer::FileFormat::Apache do
         request[:user_agent].should   == 'Mozilla/4.0 (compatible; MSIE 6.0; Windows 98)'
       end
     end
-    
+
     it "should read the correct values from a valid 200 access log line" do
       @log_parser.parse_io(StringIO.new(@sample_2)) do |request|
         request[:remote_host].should  == '10.0.1.1'
@@ -184,8 +184,8 @@ describe RequestLogAnalyzer::FileFormat::Apache do
         request[:user].should         == nil
         request[:user_agent].should   == 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_8; en-us) AppleWebKit/531.9 (KHTML, like Gecko) Version/4.0.3 Safari/531.9'
       end
-    end    
-  
+    end
+
     it "should parse 5 request from fixture access log" do
       counter = mock('counter')
       counter.should_receive(:hit!).exactly(5).times

data/spec/unit/file_format/file_format_api_spec.rb

@@ -3,43 +3,43 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 describe RequestLogAnalyzer::FileFormat do
 
   describe ".format_definition" do
-  
+
     before(:each) do
       @first_file_format  = Class.new(RequestLogAnalyzer::FileFormat::Base)
       @second_file_format = Class.new(RequestLogAnalyzer::FileFormat::Base)
     end
-    
+
     it "should specify line definitions directly within the file_format" do
       @first_file_format.format_definition.direct_test :regexp => /test/
       @first_file_format.should have_line_definition(:direct_test)
     end
- 
+
     it "specify lines with a block for the format definition" do
       @first_file_format.format_definition do |format|
         format.block_test :regexp => /test (\w+)/, :captures => [{:name => :tester, :type => :string}]
-      end 
-          
+      end
+
       @first_file_format.should have_line_definition(:block_test).capturing(:tester)
     end
-    
+
     it "should specify a line with a block" do
       @first_file_format.format_definition.hash_test do |line|
         line.regexp   = /test/
         line.captures = []
       end
-    
+
       @first_file_format.should have_line_definition(:hash_test)
     end
-  
+
     it "should define lines only for its own language" do
       @first_file_format.format_definition.first   :regexp => /test 123/
       @second_file_format.format_definition.second :regexp => /test 456/
- 
+
       @first_file_format.should      have_line_definition(:first)
       @first_file_format.should_not  have_line_definition(:second)
-      @second_file_format.should_not have_line_definition(:first)      
+      @second_file_format.should_not have_line_definition(:first)
       @second_file_format.should     have_line_definition(:second)
-    end  
+    end
   end
 
   describe ".load" do
@@ -58,12 +58,12 @@ describe RequestLogAnalyzer::FileFormat do
       @file_format = RequestLogAnalyzer::FileFormat.load(:rails)
       @file_format.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails)
     end
-  
+
     it "should load a provided format file" do
       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
 end

data/spec/unit/file_format/line_definition_spec.rb

@@ -9,20 +9,27 @@ describe RequestLogAnalyzer::LineDefinition do
       :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer }]
     })
   end
-  
+
   describe '#matches' do
-  
+
     it "should return false on an unmatching line" do
-      @line_definition.should_not parse("nonmatching")
+      @line_definition.matches("nonmatching").should be_false
     end
-  
+
     it "should return false when only the teaser matches" do
-      @line_definition.should_not parse("Testing LineDefinition")    
+      @line_definition.matches("Testing LineDefinition").should be_false
     end
-  
+
     it "should parse a line and capture the expected values" do
-      @line_definition.should parse("Testing LineDefinition, tries: 123").capturing('LineDefinition', '123')
+      @line_definition.matches("Testing LineDefinition, tries: 123").should == {:line_definition => @line_definition, :captures => ['LineDefinition', '123'] }
+    end
+
+    it "should know which names it can capture" do
+      @line_definition.captures?(:what).should be_true
+      @line_definition.captures?(:tries).should be_true
+      @line_definition.captures?(:bogus).should be_false
     end
+    
   end
 
   describe '#convert_captured_values' do
@@ -31,38 +38,38 @@ describe RequestLogAnalyzer::LineDefinition do
       @request = mock('request')
       @request.stub!(:convert_value).and_return('foo')
     end
-    
+
     it "should call convert_value for every captured value" do
       @request.should_receive(:convert_value).twice
       @line_definition.convert_captured_values(['test', '123'], @request)
     end
-    
+
     it "should set the converted values" do
       @line_definition.convert_captured_values(['test', '123'], @request).should == {:what => 'foo', :tries => 'foo'}
     end
-    
+
     context 'when using :provides option' do
       before(:each) do
-        @ld = RequestLogAnalyzer::LineDefinition.new(:test, :regexp   => /Hash\: (\{.+\})/, 
+        @ld = RequestLogAnalyzer::LineDefinition.new(:test, :regexp   => /Hash\: (\{.+\})/,
             :captures => [{ :name => :hash, :type => :hash, :provides => {:bar => :string}}])
-            
+
         @request = mock('request')
 
         @request.stub!(:convert_value).with("{:bar=>'baz'}", anything).and_return(:bar => 'baz')
         @request.stub!(:convert_value).with('baz', anything).and_return('foo')
-      end   
-      
+      end
+
       it "should call Request#convert_value for the initial hash and the value in the hash" do
         @request.should_receive(:convert_value).with("{:bar=>'baz'}", anything).and_return(:bar => 'baz')
         @request.should_receive(:convert_value).with("baz", anything)
         @ld.convert_captured_values(["{:bar=>'baz'}"], @request)
       end
-      
+
       it "should set the provides fields" do
         # The captures field must be set and converted as well
         @ld.convert_captured_values(["{:bar=>'baz'}"], @request)[:bar].should eql('foo')
-      end      
+      end
     end
-    
+
   end
 end

data/spec/unit/file_format/merb_format_spec.rb

@@ -1,56 +1,52 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Merb do
-  
-  before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:merb))
-  end
-  
-  it "should have a valid language definitions" do
-    @log_parser.file_format.should be_valid
-  end
-  
-  it "should parse a stream and find valid requests" do
-    File.open(log_fixture(:merb), 'r') do |io|
-      @log_parser.parse_io(io) do |request| 
-        request.should be_kind_of(RequestLogAnalyzer::Request)
-      end
-    end
-  end
 
-  it "should find 11 completed requests" do
-    @log_parser.should_receive(:handle_request).exactly(11).times
-    @log_parser.parse_file(log_fixture(:merb))
+  it "should be a valid file format" do
+    RequestLogAnalyzer::FileFormat.load(:merb).should be_valid
   end
-  
-  it "should parse all details from the first request correctly" do
-    request = nil
-    @log_parser.parse_file(log_fixture(:merb)) { |found_request| request ||= found_request }
+
+  describe '#parse_line' do
+    before(:each) do
+      @file_format = RequestLogAnalyzer::FileFormat.load(:merb)
+    end
     
-    request.should be_completed
-    request[:controller].should == 'session'
-    request[:action].should == 'destroy'    
-    request[:method].should == 'delete'
-    request[:params].should be_kind_of(Hash)      
-    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
-    request[:action_time].should == 0.241652
+    it "should parse a :started line correctly" do
+      line = '~ Started request handling: Fri Aug 29 11:10:23 +0200 2008'
+      @file_format.should parse_line(line).as(:started).and_capture(:timestamp => 20080829111023)
+    end
 
+    it "should parse a prefixed :started line correctly" do
+      line = '~ Aug 31 18:35:24 typekit-web001 merb:  ~ Started request handling: Mon Aug 31 18:35:25 +0000 2009'
+      @file_format.should parse_line(line).as(:started).and_capture(:timestamp => 20090831183525)
+    end
+
+    it "should parse a :params line correctly" do
+      line = '~ Params: {"_method"=>"delete", "authenticity_token"=>"[FILTERED]", "action"=>"delete", "controller"=>"session"}'
+      @file_format.should parse_line(line).as(:params).and_capture(:controller => 'session', :action => 'delete', :namespace => nil)
+    end
+
+    it "should parse a :completed line correctly" do
+      line = '~ {:dispatch_time=>0.006117, :after_filters_time=>6.1e-05, :before_filters_time=>0.000712, :action_time=>0.005833}'
+      @file_format.should parse_line(line).as(:completed).and_capture(:dispatch_time => 0.006117, 
+        :before_filters_time => 0.000712, :action_time => 0.005833, :after_filters_time => 6.1e-05)
+    end
   end
+
+  describe '#parse_io' do
+    before(:each) do
+      @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:merb))
+    end
+
+    it "should parse a stream and find valid Merb requests" do
+      @log_parser.parse_file(log_fixture(:merb)) do |request|
+        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Merb::Request)
+      end
+    end
   
-  it "should parse a prefixed Merb file correctly" do
-    request = nil
-    @log_parser.parse_file(log_fixture(:merb_prefixed)) { |found_request| request ||= found_request }
-    
-    request.should be_completed
-    request[:timestamp].should == 20090831183525
-    request[:controller].should == 'home'
-    request[:action].should == 'index'
-    request[:dispatch_time].should == 0.012001
-    request[:after_filters_time].should == 0.0
-    request[:before_filters_time].should == 0.0
-    request[:action_time].should == 0.012001
+    it "should find 11 completed requests" do
+      @log_parser.should_receive(:handle_request).exactly(11).times
+      @log_parser.parse_file(log_fixture(:merb))
+    end
   end
 end

data/spec/unit/file_format/rails_format_spec.rb

@@ -1,127 +1,167 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Rails do
-  
-  before(:each) do
-    @log_parser = RequestLogAnalyzer::Source::LogParser.new(
-          RequestLogAnalyzer::FileFormat.load(:rails), :parse_strategy => 'cautious')
-  end
-  
-  it "should have a valid language definitions" do
-    @log_parser.file_format.should be_valid
-  end
-  
-  it "should parse a stream and find valid requests" do
-    io = File.new(log_fixture(:rails_1x), 'r')
-    @log_parser.parse_io(io) do |request| 
-      request.should be_kind_of(RequestLogAnalyzer::Request)
-    end
-    io.close
-  end  
-  
-  it "should find 4 completed requests" do
-    @log_parser.should_not_receive(:warn)  
-    @log_parser.should_receive(:handle_request).exactly(4).times
-    @log_parser.parse_file(log_fixture(:rails_1x))
-  end  
-  
-  it "should parse a Rails 2.2 request properly" do
-    @log_parser.should_not_receive(:warn)
-    @log_parser.parse_file(log_fixture(:rails_22)) do |request|
-      request.should =~ :processing
-      request.should =~ :completed  
-    
-      request[:controller].should == 'PageController'
-      request[:action].should     == 'demo'
-      request[:url].should        == 'http://www.example.coml/demo'    
-      request[:status].should     == 200
-      request[:duration].should   == 0.614
-      request[:db].should         == 0.031
-      request[:view].should       == 0.120
+
+  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
-  end
-  
-  it "should parse a syslog file with prefix correctly" do
-    @log_parser.should_not_receive(:warn)    
-    @log_parser.parse_file(log_fixture(:syslog_1x)) do |request| 
-      
-      request.should be_completed
+
+    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
       
-      request[:controller].should == 'EmployeeController'
-      request[:action].should     == 'index'
-      request[:url].should        == 'http://example.com/employee.xml'    
-      request[:status].should     == 200
-      request[:duration].should   == 0.21665
-      request[:db].should         == 0.0
-      request[:view].should       == 0.00926
+      it "should at least parse :processing and :completed lines" do
+        @rails.line_definitions.should include(:processing, :completed, :failure)
+      end
     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
-    # 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 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 do
-  
-  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
+    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
-  
-  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'
-    info[:render_duration].should == 0.0029
+
+  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')
+        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" do
+          line = prefix + 'Filter chain halted as [#<ActionController::Caching::Actions::ActionCacheFilter:0x2a999ad620 @check=nil, @options={:store_options=>{}, :layout=>nil, :cache_path=>#<Proc:0x0000002a999b8890@/app/controllers/cached_controller.rb:8>}>] rendered_or_redirected.'
+          @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
-  
-  it "should parse a query executed line with 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 = :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 = :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 = :int)'   
+
+  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
+      @log_parser.should_not_receive(:warn)
+      @log_parser.parse_file(log_fixture(:rails_1x)) do |request|
+        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails::Request)
+        request.should be_completed
+      end
+    end
+
+    it "should parse a Rails 2.2 style log and find valid Rails requests without warnings" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.parse_file(log_fixture(:rails_22)) do |request|
+        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails::Request)
+        request.should be_completed
+      end
+    end
+
+    it "should parse a Rails SyslogLogger file with prefix and find valid requests without warnings" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.parse_file(log_fixture(:syslog_1x)) do |request|
+        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Rails::Request)
+        request.should be_completed
+      end
+    end
+
+    it "should find 4 completed requests" do
+      @log_parser.should_not_receive(:warn)
+      @log_parser.should_receive(:handle_request).exactly(4).times
+      @log_parser.parse_file(log_fixture(:rails_1x))
+    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
-  
-  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 = :int)'  
-  end  
-end
+end