request-log-analyzer 1.13.1 → 1.13.3

data/spec/unit/file_format/rails3_format_spec.rb

@@ -5,108 +5,108 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
   subject { RequestLogAnalyzer::FileFormat.load(:rails3) }
 
   it { should be_well_formed }
-  it { should have(11).report_trackers }
+  it { should satisfy { |ff| ff.report_trackers.length == 11 } }
 
   describe '#parse_line' do
 
-    it "should parse :started lines correctly" do
+    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'
-      subject.should parse_line(line).as(:started).and_capture(:method => 'GET',
-            :path => '/queries', :ip => '127.0.0.1', :timestamp => 20100225161518)
+      subject.should parse_line(line).as(:started).and_capture(method: 'GET',
+            path: '/queries', ip: '127.0.0.1', timestamp: 20_100_225_161_518)
     end
 
-    it "should parse :started lines in Oct, Nov and Dec correctly" do
+    it 'should parse :started lines in Oct, Nov and Dec correctly' do
       line = 'Started GET "/queries" for 127.0.0.1 at Thu Oct 25 16:15:18 -0800 2010'
-      subject.should parse_line(line).as(:started).and_capture(:method => 'GET',
-            :path => '/queries', :ip => '127.0.0.1', :timestamp => 20101025161518)
+      subject.should parse_line(line).as(:started).and_capture(method: 'GET',
+            path: '/queries', ip: '127.0.0.1', timestamp: 20_101_025_161_518)
     end
 
-    it "should parse :started lines in Ruby 1.9.2 format correctly" do
+    it 'should parse :started lines in Ruby 1.9.2 format correctly' do
       line = 'Started GET "/queries" for 127.0.0.1 at 2010-10-26 02:27:15 +0000'
-      subject.should parse_line(line).as(:started).and_capture(:method => 'GET',
-            :path => '/queries', :ip => '127.0.0.1', :timestamp => 20101026022715)
+      subject.should parse_line(line).as(:started).and_capture(method: 'GET',
+            path: '/queries', ip: '127.0.0.1', timestamp: 20_101_026_022_715)
     end
 
-    it "should parse :processing lines correctly" do
+    it 'should parse :processing lines correctly' do
       line = ' Processing by QueriesController#index as HTML'
       subject.should parse_line(line).as(:processing).and_capture(
-        :controller => 'QueriesController', :action => 'index', :format => 'HTML')
+        controller: 'QueriesController', action: 'index', format: 'HTML')
     end
 
-    it "should parse nested :processing lines correctly" do
+    it 'should parse nested :processing lines correctly' do
       line = ' Processing by Projects::QueriesController#index as HTML'
       subject.should parse_line(line).as(:processing).and_capture(
-        :controller => 'Projects::QueriesController', :action => 'index', :format => 'HTML')
+        controller: 'Projects::QueriesController', action: 'index', format: 'HTML')
     end
 
-    it "should parse :processing lines correctly with format */*" do
+    it 'should parse :processing lines correctly with format */*' do
       line = '  Processing by ProjectsController#avatar as */*'
       subject.should parse_line(line).as(:processing).and_capture(
-        :controller => 'ProjectsController', :action => 'avatar', :format => '*/*')
+        controller: 'ProjectsController', action: 'avatar', format: '*/*')
     end
 
-    it "should parse :processing lines correctly without format" do
+    it 'should parse :processing lines correctly without format' do
       line = '  Processing by ProjectsController#avatar as '
       subject.should parse_line(line).as(:processing).and_capture(
-        :controller => 'ProjectsController', :action => 'avatar', :format => '')
+        controller: 'ProjectsController', action: 'avatar', format: '')
     end
 
-    it "should parse a :parameters line correctly" do
+    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'})
+      subject.should parse_line(line).as(:parameters).and_capture(params: { action: 'cached', controller: 'cached' })
     end
 
-    it "should parse a :parameters line with no indentation correctly" do
+    it 'should parse a :parameters line with no indentation correctly' do
       line = 'Parameters: {"action"=>"cached", "controller"=>"cached"}'
-      subject.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 :completed lines correctly" do
+    it 'should parse :completed lines correctly' do
       line = 'Completed 200 OK in 170ms (Views: 78.0ms | ActiveRecord: 48.2ms)'
       subject.should parse_line(line).as(:completed).and_capture(
-          :duration => 0.170, :view => 0.078, :db => 0.0482, :status => 200)
+          duration: 0.170, view: 0.078, db: 0.0482, status: 200)
     end
 
-    it "should parse :completed lines correctly when ActiveRecord is not mentioned" do
+    it 'should parse :completed lines correctly when ActiveRecord is not mentioned' do
       line = 'Completed 200 OK in 364ms (Views: 31.4ms)'
-      subject.should parse_line(line).as(:completed).and_capture(:duration => 0.364, :status => 200)
+      subject.should parse_line(line).as(:completed).and_capture(duration: 0.364, status: 200)
     end
 
-    it "should parse :completed lines correctly when other durations are specified" do
+    it 'should parse :completed lines correctly when other durations are specified' do
       line = 'Completed 200 OK in 384ms (Views: 222.0ms | ActiveRecord: 121.0ms | Sphinx: 0.0ms)'
-      subject.should parse_line(line).as(:completed).and_capture(:duration => 0.384, :view => 0.222,
-          :db => 0.121, :status => 200)
+      subject.should parse_line(line).as(:completed).and_capture(duration: 0.384, view: 0.222,
+          db: 0.121, status: 200)
     end
 
-    it "should parse :routing_error lines correctly" do
+    it 'should parse :routing_error lines correctly' do
       line = "ActionController::RoutingError (No route matches [GET] \"/static/faq\"):"
-      subject.should parse_line(line).as(:routing_errors).and_capture(:missing_resource_method => "GET",
-          :missing_resource  => '/static/faq')
+      subject.should parse_line(line).as(:routing_errors).and_capture(missing_resource_method: 'GET',
+                                                                      missing_resource: '/static/faq')
     end
 
-    it "should parse :failure lines correctly" do
+    it 'should parse :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:"
-      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')
+      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')
     end
 
-    it "should parse :rendered lines as an array" do
-      line = " Rendered queries/index.html.erb (0.6ms)"
-      subject.should parse_line(line).as(:rendered).and_capture(:partial_duration => [0.0006])
+    it 'should parse :rendered lines as an array' do
+      line = ' Rendered queries/index.html.erb (0.6ms)'
+      subject.should parse_line(line).as(:rendered).and_capture(partial_duration: [0.0006])
     end
 
-    it "should parse :rendered lines with no identation as an array" do
-      line = "Rendered queries/index.html.erb (0.6ms)"
-      subject.should parse_line(line).as(:rendered).and_capture(:partial_duration => [0.0006])
+    it 'should parse :rendered lines with no identation as an array' do
+      line = 'Rendered queries/index.html.erb (0.6ms)'
+      subject.should parse_line(line).as(:rendered).and_capture(partial_duration: [0.0006])
     end
   end
 
   describe '#parse_io' do
     let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
 
-    it "should parse a successful request correctly" do
+    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
           Processing by QueriesController#index as HTML
@@ -121,7 +121,7 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
       log_parser.parse_string(log)
     end
 
-    it "should count partials correctly" do
+    it 'should count partials correctly' do
       log = <<-EOLOG
         Started GET "/stream_support" for 127.0.0.1 at 2012-11-21 15:21:31 +0100
         Processing by HomeController#stream_support as */*
@@ -133,7 +133,7 @@ describe RequestLogAnalyzer::FileFormat::Rails3 do
       log_parser.parse_string(log)
     end
 
-    it "should parse a failing request correctly" do
+    it 'should parse a failing request correctly' do
       log = <<-EOLOG
         Started POST "/queries/397638749/execute.csv" for 127.0.0.1 at Mon Mar 01 18:44:33 -0800 2010
           Processing by QueriesController#execute as CSV

data/spec/unit/file_format/rails_format_spec.rb

@@ -5,12 +5,12 @@ describe RequestLogAnalyzer::FileFormat::Rails do
   describe '.create' do
 
     context 'without providing a lines argument' do
-      subject { RequestLogAnalyzer::FileFormat::Rails.create } 
+      subject { RequestLogAnalyzer::FileFormat::Rails.create }
 
       it { should be_well_formed }
-      it { should have(11).report_trackers }
+      it { should satisfy { |ff| ff.report_trackers.length >= 11 } }
 
-      it "should parse the lines in the production set" do
+      it 'should parse the lines in the production set' do
         subject.line_definitions.should == RequestLogAnalyzer::FileFormat.load(:rails, 'production').line_definitions
       end
     end
@@ -19,8 +19,8 @@ describe RequestLogAnalyzer::FileFormat::Rails do
       subject {  RequestLogAnalyzer::FileFormat.load(:rails, 'minimal,failure') }
 
       it { should be_well_formed }
-      it { should have(10).report_trackers }
-      
+      it { should satisfy { |ff| ff.report_trackers.length >= 10 } }
+
       it { should have_line_definition(:processing) }
       it { should have_line_definition(:completed) }
       it { should have_line_definition(:failure) }
@@ -32,102 +32,101 @@ describe RequestLogAnalyzer::FileFormat::Rails do
         subject { RequestLogAnalyzer::FileFormat.load(:rails, constant) }
 
         it { should be_well_formed }
-        it { should have_at_least(9).report_trackers }
+        it { should satisfy { |ff| ff.report_trackers.length >= 9 } }
 
         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
 
-    {'with prefix' => 'LINE PREFIX: ', 'without prefix' => '' }.each do |context, prefix|
+    { 'with prefix' => 'LINE PREFIX: ', 'without prefix' => '' }.each do |context, prefix|
       context context do
-        it "should parse a :processing line correctly" 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]'
-          subject.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: 20_080_814_211_630, 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]'
-           subject.should parse_line(line).as(:processing).and_capture(:controller => 'PeopleController', :action => 'index', :timestamp => 20080814211630, :method => 'GET', :ip => '::1')
+
+        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]'
+          subject.should parse_line(line).as(:processing).and_capture(controller: 'PeopleController', action: 'index', timestamp: 20_080_814_211_630, 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]'
-           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')
+        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]'
+          subject.should parse_line(line).as(:processing).and_capture(controller: 'PeopleController', action: 'index', timestamp: 20_080_814_211_630, method: 'GET', ip: '3ffe:1900:4545:3:200:f8ff:fe21:67cf')
         end
 
-        it "should parse a Rails 2.1 style :completed line correctly" do
+        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]'
-          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')
+          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
+        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]'
-          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')
+          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
+        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]'
-          subject.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]"
-          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')
+
+        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]'
+          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
+        it 'should parse a :failure line with exception correctly' do
           line = prefix + "NoMethodError (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")
+          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
+        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.'
           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.'          
+        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.'
           subject.should parse_line(line).as(:cache_hit)
         end
 
-
-        it "should parse a :parameters line correctly" do
+        it 'should parse a :parameters line correctly' do
           line = prefix + '  Parameters: {"action"=>"cached", "controller"=>"cached"}'
-          subject.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
+        it 'should parse a :rendered line correctly' do
           line = prefix + 'Rendered layouts/_footer (2.9ms)'
-          subject.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
+        it 'should parse a :query_executed line with colors' do
           line = prefix + ' User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) '
-          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)')
+          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
+        it 'should parse a :query_executed line without colors' do
           line = prefix + ' User Load (0.4ms)   SELECT * FROM `users` WHERE (`users`.`id` = 18205844) '
-          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)')
+          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
+        it 'should parse a :query_cached line with colors' do
           line = prefix + ' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) '
-          subject.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
+        it 'should parse a :query_cached line without colors' do
           line = prefix + ' CACHE (0.0ms)   SELECT * FROM `users` WHERE (`users`.`id` = 0) '
-          subject.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
+        it 'should not parse an unsupported line' do
           line = prefix + 'nonsense line that should not be parsed as anything'
           subject.should_not parse_line(line)
         end
@@ -136,27 +135,27 @@ describe RequestLogAnalyzer::FileFormat::Rails do
   end
 
   describe '#parse_io' do
-    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject, :parse_strategy => 'cautious') }
+    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
+    it 'should parse a Rails 2.1 style log and find valid Rails requests without warnings' do
       log_parser.should_receive(:handle_request).exactly(4).times
       log_parser.should_not_receive(:warn)
-      log_parser.parse_file(log_fixture(:rails_1x))\
+      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
+    it 'should parse a Rails 2.2 style log and find valid Rails requests without warnings' do
       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
+    it 'should parse a Rails SyslogLogger file with prefix and find valid requests without warnings' do
       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
+    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
@@ -164,7 +163,7 @@ describe RequestLogAnalyzer::FileFormat::Rails do
       end
     end
 
-    it "should detect unordered requests in the logs" do
+    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).at_least(:twice)

data/spec/unit/file_format/w3c_format_spec.rb

@@ -5,40 +5,43 @@ describe RequestLogAnalyzer::FileFormat::W3c do
   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 do
+    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 satisfy { |ff| ff.report_trackers.length == 10 } }
 
-  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 do
+      should parse_line(sample1, 'an access line').and_capture(
+              timestamp: 20_020_524_201_801,
+              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/')
+    end
+
     it { should_not parse_line(irrelevant, 'an irrelevant line') }
     it { should_not parse_line('nonsense', 'a nonsense line') }
   end
-  
+
   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
+
+    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)

data/spec/unit/filter/anonymize_filter_spec.rb

@@ -6,16 +6,16 @@ describe RequestLogAnalyzer::Filter::Anonymize, 'anonymize request' do
     @filter = RequestLogAnalyzer::Filter::Anonymize.new(testing_format)
   end
 
-  it "should anonimize ip" do
-    @filter.filter(request(:ip => '123.123.123.123'))[:ip].should_not eql('123.123.123.123')
+  it 'should anonimize ip' do
+    @filter.filter(request(ip: '123.123.123.123'))[:ip].should_not eql('123.123.123.123')
   end
 
-  it "should anonimize url" do
-    @filter.filter(request(:url => 'https://test.mysite.com/employees'))[:url].should eql('http://example.com/employees')
+  it 'should anonimize url' do
+    @filter.filter(request(url: 'https://test.mysite.com/employees'))[:url].should eql('http://example.com/employees')
   end
 
-  it "should fuzz durations" do
-    @filter.filter(request(:duration => 100))[:duration].should_not eql(100)
+  it 'should fuzz durations' do
+    @filter.filter(request(duration: 100))[:duration].should_not eql(100)
   end
 
-end
+end