request-log-analyzer 1.13.1 → 1.13.3

data/spec/unit/file_format/inheritance_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+class DummyInheritedFromRails3 < RequestLogAnalyzer::FileFormat::Rails3
+end
+
+describe DummyInheritedFromRails3 do
+
+  subject { RequestLogAnalyzer::FileFormat.load(DummyInheritedFromRails3) }
+
+  it { should be_well_formed }
+  it { subject.report_trackers.length.should == 11 }
+
+end

data/spec/unit/file_format/line_definition_spec.rb

@@ -2,66 +2,68 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::LineDefinition do
 
-  subject { RequestLogAnalyzer::LineDefinition.new(:test, {
-      :teaser   => /Testing /,
-      :regexp   => /Testing (\w+), tries\: (\d+)/,
-      :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer }]
-    })
-  }
+  subject do
+    RequestLogAnalyzer::LineDefinition.new(:test,
+                                           teaser: /Testing /,
+                                           regexp: /Testing (\w+), tries\: (\d+)/,
+                                           captures: [{ name: :what, type: :string }, { name: :tries, type: :integer }]
+                                                   )
+  end
 
   describe '#matches' do
 
-    it "should return false on an unmatching line" do
-      subject.matches("nonmatching").should be_false
+    it 'should return false on an unmatching line' do
+      subject.matches('nonmatching').should == false
     end
 
-    it "should return false when only the teaser matches" do
-      subject.matches("Testing LineDefinition").should be_false
+    it 'should return false when only the teaser matches' do
+      subject.matches('Testing LineDefinition').should == false
     end
 
-    it "should parse a line and capture the expected values" do
-      subject.matches("Testing LineDefinition, tries: 123").should == {:line_definition => subject, :captures => ['LineDefinition', '123'] }
+    it 'should parse a line and capture the expected values' do
+      subject.matches('Testing LineDefinition, tries: 123').should == { line_definition: subject, captures: %w(LineDefinition 123) }
     end
 
-    it "should know which names it can capture" do
-      subject.captures?(:what).should be_true
-      subject.captures?(:tries).should be_true
-      subject.captures?(:bogus).should be_false
+    it 'should know which names it can capture' do
+      subject.captures?(:what).should == true
+      subject.captures?(:tries).should == true
+      subject.captures?(:bogus).should == false
     end
   end
 
   describe '#convert_captured_values' do
-    let(:request) { double('request', :convert_value => 'foo') }
+    let(:request) { double('request', convert_value: 'foo') }
 
-    it "should call convert_value for every captured value" do
+    it 'should call convert_value for every captured value' do
       request.should_receive(:convert_value).twice
-      subject.convert_captured_values(['test', '123'], request)
+      subject.convert_captured_values(%w(test 123), request)
     end
 
-    it "should set the converted values" do
-      subject.convert_captured_values(['test', '123'], request).should == {:what => 'foo', :tries => 'foo'}
+    it 'should set the converted values' do
+      subject.convert_captured_values(%w(test 123), request).should == { what: 'foo', tries: 'foo' }
     end
 
     context 'when using :provides option' do
-      
-      subject { RequestLogAnalyzer::LineDefinition.new(:test, 
-          :regexp   => /Hash\: (\{.+\})/,
-          :captures => [{ :name => :hash, :type => :hash, :provides => {:bar => :string}}]) 
-      } 
-      
+
+      subject do
+        RequestLogAnalyzer::LineDefinition.new(:test,
+                                               regexp: /Hash\: (\{.+\})/,
+                                               captures: [{ name: :hash, type: :hash, provides: { bar: :string } }])
+      end
+
       before do
-        request.stub(:convert_value).with("{:bar=>'baz'}", anything).and_return(:bar => 'baz')
+        request.stub(:convert_value).with("{:bar=>'baz'}", anything).and_return(bar: 'baz')
         request.stub(:convert_value).with('baz', anything).and_return('foo')
       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)
+      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)
         subject.convert_captured_values(["{:bar=>'baz'}"], request)
       end
 
-      it "should return the converted hash" do
-        subject.convert_captured_values(["{:bar=>'baz'}"], request).should include(:bar => 'foo')
+      it 'should return the converted hash' do
+        subject.convert_captured_values(["{:bar=>'baz'}"], request).should include(bar: 'foo')
       end
     end
   end

data/spec/unit/file_format/merb_format_spec.rb

@@ -3,32 +3,34 @@ require 'spec_helper'
 describe RequestLogAnalyzer::FileFormat::Merb do
 
   subject { RequestLogAnalyzer::FileFormat.load(:merb) }
-  
+
   it { should be_well_formed }
   it { should have_line_definition(:started).capturing(:timestamp) }
   it { should have_line_definition(:params).capturing(:controller, :action, :namespace) }
   it { should have_line_definition(:completed).capturing(:dispatch_time, :before_filters_time, :action_time, :after_filters_time) }
-  it { should have(4).report_trackers }
+  it { should satisfy { |ff| ff.report_trackers.length == 4 } }
 
   describe '#parse_line' do
     let(:started_sample)          { '~ Started request handling: Fri Aug 29 11:10:23 +0200 2008' }
-    let(:prefixed_started_sample) { '~ Aug 31 18:35:24 typekit-web001 merb:  ~ Started request handling: Mon Aug 31 18:35:25 +0000 2009' }    
+    let(:prefixed_started_sample) { '~ Aug 31 18:35:24 typekit-web001 merb:  ~ Started request handling: Mon Aug 31 18:35:25 +0000 2009' }
     let(:params_sample)           { '~ Params: {"_method"=>"delete", "authenticity_token"=>"[FILTERED]", "action"=>"delete", "controller"=>"session"}' }
     let(:completed_sample)        { '~ {:dispatch_time=>0.006117, :after_filters_time=>6.1e-05, :before_filters_time=>0.000712, :action_time=>0.005833}' }
-    
-    it { should parse_line(started_sample, 'without prefix').as(:started).and_capture(:timestamp => 20080829111023) }
-    it { should parse_line(prefixed_started_sample, 'with prefix').as(:started).and_capture(:timestamp => 20090831183525) }
-    it { should parse_line(params_sample).as(:params).and_capture(:controller => 'session', :action => 'delete', :namespace => nil) }
-    it { should parse_line(completed_sample).as(:completed).and_capture(:dispatch_time => 0.006117, 
-              :before_filters_time => 0.000712, :action_time => 0.005833, :after_filters_time => 6.1e-05) }
+
+    it { should parse_line(started_sample, 'without prefix').as(:started).and_capture(timestamp: 20_080_829_111_023) }
+    it { should parse_line(prefixed_started_sample, 'with prefix').as(:started).and_capture(timestamp: 20_090_831_183_525) }
+    it { should parse_line(params_sample).as(:params).and_capture(controller: 'session', action: 'delete', namespace: nil) }
+    it do
+      should parse_line(completed_sample).as(:completed).and_capture(dispatch_time: 0.006117,
+              before_filters_time: 0.000712, action_time: 0.005833, after_filters_time: 6.1e-05)
+    end
 
     it { should_not parse_line('~ nonsense', 'a nonsense line') }
   end
 
   describe '#parse_io' do
-    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) } 
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
 
-    it "should parse a log fragment correctly without warnings" do
+    it 'should parse a log fragment correctly without warnings' do
       log_parser.should_receive(:handle_request).exactly(11).times
       log_parser.should_not_receive(:warn)
       log_parser.parse_file(log_fixture(:merb))

data/spec/unit/file_format/mysql_format_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe RequestLogAnalyzer::FileFormat::Mysql do
 
   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) }
@@ -11,10 +11,10 @@ describe RequestLogAnalyzer::FileFormat::Mysql do
   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 }
-  
+  it { should satisfy { |ff| ff.report_trackers.length == 7 } }
+
   describe '#parse_line' do
-    
+
     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]' }
@@ -28,15 +28,15 @@ describe RequestLogAnalyzer::FileFormat::Mysql do
     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 parse_line(time_sample).as(:time).and_capture(timestamp: 20_091_112_081_356) }
+    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: 1_191_307, rows_examined: 1_191_307) }
+    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: 1_191_307, rows_examined: 1_191_307) }
+    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) }
@@ -46,48 +46,48 @@ describe RequestLogAnalyzer::FileFormat::Mysql do
   describe '#parse_io' do
     let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
 
-    it "should parse a single line query entry correctly" do
+    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_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
+    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 
+        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)"
+        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, without warnings" do
-        fixture = <<-EOS
+    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
+    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]
@@ -102,7 +102,7 @@ describe RequestLogAnalyzer::FileFormat::Mysql do
       end
     end
 
-    it "should find 26 completed sloq query entries" do
+    it 'should find 26 completed sloq query entries' do
       log_parser.should_not_receive(:warn)
       log_parser.should_receive(:handle_request).exactly(26).times
       log_parser.parse_file(log_fixture(:mysql_slow_query))

data/spec/unit/file_format/oink_format_spec.rb

@@ -3,69 +3,69 @@ require 'spec_helper'
 describe RequestLogAnalyzer::FileFormat::Oink do
 
   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 }
+  it { should satisfy { |ff| ff.report_trackers.length == 12 } }
 
   describe '#parse_line' do
-    let(:memory_usage_sample)          { 'Jun 18 11:27:36 derek rails[67783]: Memory usage: 714052 | PID: 67783' } 
+    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" }
+    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
-      subject.should parse_line(memory_usage_sample).as(:memory_usage).and_capture(:pid => 67783, :memory => 714052)
+    it 'should parse a :memory_usage line correctly' do
+      subject.should parse_line(memory_usage_sample).as(:memory_usage).and_capture(pid: 67_783, memory: 714_052)
     end
-    
-    it "should parse the PID from a :processing line correctly" do
-      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')
+
+    it 'should parse the PID from a :processing line correctly' do
+      subject.should parse_line(processing_sample).as(:processing).and_capture(pid: 67_783, controller: 'PeopleController', action: 'index', timestamp: 20_080_814_211_630, method: 'GET', ip: '1.1.1.1')
     end
 
-    it "should parse a :instance_type_counter correctly" do
-      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})
+    it 'should parse a :instance_type_counter correctly' do
+      subject.should parse_line(instance_type_counter_sample).as(:instance_type_counter).and_capture(pid: 26_364, 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
-      it "should parse requests" do
+
+    context 'Rails 2.2 style log' do
+      it 'should parse requests' do
         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
+
+      it 'should not record :memory_diff on first request' do
         log_parser.parse_file(log_fixture(:oink_22)) do |request|
-          request[:memory_diff].should == nil if log_parser.parsed_requests == 1
+          request[:memory_diff].should.nil? if log_parser.parsed_requests == 1
         end
       end
-      
-      it "should record :memory_diff of 2nd tracked PID" do
+
+      it 'should record :memory_diff of 2nd tracked PID' do
         log_parser.parse_file(log_fixture(:oink_22)) do |request|
-          request[:memory_diff].should == 50000 * 1024 if log_parser.parsed_requests == 3
+          request[:memory_diff].should == 50_000 * 1024 if log_parser.parsed_requests == 3
         end
       end
-      
-      it "should record :memory_diff of 1st tracked PID" do
+
+      it 'should record :memory_diff of 1st tracked PID' do
         log_parser.parse_file(log_fixture(:oink_22)) do |request|
-          request[:memory_diff].should == 30000 * 1024 if log_parser.parsed_requests == 4
+          request[:memory_diff].should == 30_000 * 1024 if log_parser.parsed_requests == 4
         end
       end
     end
-    
+
     context 'Rails 2.2 style log w/failure' do
-      it "should parse requests" do
+      it 'should parse requests' do
         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
+
+      it 'should ignore memory changes when a failure occurs' do
         log_parser.parse_file(log_fixture(:oink_22_failure)) do |request|
-          request[:memory_diff].should == nil if log_parser.parsed_requests == 4
+          request[:memory_diff].should.nil? if log_parser.parsed_requests == 4
         end
       end
     end

data/spec/unit/file_format/postgresql_format_spec.rb

@@ -4,23 +4,23 @@ describe RequestLogAnalyzer::FileFormat::Postgresql do
 
   subject { RequestLogAnalyzer::FileFormat.load(:Postgresql) }
   let(:log_parser)  { RequestLogAnalyzer::Source::LogParser.new(subject) }
-  
+
   it { should be_well_formed }
 
   describe '#parse_line' do
-    it "should parse a :query line correctly" do
+    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"'
-      subject.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: 20_101_010_135_207, query_fragment: 'SELECT * FROM "delayed_jobs"')
     end
-    
-    it "should parse a :query_fragment line correctly" do
+
+    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",'
-      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",')
+      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
+    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"'
-      subject.should parse_line(line).as(:query).and_capture(:query_time => 0.710)
+      subject.should parse_line(line).as(:query).and_capture(query_time: 0.710)
     end
   end
 
@@ -31,7 +31,7 @@ describe RequestLogAnalyzer::FileFormat::Postgresql do
   #         ', '2010-10-10 15:00:02.159884', 0, '2010-10-10 16:00:00.000000', 0, NULL, NULL) RETURNING "id"
   #       2010-10-10 15:00:02 GMT [38747]: [1670-1] LOCATION:  exec_simple_query, postgres.c:1081
   #     EOS
-  # 
+  #
   #     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'

data/spec/unit/file_format/rack_format_spec.rb

@@ -1,15 +1,17 @@
 require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Rack do
-  
-  subject { RequestLogAnalyzer::FileFormat.load(:rack)} 
+
+  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 do
+    should have_line_definition(:access).capturing(:remote_host, :user, :remote_logname,
+                                                   :timestamp, :http_method, :path, :http_version, :http_status, :bytes_sent, :duration)
+  end
 
-  it { should have(7).report_trackers }
+  it { should satisfy { |ff| ff.report_trackers.length == 7 } }
 
   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' }
@@ -17,36 +19,39 @@ describe RequestLogAnalyzer::FileFormat::Rack do
   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 do
+      should parse_line(sample1, 'a sample access line').and_capture(
+            remote_host: '127.0.0.1', timestamp: 20_091_123_214_747, 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')
+    end
+
+    it do
+      should parse_line(sample2, 'another sample access line').and_capture(
+            remote_host: '127.0.0.1', timestamp: 20_090_916_074_008, user: nil,
+            http_status: 500,         http_method: 'GET',        http_version: '1.1',
+            duration: 0.0453,         bytes_sent: 63_183,         remote_logname: nil,
+            path: '/favicon.ico')
+    end
+
+    it do
+      should parse_line(sample3, 'a third sample access line').and_capture(
+            remote_host: '127.0.0.1', timestamp: 20_091_001_075_810, user: nil,
+            http_status: 200,         http_method: 'GET',        http_version: '1.1',
+            duration: 0.0045,         bytes_sent: 1,             remote_logname: nil,
+            path: '/')
+    end
+
     it { should_not parse_line(irrelevant, 'an irrelevant line') }
-    it { should_not parse_line('nonsense', 'a nonsense line') }  
+    it { should_not parse_line('nonsense', 'a nonsense line') }
   end
 
   describe '#parse_io' do
     let(:snippet) { log_snippet(irrelevant, sample1, sample2, sample3) }
-    
-    it "shouldparse a snippet without warnings" do
+
+    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)