request-log-analyzer 1.10.1 → 1.11.0

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

data/spec/unit/file_format/rails3_format_spec.rb

@@ -3,12 +3,11 @@ require 'spec_helper'
 describe RequestLogAnalyzer::FileFormat::Rails3 do
 
   subject { RequestLogAnalyzer::FileFormat.load(:rails3) }
-  let(:log_parser) {RequestLogAnalyzer::Source::LogParser.new(subject) }
   
-  it { should be_valid }
-
+  it { should be_well_formed }
+  it { should have(9).report_trackers }
+  
   describe '#parse_line' do
-    before(:each) { @file_format = RequestLogAnalyzer::FileFormat.load(:rails3) }
 
     it "should parse :started lines correctly" do
       line = 'Started GET "/queries" for 127.0.0.1 at Thu Feb 25 16:15:18 -0800 2010'
@@ -51,6 +50,11 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
       subject.should parse_line(line).as(:processing).and_capture(
         :controller => 'ProjectsController', :action => 'avatar', :format => '')
     end
+
+    it "should parse a :parameters line correctly" do
+      line = '  Parameters: {"action"=>"cached", "controller"=>"cached"}'
+      subject.should parse_line(line).as(:parameters).and_capture(:params => {:action => 'cached', :controller => 'cached'})
+    end
     
     it "should parse :completed lines correctly" do
       line = 'Completed 200 OK in 170ms (Views: 78.0ms | ActiveRecord: 48.2ms)'
@@ -72,7 +76,7 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
 
     it "should pase :failure lines correctly" do
       line = "ActionView::Template::Error (undefined local variable or method `field' for #<Class>) on line #3 of /Users/willem/Code/warehouse/app/views/queries/execute.csv.erb:"
-      @file_format.should parse_line(line).as(:failure).and_capture(:line => 3, 
+      subject.should parse_line(line).as(:failure).and_capture(:line => 3, 
           :error   => 'ActionView::Template::Error', 
           :message => "undefined local variable or method `field' for #<Class>", 
           :file    => '/Users/willem/Code/warehouse/app/views/queries/execute.csv.erb')
@@ -80,6 +84,8 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
   end
   
   describe '#parse_io' do
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
+
     it "should parse a successful request correctly" do
       log = <<-EOLOG
         Started GET "/" for 127.0.0.1 at Fri Mar 19 06:40:41 -0700 2010
@@ -90,12 +96,9 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
         Completed 200 OK in 170ms (Views: 78.4ms | ActiveRecord: 48.2ms)
       EOLOG
       
-      request_counter.should_receive(:hit!).once
+      log_parser.should_receive(:handle_request).once
       log_parser.should_not_receive(:warn)
-      
-      log_parser.parse_io(StringIO.new(log)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails3::Request) && request.completed?
-      end
+      log_parser.parse_string(log)
     end
     
     it "should parse an unroutable request correctly" do
@@ -109,12 +112,9 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
       
       EOLOG
 
-      request_counter.should_receive(:hit!).once
+      log_parser.should_receive(:handle_request).once
       log_parser.should_not_receive(:warn)
-      
-      log_parser.parse_io(StringIO.new(log)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails3::Request) && request.completed?
-      end
+      log_parser.parse_string(log)
     end
     
     it "should parse a failing request correctly" do
@@ -141,12 +141,9 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
 
       EOLOG
 
-      request_counter.should_receive(:hit!).once
+      log_parser.should_receive(:handle_request).once
       log_parser.should_not_receive(:warn)
-      
-      log_parser.parse_io(StringIO.new(log)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Rails3::Request) && request.completed?
-      end
+      log_parser.parse_string(log)
     end
   end
 end

data/spec/unit/file_format/rails_format_spec.rb

@@ -5,186 +5,170 @@ describe RequestLogAnalyzer::FileFormat::Rails do
   describe '.create' do
 
     context 'without providing a lines argument' do
-      before(:each) { @rails = RequestLogAnalyzer::FileFormat.load(:rails) }
+      subject { RequestLogAnalyzer::FileFormat::Rails.create } 
 
-      it "should create a valid file format" do
-        @rails.should be_valid
-      end
+      it { should be_well_formed }
+      it { should have(11).report_trackers }
 
-      it "should parse the production lines" do
-        production_rails = RequestLogAnalyzer::FileFormat.load(:rails, 'production')
-        @rails.line_definitions.should == production_rails.line_definitions
+      it "should parse the lines in the production set" do
+        subject.line_definitions.should == RequestLogAnalyzer::FileFormat.load(:rails, 'production').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
+      subject {  RequestLogAnalyzer::FileFormat.load(:rails, 'minimal,failure') }
 
-      it "should at least parse :processing and :completed lines" do
-        @rails.line_definitions.should include(:processing, :completed, :failure)
-      end
+      it { should be_well_formed }
+      it { should have(10).report_trackers }
+      
+      it { should have_line_definition(:processing) }
+      it { should have_line_definition(:completed) }
+      it { should have_line_definition(:failure) }
     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) }
+        subject { RequestLogAnalyzer::FileFormat.load(:rails, constant) }
 
-        it "should return a valid language" do
-          @rails.should be_valid
-        end
+        it { should be_well_formed }
+        it { should have_at_least(9).report_trackers }
 
-        it "should at least parse :processing and :completed lines" do
-          @rails.line_definitions.should include(:processing, :completed)
-        end
+        it { should have_line_definition(:processing) }
+        it { should have_line_definition(:completed) }
       end
     end
   end
+  
+  subject { RequestLogAnalyzer::FileFormat.load(:rails, :all) }
 
   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')
+          subject.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')
+           subject.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')
+           subject.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')
+          subject.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')
+          subject.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 Rails 2.2 style :completed line correctly when AR is disabled" do
           line = prefix + 'Completed in 597ms (View: 298 | 200 OK [http://shapado.com]'
-          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.597, :db => nil, :view => 0.298, :status => 200, :url => 'http://shapado.com')
+          subject.should parse_line(line).as(:completed).and_capture(:duration => 0.597, :db => nil, :view => 0.298, :status => 200, :url => 'http://shapado.com')
         end
         
         it "should parse a Rails 2.2 style :completed line without view" do
           line = prefix + "Completed in 148ms (DB: 0) | 302 Found [http://iwp-sod.hargray.org/login]"
-          @rails.should parse_line(line).as(:completed).and_capture(:duration => 0.148, :db => 0.0, :view => nil, :status => 302, :url => 'http://iwp-sod.hargray.org/login')
+          subject.should parse_line(line).as(:completed).and_capture(:duration => 0.148, :db => 0.0, :view => nil, :status => 302, :url => 'http://iwp-sod.hargray.org/login')
         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")
+          subject.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)
+          subject.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)
+          subject.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'})
+          subject.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)
+          subject.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)')
+          subject.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)')
+          subject.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)')
+          subject.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)')
+          subject.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)
+          subject.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
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject, :parse_strategy => 'cautious') }
 
     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
+      log_parser.should_receive(:handle_request).exactly(4).times
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_file(log_fixture(:rails_1x))\
     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
+      log_parser.should_receive(:handle_request).once
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_file(log_fixture(:rails_22))
     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
+      log_parser.should_receive(:handle_request).once
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_file(log_fixture(:syslog_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|
+      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))
+      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).at_least(:twice)
+      log_parser.parse_file(log_fixture(:rails_unordered))
     end
   end
 end

data/spec/unit/file_format/w3c_format_spec.rb

@@ -2,45 +2,46 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::W3c do
 
-  before(:each) do
-    @file_format = RequestLogAnalyzer::FileFormat.load(:w3c)
-    @log_parser  = RequestLogAnalyzer::Source::LogParser.new(@file_format)  
-    #          date       time     c-ip cs-username s-ip     s-port  cs-method cs-uri-stem cs-uri-query sc-status sc-bytes cs-bytes time-taken cs(User-Agent) cs(Referrer) 
-    @sample = '2002-05-24 20:18:01 172.224.24.114 - 206.73.118.24 80 GET /Default.htm - 200 7930 248 31 Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server) http://64.224.24.114/'
+  subject { RequestLogAnalyzer::FileFormat.load(:w3c) }
+
+  it { should be_well_formed }
+  it { should have_line_definition(:access).capturing(:timestamp, :remote_ip, :username, :local_ip, :port,
+            :method, :path, :http_status, :bytes_sent, :bytes_received, :duration, :user_agent, :referer) }
+
+  it { should have(10).report_trackers }
+  
+  let(:sample1) { '2002-05-24 20:18:01 172.224.24.114 - 206.73.118.24 80 GET /Default.htm - 200 7930 248 31 Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server) http://64.224.24.114/' }
+  let(:irrelevant) { '#Software: Microsoft Internet Information Services 6.0' }
+  
+  describe '#parse_line' do
+    it { should parse_line(sample1, 'an access line').and_capture(
+              :timestamp      => 20020524201801,
+              :remote_ip      => "172.224.24.114",
+              :username       => nil,
+              :local_ip       => "206.73.118.24",
+              :port           => 80,
+              :method         => 'GET',
+              :path           => '/Default.htm',
+              :http_status    => 200,
+              :bytes_sent     => 7930,
+              :bytes_received => 248,
+              :duration       => 0.031,
+              :user_agent     => 'Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server)',
+              :referer        => 'http://64.224.24.114/')
+    }
+    
+    it { should_not parse_line(irrelevant, 'an irrelevant line') }
+    it { should_not parse_line('nonsense', 'a nonsense line') }
   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(:timestamp, :remote_ip, :username, :local_ip, :port, :method, :path, :http_status, :bytes_sent, :bytes_received, :duration, :user_agent, :referer)
-  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('#Software: Microsoft Internet Information Services 6.0').should be_nil
-  end
-
-  it "should parse and convert the sample fields correctly" do
-    @log_parser.parse_io(StringIO.new(@sample)) do |request|
-      request[:timestamp].should      == 20020524201801
-      request[:remote_ip].should      == "172.224.24.114"
-      request[:username].should       == nil
-      request[:local_ip].should       == "206.73.118.24"
-      request[:port].should           == 80
-      request[:method].should         == 'GET'
-      request[:path].should           == '/Default.htm'
-      request[:http_status].should    == 200
-      request[:bytes_sent].should     == 7930
-      request[:bytes_received].should == 248
-      request[:duration].should       == 0.031
-      request[:user_agent].should     == 'Mozilla/4.0+(compatible;+MSIE+5.01;+Windows+2000+Server)'
-      request[:referer].should        == 'http://64.224.24.114/'
+  
+  describe '#parse_io' do
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
+    let(:snippet) { log_snippet(irrelevant, sample1, sample1) }
+    
+    it "should parse a snippet successully without warnings" do
+      log_parser.should_receive(:handle_request).twice
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_io(snippet)
     end
   end
-
-end
+end