request-log-analyzer 1.9.10 → 1.11.0

data/spec/unit/file_format/mysql_format_spec.rb

@@ -2,153 +2,110 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Mysql do
 
-  it "should be a valid file format" do
-    RequestLogAnalyzer::FileFormat.load(:mysql).should be_valid
-  end
-
+  subject { RequestLogAnalyzer::FileFormat.load(:mysql) }
+  
+  it { should be_well_formed }
+  it { should have_line_definition(:time).capturing(:timestamp) }
+  it { should have_line_definition(:user_host).capturing(:user, :host, :ip) }
+  it { should have_line_definition(:query_statistics).capturing(:query_time, :lock_time, :rows_sent, :rows_examined) }
+  it { should have_line_definition(:use_database).capturing(:database) }
+  it { should have_line_definition(:query_part).capturing(:query_fragment) }
+  it { should have_line_definition(:query).capturing(:query) }
+  it { should have(7).report_trackers }
+  
   describe '#parse_line' do
-    before(:each) do
-      @file_format = RequestLogAnalyzer::FileFormat.load(:mysql)
-    end
-
-    it "should parse a :time line correctly" do
-      line = '# Time: 091112  8:13:56'
-      @file_format.should parse_line(line).as(:time).and_capture(:timestamp => 20091112081356)
-    end
-
-    it "should parse a :user_host line correctly with IP present" do
-      line = '# User@Host: admin[admin] @ db1 [10.0.0.1]'
-      @file_format.should parse_line(line).as(:user_host).and_capture(:user => "admin", :host => 'db1', :ip => '10.0.0.1')
-    end
-
-    it "should parse a :user_host line correctly without a host" do
-      line = '# User@Host: admin[admin] @  [10.0.0.1]'
-      @file_format.should parse_line(line).as(:user_host).and_capture(:user => "admin", :host => '', :ip => '10.0.0.1')
-    end
-
-    it "should parse a :user_host line correctly with IP absent" do
-      line = '# User@Host: root[root] @ localhost []'
-      @file_format.should parse_line(line).as(:user_host).and_capture(:user => "root", :host => 'localhost', :ip => "")
-    end
-
-    it "should parse a :query_statistics line" do
-      line = '# Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307'
-      @file_format.should parse_line(line).as(:query_statistics).and_capture(:query_time => 10.0,
-          :lock_time => 0.0, :rows_sent => 1191307, :rows_examined => 1191307)
-    end
-
-    it "should parse a :query_statistics line with floating point durations" do
-      line = '# Query_time: 10.00000  Lock_time: 0.00000  Rows_sent: 1191307  Rows_examined: 1191307'
-      @file_format.should parse_line(line).as(:query_statistics).and_capture(:query_time => 10.0,
-          :lock_time => 0.0, :rows_sent => 1191307, :rows_examined => 1191307)
-    end
-    
-    it "should parse a :query_part line" do
-      line = '                               AND clients.index > 0'
-      @file_format.should parse_line(line).as(:query_part).and_capture(:query_fragment => line)
-    end
     
-    it "should parse a final :query line" do
-      line = 'SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`; '
-      @file_format.should parse_line(line).as(:query).and_capture(:query =>
-        'SELECT /*!:int SQL_NO_CACHE */ * FROM events')
-    end
-    
-    it "should parse a :use_database line" do
-      line = 'use db;'
-      @file_format.should parse_line(line).as(:use_database).and_capture(:database => 'db')
-    end
-    
-    it "should not parse a SET timestamp line" do
-      line = 'SET timestamp=1250651725;'
-      @file_format.should_not parse_line(line)
-    end
-
-    it "should not parse a SET insert_id line" do
-      line = 'SET insert_id=1250651725;'
-      @file_format.should_not parse_line(line)
-    end
-
-    it "should not parse a SET timestamp, insert_id line" do
-      line = 'SET timestamp=1250651725, insert_id=45674;'
-      @file_format.should_not parse_line(line)
-    end
-
-
+    let(:time_sample)                   { '# Time: 091112  8:13:56' }
+    let(:user_host_sample)              { '# User@Host: admin[admin] @ db1 [10.0.0.1]' }
+    let(:user_host_wo_host_sample)      { '# User@Host: admin[admin] @  [10.0.0.1]' }
+    let(:user_host_wo_ip_sample)        { '# User@Host: root[root] @ localhost []' }
+    let(:float_query_statistics_sample) { '# Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307' }
+    let(:int_query_statistics_sample)   { '# Query_time: 10.00000  Lock_time: 0.00000  Rows_sent: 1191307  Rows_examined: 1191307' }
+    let(:partial_query_sample)          { 'AND clients.index > 0' }
+    let(:full_query_sample)             { 'SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`; ' }
+    let(:use_db_sample)                 { 'use db;' }
+    let(:set_timestamp_sample)          { 'SET timestamp=1250651725;' }
+    let(:set_insertid_sample)           { 'SET insert_id=1250651725;' }
+    let(:set_timestamp_insertid_sample) { 'SET timestamp=1250651725, insert_id=45674;' }
+
+    it { should parse_line(time_sample).as(:time).and_capture(:timestamp => 20091112081356) }
+    it { should parse_line(user_host_sample).as(:user_host).and_capture(:user => "admin", :host => 'db1', :ip => '10.0.0.1') }
+    it { should parse_line(user_host_wo_host_sample, 'without host').as(:user_host).and_capture(:user => "admin", :host => '', :ip => '10.0.0.1') }
+    it { should parse_line(user_host_wo_ip_sample, 'without IP').as(:user_host).and_capture(:user => "root", :host => 'localhost', :ip => "") }
+    it { should parse_line(float_query_statistics_sample, 'using floats').as(:query_statistics).and_capture(:query_time => 10.0, :lock_time => 0.0, :rows_sent => 1191307, :rows_examined => 1191307) }
+    it { should parse_line(int_query_statistics_sample, 'using integers').as(:query_statistics).and_capture(:query_time => 10.0, :lock_time => 0.0, :rows_sent => 1191307, :rows_examined => 1191307) }
+    it { should parse_line(partial_query_sample).as(:query_part).and_capture(:query_fragment => 'AND clients.index > 0') }
+    it { should parse_line(full_query_sample).as(:query).and_capture(:query => 'SELECT /*!:int SQL_NO_CACHE */ * FROM events') }
+    it { should parse_line(use_db_sample).as(:use_database).and_capture(:database => 'db') }
+
+    it { should_not parse_line(set_timestamp_sample) }
+    it { should_not parse_line(set_insertid_sample) }
+    it { should_not parse_line(set_timestamp_insertid_sample) }
   end
 
   describe '#parse_io' do
-    before(:each) do
-      @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:mysql))
-    end
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
 
     it "should parse a single line query entry correctly" do
-      fixture = <<EOS
-# Time: 091112 18:13:56
-# User@Host: admin[admin] @ db1 [10.0.0.1]
-# Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
-SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`;
-EOS
-      @log_parser.parse_io(StringIO.new(fixture)) do |request|
-        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Mysql::Request)
+      fixture = <<-EOS
+        # Time: 091112 18:13:56
+        # User@Host: admin[admin] @ db1 [10.0.0.1]
+        # Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
+        SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`;
+      EOS
+      
+      log_parser.parse_string(fixture) do |request|
         request[:query].should == 'SELECT /*!:int SQL_NO_CACHE */ * FROM events'
       end
     end
 
     it "should parse a multiline query entry correctly" do
-      fixture = <<EOS
-# Time: 091112 18:13:56
-# User@Host: admin[admin] @ db1 [10.0.0.1]
-# Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
-SELECT * FROM `clients` WHERE (1=1 
-                              AND clients.valid_from < '2009-12-05' AND (clients.valid_to IS NULL or clients.valid_to > '2009-11-20')
-                               AND clients.index > 0
-                              ) AND (clients.deleted_at IS NULL);
-EOS
-      @log_parser.parse_io(StringIO.new(fixture)) do |request|
-        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Mysql::Request)
+      fixture = <<-EOS
+        # Time: 091112 18:13:56
+        # User@Host: admin[admin] @ db1 [10.0.0.1]
+        # Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
+        SELECT * FROM `clients` WHERE (1=1 
+                                      AND clients.valid_from < '2009-12-05' AND (clients.valid_to IS NULL or clients.valid_to > '2009-11-20')
+                                       AND clients.index > 0
+                                      ) AND (clients.deleted_at IS NULL);
+      EOS
+      
+      log_parser.parse_string(fixture) do |request|
         request[:query].should == "SELECT * FROM clients WHERE (:int=:int AND clients.valid_from < :date AND (clients.valid_to IS NULL or clients.valid_to > :date) AND clients.index > :int ) AND (clients.deleted_at IS NULL)"
       end
     end
 
-    it "should parse a request without timestamp correctly" do
-        fixture = <<EOS
-# User@Host: admin[admin] @ db1 [10.0.0.1]
-# Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
-SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`;
-EOS
-      request_counter.should_receive(:hit!).once
-      @log_parser.should_not_receive(:warn)
-
-      @log_parser.parse_io(StringIO.new(fixture)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Mysql::Request) && request.completed?
-      end
+    it "should parse a request without timestamp correctly, without warnings" do
+        fixture = <<-EOS
+        # User@Host: admin[admin] @ db1 [10.0.0.1]
+        # Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
+        SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`;
+      EOS
+      
+      log_parser.should_receive(:handle_request).once
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_string(fixture)
     end
 
     it "should parse a query with context information correctly" do
-      fixture = <<EOS
-# Time: 091112 18:13:56
-# User@Host: admin[admin] @ db1 [10.0.0.1]
-# Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
-use database_name;
-SET timestamp=4324342342423, insert_id = 224253443;
-SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`;
-EOS
-
-      request_counter.should_receive(:hit!).once
-      @log_parser.should_not_receive(:warn)
-
-      @log_parser.parse_io(StringIO.new(fixture)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Mysql::Request) && request.completed?
+      fixture = <<-EOS
+        # Time: 091112 18:13:56
+        # User@Host: admin[admin] @ db1 [10.0.0.1]
+        # Query_time: 10  Lock_time: 0  Rows_sent: 1191307  Rows_examined: 1191307
+        use database_name;
+        SET timestamp=4324342342423, insert_id = 224253443;
+        SELECT /*!40001 SQL_NO_CACHE */ * FROM `events`;
+      EOS
+
+      log_parser.parse_string(fixture) do |request|
         request[:query].should == 'SELECT /*!:int SQL_NO_CACHE */ * FROM events'
       end
-
     end
 
-
     it "should find 26 completed sloq query entries" do
-      @log_parser.should_receive(:handle_request).exactly(26).times
-      @log_parser.parse_file(log_fixture(:mysql_slow_query))
+      log_parser.should_not_receive(:warn)
+      log_parser.should_receive(:handle_request).exactly(26).times
+      log_parser.parse_file(log_fixture(:mysql_slow_query))
     end
   end
 end

data/spec/unit/file_format/oink_format_spec.rb

@@ -1,103 +1,71 @@
 require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Oink do
-  describe '.create' do
 
-    context 'without providing a lines argument' do
-      before(:each) { @oink = RequestLogAnalyzer::FileFormat.load(:oink) }
-
-      it "should create a valid file format" do
-        @oink.should be_valid
-      end
-      
-      it "should parse :memory_usage line" do
-        @oink.line_definitions.should include(:memory_usage)
-      end
-
-    end
-  
-  end
+  subject { RequestLogAnalyzer::FileFormat.load(:oink) }
   
+  it { should have_line_definition(:memory_usage).capturing(:pid, :memory) }
+  it { should have_line_definition(:processing).capturing(:pid, :controller, :action, :ip) }
+  it { should have_line_definition(:instance_type_counter).capturing(:pid, :instance_counts) }
+  it { should have(12).report_trackers }
+
   describe '#parse_line' do
-    before(:each) { @oink = RequestLogAnalyzer::FileFormat.load(:oink, :all) }
-    
+    let(:memory_usage_sample)          { 'Jun 18 11:27:36 derek rails[67783]: Memory usage: 714052 | PID: 67783' } 
+    let(:processing_sample)            { 'Aug 14 21:16:30 derek rails[67783]: Processing PeopleController#index (for 1.1.1.1 at 2008-08-14 21:16:30) [GET]' }
+    let(:instance_type_counter_sample) { "Dec 13 12:00:44 storenvy rails[26364]: Instantiation Breakdown: Total: 732 | User: 376 | Post: 323 | Comment: 32 | Blog: 1" }
+
     it "should parse a :memory_usage line correctly" do
-      line = 'Jun 18 11:27:36 derek rails[67783]: Memory usage: 714052 | PID: 67783'
-      @oink.should parse_line(line).as(:memory_usage).and_capture(:pid => 67783, :memory => 714052)
+      subject.should parse_line(memory_usage_sample).as(:memory_usage).and_capture(:pid => 67783, :memory => 714052)
     end
     
     it "should parse the PID from a :processing line correctly" do
-      line = 'Aug 14 21:16:30 derek rails[67783]: Processing PeopleController#index (for 1.1.1.1 at 2008-08-14 21:16:30) [GET]'
-      @oink.should parse_line(line).as(:processing).and_capture(:pid => 67783, :controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '1.1.1.1')
+      subject.should parse_line(processing_sample).as(:processing).and_capture(:pid => 67783, :controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '1.1.1.1')
     end
 
     it "should parse a :instance_type_counter correctly" do
-
-      line = "Dec 13 12:00:44 storenvy rails[26364]: Instantiation Breakdown: Total: 732 | User: 376 | Post: 323 | Comment: 32 | Blog: 1"
-
-      @oink.should parse_line(line).as(:instance_type_counter).and_capture(:pid => 26364, :instance_counts =>  {'Total' => 732, 'User' => 376, 'Post' => 323, 'Comment' => 32, 'Blog' => 1})
+      subject.should parse_line(instance_type_counter_sample).as(:instance_type_counter).and_capture(:pid => 26364, :instance_counts =>  {'Total' => 732, 'User' => 376, 'Post' => 323, 'Comment' => 32, 'Blog' => 1})
     end
   end
   
   describe '#parse_io' do
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
+    
     context "Rails 2.2 style log" do
-      before(:each) do
-        @log_parser = RequestLogAnalyzer::Source::LogParser.new(
-              RequestLogAnalyzer::FileFormat.load(:oink), :parse_strategy => 'cautious')
-      end
-
       it "should parse requests" do
-        request_counter.should_receive(:hit!).exactly(4).times
-        
-        @log_parser.parse_file(log_fixture(:oink_22)) do |request|
-          request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
-        end
+        log_parser.should_receive(:handle_request).exactly(4).times
+        log_parser.should_not_receive(:warn)
+        log_parser.parse_file(log_fixture(:oink_22))
       end
       
       it "should not record :memory_diff on first request" do
-        @log_parser.parse_file(log_fixture(:oink_22)) do |request|
-          if @log_parser.parsed_requests == 1
-            request[:memory_diff].should == nil
-          end
+        log_parser.parse_file(log_fixture(:oink_22)) do |request|
+          request[:memory_diff].should == nil if log_parser.parsed_requests == 1
         end
       end
       
       it "should record :memory_diff of 2nd tracked PID" do
-        @log_parser.parse_file(log_fixture(:oink_22)) do |request|
-          if @log_parser.parsed_requests == 3
-            request[:memory_diff].should == 50000*1024
-          end
+        log_parser.parse_file(log_fixture(:oink_22)) do |request|
+          request[:memory_diff].should == 50000 * 1024 if log_parser.parsed_requests == 3
         end
       end
       
       it "should record :memory_diff of 1st tracked PID" do
-        @log_parser.parse_file(log_fixture(:oink_22)) do |request|
-          if @log_parser.parsed_requests == 4
-            request[:memory_diff].should == 30000*1024
-          end
+        log_parser.parse_file(log_fixture(:oink_22)) do |request|
+          request[:memory_diff].should == 30000 * 1024 if log_parser.parsed_requests == 4
         end
       end
     end
     
     context 'Rails 2.2 style log w/failure' do
-      before(:each) do
-        @log_parser = RequestLogAnalyzer::Source::LogParser.new(
-              RequestLogAnalyzer::FileFormat.load(:oink), :parse_strategy => 'cautious')
-      end
-      
       it "should parse requests" do
-        request_counter.should_receive(:hit!).exactly(4).times
-        
-        @log_parser.parse_file(log_fixture(:oink_22_failure)) do |request|
-          request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails::Request) && request.completed?
-        end
+        log_parser.should_receive(:handle_request).exactly(4).times
+        log_parser.should_not_receive(:warn)
+        log_parser.parse_file(log_fixture(:oink_22_failure))
       end
       
       it "should ignore memory changes when a failure occurs" do
-        @log_parser.parse_file(log_fixture(:oink_22_failure)) do |request|
-          if @log_parser.parsed_requests == 4
-            request[:memory_diff].should == nil
-          end
+        log_parser.parse_file(log_fixture(:oink_22_failure)) do |request|
+          request[:memory_diff].should == nil if log_parser.parsed_requests == 4
         end
       end
     end

data/spec/unit/file_format/postgresql_format_spec.rb

@@ -2,36 +2,29 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Postgresql do
 
-  it "should be a valid file format" do
-    RequestLogAnalyzer::FileFormat.load(:Postgresql).should be_valid
-  end
+  subject { RequestLogAnalyzer::FileFormat.load(:Postgresql) }
+  let(:log_parser)  { RequestLogAnalyzer::Source::LogParser.new(subject) }
+  
+  it { should be_well_formed }
 
   describe '#parse_line' do
-    before(:each) do
-      @file_format = RequestLogAnalyzer::FileFormat.load(:Postgresql)
-    end
-
     it "should parse a :query line correctly" do
       line = '2010-10-10 13:52:07 GMT [38747]: [33-1] LOG:  00000: duration: 0.710 ms  statement: SELECT * FROM "delayed_jobs"'
-      @file_format.should parse_line(line).as(:query).and_capture(:timestamp => 20101010135207, :query_fragment => 'SELECT * FROM "delayed_jobs"')
+      subject.should parse_line(line).as(:query).and_capture(:timestamp => 20101010135207, :query_fragment => 'SELECT * FROM "delayed_jobs"')
     end
     
     it "should parse a :query_fragment line correctly" do
       line = '    ("failed_at", "locked_by", "created_at", "handler", "updated_at", "priority", "run_at", "attempts", "locked_at",'
-      @file_format.should parse_line(line).as(:query_fragment).and_capture(:query_fragment => '("failed_at", "locked_by", "created_at", "handler", "updated_at", "priority", "run_at", "attempts", "locked_at",')
+      subject.should parse_line(line).as(:query_fragment).and_capture(:query_fragment => '("failed_at", "locked_by", "created_at", "handler", "updated_at", "priority", "run_at", "attempts", "locked_at",')
     end
 
     it "should parse a :query line correctly" do
       line = '2010-10-10 13:52:07 GMT [38747]: [33-1] LOG:  00000: duration: 0.710 ms  statement: SELECT * FROM "delayed_jobs"'
-      @file_format.should parse_line(line).as(:query).and_capture(:query_time => 0.710)
-    end    
+      subject.should parse_line(line).as(:query).and_capture(:query_time => 0.710)
+    end
   end
 
   describe '#parse_io' do
-    before(:each) do
-      @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:postgresql))
-    end
-
     it "should parse a multiline query entry correctly" do
       fixture = <<-EOS
         2010-10-10 15:00:02 GMT [38747]: [1669-1] LOG:  00000: duration: 0.195 ms  statement: INSERT INTO "delayed_jobs" ("failed_at", "locked_by", "created_at", "handler", "updated_at", "priority", "run_at", "attempts", "locked_at", "last_error") VALUES(NULL, NULL, '2010-10-10 15:00:02.159884', E'--- !ruby/object:RuntheChooChootrain {}
@@ -39,14 +32,10 @@ describe RequestLogAnalyzer::FileFormat::Postgresql do
         2010-10-10 15:00:02 GMT [38747]: [1670-1] LOCATION:  exec_simple_query, postgres.c:1081
       EOS
 
-      request_counter.should_receive(:hit!).exactly(1).times
-      @log_parser.should_not_receive(:warn)
-      @log_parser.parse_io(StringIO.new(fixture)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Postgresql::Request) && request.completed?
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_string(fixture) do |request|
         request[:query].should == 'INSERT INTO delayed_jobs (failed_at, locked_by, created_at, handler, updated_at, priority, run_at, attempts, locked_at, last_error) VALUES(NULL, NULL, :string, E:string, :string, :int, :string, :int, NULL, NULL) RETURNING id'
       end
     end
-
   end
 end
-

data/spec/unit/file_format/rack_format_spec.rb

@@ -1,50 +1,55 @@
 require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Rack do
+  
+  subject { RequestLogAnalyzer::FileFormat.load(:rack)} 
+  let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
+  
+  it { should be_well_formed }
+  it { should have_line_definition(:access).capturing(:remote_host, :user, :remote_logname, 
+          :timestamp, :http_method, :path, :http_version, :http_status, :bytes_sent, :duration) }
+
+  it { should have(7).report_trackers }
+
+  let(:sample1) { '127.0.0.1 - - [23/Nov/2009 21:47:47] "GET /css/stylesheet.css HTTP/1.1" 200 3782 0.0024' }
+  let(:sample2) { '127.0.0.1 - - [16/Sep/2009 07:40:08] "GET /favicon.ico HTTP/1.1" 500 63183 0.0453' }
+  let(:sample3) { '127.0.0.1 - - [01/Oct/2009 07:58:10] "GET / HTTP/1.1" 200 1 0.0045' }
+  let(:irrelevant) { '== Sinatra/0.9.4 has taken the stage on 4567 for development with backup from Mongrel' }
+
+  describe '#parse_line' do
+    
+    it { should parse_line(sample1, 'a sample access line').and_capture(
+            :remote_host => '127.0.0.1', :timestamp => 20091123214747, :user => nil,
+            :http_status => 200,         :http_method => 'GET',        :http_version => '1.1',
+            :duration => 0.0024,         :bytes_sent => 3782,         :remote_logname => nil,
+            :path => '/css/stylesheet.css')
+    }
+    
+    it { should parse_line(sample2, 'another sample access line').and_capture(
+            :remote_host => '127.0.0.1', :timestamp => 20090916074008, :user => nil,
+            :http_status => 500,         :http_method => 'GET',        :http_version => '1.1',
+            :duration => 0.0453,         :bytes_sent => 63183,         :remote_logname => nil,
+            :path => '/favicon.ico')
+    }
+    
+    it { should parse_line(sample3, 'a third sample access line').and_capture(
+            :remote_host => '127.0.0.1', :timestamp => 20091001075810, :user => nil,
+            :http_status => 200,         :http_method => 'GET',        :http_version => '1.1',
+            :duration => 0.0045,         :bytes_sent => 1,             :remote_logname => nil,
+            :path => '/')
+    }
+    
+    it { should_not parse_line(irrelevant, 'an irrelevant line') }
+    it { should_not parse_line('nonsense', 'a nonsense line') }  
+  end
 
-  context '"Sinatra" access log parsing' do
-
-    before(:each) do
-      @file_format      = RequestLogAnalyzer::FileFormat.load(:rack)
-      @log_parser       = RequestLogAnalyzer::Source::LogParser.new(@file_format)    
-      @sample = '127.0.0.1 - - [23/Nov/2009 21:47:47] "GET /css/stylesheet.css HTTP/1.1" 200 3782 0.0024'
-    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(:remote_host, :timestamp, :http_method, :path, :http_version, 
-        :http_status, :bytes_sent, :duration)
-    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('== Sinatra/0.9.4 has taken the stage on 4567 for development with backup from Mongrel').should be_nil
-    end
-
-    it "should parse the sample fields correctly" do
-      match = @file_format.parse_line(@sample)
-      match.should_not be_nil
-    end
-
-    it "should parse and convert the sample fields correctly" do
-      @log_parser.parse_io(StringIO.new(@sample)) do |request|
-        request[:remote_host].should    == '127.0.0.1'
-        request[:timestamp].should      == 20091123214747
-        request[:http_method].should    == 'GET'
-        request[:path].should           == '/css/stylesheet.css'
-        request[:http_version].should   == '1.1'
-        request[:http_status].should    == 200
-        request[:bytes_sent].should     == 3782
-        request[:duration].should       == 0.0024
-      end
+  describe '#parse_io' do
+    let(:snippet) { log_snippet(irrelevant, sample1, sample2, sample3) }
+    
+    it "shouldparse a snippet without warnings" do
+      log_parser.should_receive(:handle_request).exactly(3).times
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_io(snippet)
     end
-
   end
-
-end
+end