request-log-analyzer 1.10.1 → 1.11.0

data/spec/unit/file_format/delayed_job2_format_spec.rb

@@ -1,41 +1,39 @@
 require 'spec_helper'
 
-describe RequestLogAnalyzer::FileFormat::DelayedJob do
+describe RequestLogAnalyzer::FileFormat::DelayedJob2 do
 
-  it "should be a valid file format" do
-    RequestLogAnalyzer::FileFormat.load(:delayed_job).should be_valid
-  end
+  subject { RequestLogAnalyzer::FileFormat.load(:delayed_job2) }
 
+  it { should be_well_formed }
+  it { should have_line_definition(:job_lock).capturing(:timestamp, :job, :host, :pid) }
+  it { should have_line_definition(:job_completed).capturing(:timestamp, :duration, :host, :pid) }  
+  it { should have(4).report_trackers }
+  
   describe '#parse_line' do
     
-    before(:each) do
-      @file_format = RequestLogAnalyzer::FileFormat.load(:delayed_job2)
-    end
+    let(:job_lock_sample1)     { "2010-05-17T17:37:34+0000: * [Worker(delayed_job host:hostname.co.uk pid:11888)] acquired lock on S3FileJob" }
+    let(:job_lock_sample2)     { "2010-05-17T17:37:34+0000: * [Worker(delayed_job.0 host:hostname.co.uk pid:11888)] acquired lock on S3FileJob" }
+    let(:job_completed_sample) { '2010-05-17T17:37:35+0000: * [JOB] delayed_job host:hostname.co.uk pid:11888 completed after 1.0676' }
+    let(:starting_sample)      { '2010-05-17T17:36:44+0000: *** Starting job worker delayed_job host:hostname.co.uk pid:11888' } 
+    let(:summary_sample)       { '3 jobs processed at 0.3163 j/s, 0 failed ...' }
+    
+    it { should parse_line(job_lock_sample1, 'with a single worker').as(:job_lock).and_capture(
+                    :timestamp => 20100517173734, :job => 'S3FileJob', :host => 'hostname.co.uk', :pid => 11888) }
 
-    it "should parse a :job_lock line correctly" do
-      line = "2010-05-17T17:37:34+0000: * [Worker(delayed_job host:hostname.co.uk pid:11888)] acquired lock on S3FileJob"
-      @file_format.should parse_line(line).as(:job_lock).and_capture(:timestamp => 20100517173734,
-                                    :job => 'S3FileJob', :host => 'hostname.co.uk', :pid => 11888)
-    end
+    it { should parse_line(job_lock_sample2, 'with multiple workers').as(:job_lock).and_capture(
+                    :timestamp => 20100517173734, :job => 'S3FileJob', :host => 'hostname.co.uk', :pid => 11888) }
 
-    it "should parse a :job_lock line correctly when the worker is one of many" do
-      line = "2010-05-17T17:37:34+0000: * [Worker(delayed_job.0 host:hostname.co.uk pid:11888)] acquired lock on S3FileJob"
-      @file_format.should parse_line(line).as(:job_lock).and_capture(:timestamp => 20100517173734,
-                                    :job => 'S3FileJob', :host => 'hostname.co.uk', :pid => 11888)
-    end
+    it { should parse_line(job_completed_sample).as(:job_completed).and_capture(:timestamp => 20100517173735,
+                    :duration => 1.0676, :host => 'hostname.co.uk', :pid => 11888) }
 
-    it "should parse a :job_completed line correctly" do
-      line = '2010-05-17T17:37:35+0000: * [JOB] delayed_job host:hostname.co.uk pid:11888 completed after 1.0676'
-      @file_format.should parse_line(line).as(:job_completed).and_capture(:timestamp => 20100517173735,
-                                    :duration => 1.0676, :host => 'hostname.co.uk', :pid => 11888)
-    end
+    it { should_not parse_line(starting_sample, 'a starting line') }
+    it { should_not parse_line(summary_sample, 'a summary line') }
+    it { should_not parse_line('nonsense', 'a nonsense line') }
   end
   
   describe '#parse_io' do
-    before(:each) do
-      @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:delayed_job2))
-    end
-    
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
+
     it "should parse a batch of completed jobs without warnings" do
       fragment = <<-EOLOG
         2010-05-17T17:36:44+0000: *** Starting job worker delayed_job host:hostname.co.uk pid:11888
@@ -49,12 +47,9 @@ describe RequestLogAnalyzer::FileFormat::DelayedJob do
         2010-05-19T11:47:26+0000: Exiting...
       EOLOG
 
-      request_counter.should_receive(:hit!).exactly(3).times
-      @log_parser.should_not_receive(:warn)
-
-      @log_parser.parse_io(StringIO.new(fragment)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::DelayedJob2::Request)
-      end
+      log_parser.should_receive(:handle_request).exactly(3).times
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_string(fragment)
     end
   end
 end

data/spec/unit/file_format/delayed_job_format_spec.rb

@@ -1,83 +1,64 @@
 require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::DelayedJob do
+  
+  subject { RequestLogAnalyzer::FileFormat.load(:delayed_job) }
 
-  it "should be a valid file format" do
-    RequestLogAnalyzer::FileFormat.load(:delayed_job).should be_valid
-  end
+  it { should be_well_formed }
+  it { should have_line_definition(:job_lock).capturing(:job) }
+  it { should have_line_definition(:job_completed).capturing(:completed_job, :duration) }
+  it { should have_line_definition(:job_lock_failed).capturing(:locked_job) }
+  it { should have_line_definition(:job_failed).capturing(:failed_job, :attempts, :exception) }
+  it { should have(3).report_trackers }
 
   describe '#parse_line' do
-    before(:each) do
-      @file_format = RequestLogAnalyzer::FileFormat.load(:delayed_job)
-    end
+    let(:job_lock_sample)        { '* [JOB] acquiring lock on BackgroundJob::ThumbnailSaver' }
+    let(:job_completed_sample)   { '* [JOB] BackgroundJob::ThumbnailSaver completed after 0.7932' }
+    let(:job_lock_failed_sample) { '* [JOB] failed to acquire exclusive lock for BackgroundJob::ThumbnailSaver' }
+    let(:job_failed_sample)      { "* [JOB] BackgroundJob::ThumbnailSaver failed with ActiveRecord::RecordNotFound: Couldn't find Design with ID=20413443 - 1 failed attempts" }  
+    let(:summary_sample)         { '1 jobs processed at 1.0834 j/s, 0 failed ...' }
 
-    it "should parse a :job_lock line correctly" do
-      line = "* [JOB] acquiring lock on BackgroundJob::ThumbnailSaver"
-      @file_format.should parse_line(line).as(:job_lock).and_capture(:job => 'BackgroundJob::ThumbnailSaver')
-    end
-
-    it "should parse a :job_completed line correctly" do
-      line = '* [JOB] BackgroundJob::ThumbnailSaver completed after 0.7932'
-      @file_format.should parse_line(line).as(:job_completed).and_capture(
-        :duration => 0.7932, :completed_job => 'BackgroundJob::ThumbnailSaver')
-    end
-    
-    it "should pase a :job_failed line correctly" do
-      line = "* [JOB] BackgroundJob::ThumbnailSaver failed with ActiveRecord::RecordNotFound: Couldn't find Design with ID=20413443 - 1 failed attempts"
-      @file_format.should parse_line(line).as(:job_failed).and_capture(:attempts => 1,
-        :failed_job => 'BackgroundJob::ThumbnailSaver', :exception => 'ActiveRecord::RecordNotFound')
-    end
-    
-    it "should parse a failed job lock line correctly" do
-      line = "* [JOB] failed to acquire exclusive lock for BackgroundJob::ThumbnailSaver"
-      @file_format.should parse_line(line).as(:job_lock_failed).and_capture(:locked_job => 'BackgroundJob::ThumbnailSaver')
-    end
-    
-    # it "should pase a :batch_completed line correctly" do
-    #   line = '1 jobs processed at 1.0834 j/s, 0 failed ...'
-    #   @file_format.should parse_line(line).as(:batch_completed).and_capture(
-    #     :mean_duration => 0.7932, :total_amount => 1, :failed_amount => 0) 
-    # end
+    it { should parse_line(job_lock_sample).as(:job_lock).and_capture(:job => 'BackgroundJob::ThumbnailSaver') }
+    it { should parse_line(job_completed_sample).as(:job_completed).and_capture(:duration => 0.7932, :completed_job => 'BackgroundJob::ThumbnailSaver') }
+    it { should parse_line(job_lock_failed_sample).as(:job_lock_failed).and_capture(:locked_job => 'BackgroundJob::ThumbnailSaver') }
+    it { should parse_line(job_failed_sample).as(:job_failed).and_capture(:attempts => 1, :failed_job => 'BackgroundJob::ThumbnailSaver', :exception => 'ActiveRecord::RecordNotFound') }
 
+    it { should_not parse_line(summary_sample, 'a summary line') }
+    it { should_not parse_line('nonsense', 'a nonsense line') }
   end
-  
+
   describe '#parse_io' do
-    before(:each) do
-      @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:delayed_job))
-    end
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) } 
     
     it "should parse a batch of completed jobs without warnings" do
-      fragment = "* [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
-                  * [JOB] BackgroundJob::ThumbnailSaver completed after 0.9114
-                  * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
-                  * [JOB] BackgroundJob::ThumbnailSaver completed after 0.9110
-                  2 jobs processed at 1.0832 j/s, 0 failed ..."
-
-      request_counter.should_receive(:hit!).exactly(2).times
-      @log_parser.should_not_receive(:warn)
+      fragment = log_snippet(<<-EOLOG)
+          * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
+          * [JOB] BackgroundJob::ThumbnailSaver completed after 0.9114
+          * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
+          * [JOB] BackgroundJob::ThumbnailSaver completed after 0.9110
+          2 jobs processed at 1.0832 j/s, 0 failed ...
+      EOLOG
 
-      @log_parser.parse_io(StringIO.new(fragment)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::DelayedJob::Request)
-      end
+      log_parser.should_receive(:handle_request).twice
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_io(fragment)
     end
     
     it "should parse a batch with a failed job without warnings" do
-      fragment = "* [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
-                  * [JOB] BackgroundJob::ThumbnailSaver completed after 1.0627
-                  * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
-                  * [JOB] BackgroundJob::ThumbnailSaver failed with ActiveRecord::RecordNotFound: Couldn't find Design with ID=20413443 - 3 failed attempts
-                  Couldn't find Design with ID=20413443
-                  * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
-                  * [JOB] failed to acquire exclusive lock for BackgroundJob::ThumbnailSaver
-                  2 jobs processed at 1.4707 j/s, 1 failed ..."
+      fragment = log_snippet(<<-EOLOG)
+          * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
+          * [JOB] BackgroundJob::ThumbnailSaver completed after 1.0627
+          * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
+          * [JOB] BackgroundJob::ThumbnailSaver failed with ActiveRecord::RecordNotFound: Couldn't find Design with ID=20413443 - 3 failed attempts
+          Couldn't find Design with ID=20413443
+          * [JOB] acquiring lock on BackgroundJob::ThumbnailSaver
+          * [JOB] failed to acquire exclusive lock for BackgroundJob::ThumbnailSaver
+          2 jobs processed at 1.4707 j/s, 1 failed ...
+      EOLOG
 
-      request_counter.should_receive(:hit!).exactly(3).times
-      @log_parser.should_not_receive(:warn)
-
-      @log_parser.parse_io(StringIO.new(fragment)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::DelayedJob::Request)
-      end
+      log_parser.should_receive(:handle_request).exactly(3).times
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_io(fragment)
     end
   end
 end
-

data/spec/unit/file_format/haproxy_format_spec.rb

@@ -2,83 +2,81 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Haproxy do
 
-  before(:each) do
-    @file_format = RequestLogAnalyzer::FileFormat.load(:haproxy)
-    @log_parser  = RequestLogAnalyzer::Source::LogParser.new(@file_format)
-    @sample1 = 'Feb  6 12:14:14 localhost haproxy[14389]: 10.0.1.2:33317 [06/Feb/2009:12:14:14.655] http-in static/srv1 10/0/30/69/109 200 2750 - - ---- 1/1/1/1/0 0/0 {1wt.eu} {} "GET /index.html HTTP/1.1"'
-    @sample2 = 'haproxy[18113]: 127.0.0.1:34549 [15/Oct/2003:15:19:06.103] px-http px-http/<NOSRV> -1/-1/-1/-1/+50001 408 +2750 - - cR-- 2/2/2/0/+2 0/0 ""'
-  end
+  subject { RequestLogAnalyzer::FileFormat.load(:haproxy) }
+  let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
 
-  it "should be a valid file format" do
-    @file_format.should be_valid
-  end
+  it { should be_well_formed }
 
-  it "should parse access lines and capture all of its fields" do
-    @file_format.should have_line_definition(:haproxy).capturing(:client_ip, :accept_date, :frontend_name, :backend_name, :server_name, :tq, :tw, :tc, :tr, :tt, :status_code, :bytes_read, :captured_request_cookie, :captured_response_cookie, :termination_event_code, :terminated_session_state, :clientside_persistence_cookie, :serverside_persistence_cookie, :actconn, :feconn, :beconn, :srv_conn, :retries, :srv_queue, :backend_queue, :captured_request_headers, :captured_response_headers, :http_request)
-  end
+  it { should have_line_definition(:haproxy13).capturing(:client_ip, :timestamp, :frontend_name, :backend_name, :server_name, :tq, :tw, :tc, :tr, :tt, :status_code, :bytes_read, :captured_request_cookie, :captured_response_cookie, :termination_event_code, :terminated_session_state, :clientside_persistence_cookie, :serverside_persistence_cookie, :actconn, :feconn, :beconn, :srv_conn, :retries, :srv_queue, :backend_queue, :captured_request_headers, :captured_response_headers, :http_request) }
+  it { should have_line_definition(:haproxy12).capturing(:client_ip, :timestamp, :frontend_name, :server_name, :tq, :tw, :tc, :tr, :tt, :status_code, :bytes_read, :captured_request_cookie, :captured_response_cookie, :termination_event_code, :terminated_session_state, :clientside_persistence_cookie, :serverside_persistence_cookie, :srv_conn, :listener_conn, :process_conn, :srv_queue, :backend_queue, :captured_request_headers, :captured_response_headers, :http_request) }
+  it { should have_line_definition(:haproxy11).capturing(:client_ip, :timestamp, :frontend_name, :server_name, :tq, :tc, :tr, :tt, :status_code, :bytes_read, :captured_request_cookie, :captured_response_cookie, :termination_event_code, :terminated_session_state, :clientside_persistence_cookie, :serverside_persistence_cookie, :listener_conn, :process_conn, :captured_request_headers, :captured_response_headers, :http_request) }
 
-  it "should match the sample line" do
-    @file_format.parse_line(@sample1).should include(:line_definition, :captures)
-  end
+  it { should have(14).report_trackers }
 
-  it "should not match a nonsense line" do
-    @file_format.parse_line('dsadasdas dsaadsads dsaadsads').should be_nil
-  end
+  let(:sample_haproxy13) { 'Feb  6 12:14:14 localhost haproxy[14389]: 10.0.1.2:33317 [06/Feb/2009:12:14:14.655] http-in static/srv1 10/0/30/69/109 200 2750 - - ---- 1/1/1/1/0 0/0 {1wt.eu} {} "GET /index.html HTTP/1.1"' }
+  let(:sample_haproxy12) { 'Mar 15 06:36:49 localhost haproxy[9367]: 127.0.0.1:38990 [15/Mar/2011:06:36:45.103] as-proxy mc-search-2 0/0/0/730/731 200 29404 - - --NN 2/54/54 0/0 {66.249.68.216} {} "GET /neighbor/26014153 HTTP/1.0" ' }
+  let(:sample_haproxy11) { 'haproxy[674]: 127.0.0.1:33320 [15/Oct/2003:08:32:17] relais-http Srv1 9/7/14/30 502 243 - - PH-- 2/3 "GET /cgi-bin/bug.cgi? HTTP/1.0"' }
+  let(:sample_errors)    { 'haproxy[18113]: 127.0.0.1:34549 [15/Oct/2003:15:19:06.103] px-http px-http/<NOSRV> -1/-1/-1/-1/+50001 408 +2750 - - cR-- 2/2/2/0/+2 0/0 ""' }
 
-  it "should parse and convert the sample fields correctly" do
-    @log_parser.parse_io(StringIO.new(@sample1)) do |request|
-      request[:client_ip].should                      == '10.0.1.2'
-      request[:accept_date].should                    == 20090206121414
-      request[:frontend_name].should                  == 'http-in'
-      request[:backend_name].should                   == 'static'
-      request[:server_name].should                    == 'srv1'
-      request[:tq].should                             == 0.010
-      request[:tw].should                             == 0.000
-      request[:tc].should                             == 0.030
-      request[:tr].should                             == 0.069
-      request[:tt].should                             == 0.109
-      request[:status_code].should                    == 200
-      request[:bytes_read].should                     == 2750
-      request[:captured_request_cookie].should        == nil
-      request[:captured_response_cookie].should       == nil
-      request[:termination_event_code].should         == nil
-      request[:terminated_session_state].should       == nil
-      request[:clientside_persistence_cookie].should  == nil
-      request[:serverside_persistence_cookie].should  == nil
-      request[:actconn].should                        == 1
-      request[:feconn].should                         == 1
-      request[:beconn].should                         == 1
-      request[:srv_conn].should                       == 1
-      request[:retries].should                        == 0
-      request[:srv_queue].should                      == 0
-      request[:backend_queue].should                  == 0
-      request[:captured_request_headers].should       == '{1wt.eu}'
-      request[:captured_response_headers].should      == nil
-      request[:http_request].should                   == 'GET /index.html HTTP/1.1'
-    end
-  end
+  describe '#parse_line' do
+    it { should parse_line(sample_haproxy13, 'an haproxy 1.3 access line').and_capture(
+            :client_ip => '10.0.1.2',     :tq => 0.010,   :captured_request_cookie => nil,
+            :timestamp => 20090206121414, :tw => 0.000,   :captured_response_cookie => nil,
+            :frontend_name => 'http-in',  :tc => 0.030,   :clientside_persistence_cookie => nil,
+            :backend_name => 'static',    :tr => 0.069,   :serverside_persistence_cookie => nil,
+            :server_name => 'srv1',       :tt => 0.109,   :termination_event_code => nil,
+            :status_code => 200,          :actconn => 1,  :terminated_session_state => nil,
+            :bytes_read => 2750,          :feconn => 1,   :captured_request_headers => '{1wt.eu}',
+            :backend_queue => 0,          :beconn => 1,   :captured_response_headers => nil,
+            :retries => 0,                :srv_conn => 1, :srv_queue => 0,
+            :http_request => 'GET /index.html HTTP/1.1')
+    }
+
+    it { should parse_line(sample_haproxy12, 'an haproxy 1.2 access line').and_capture(
+            :client_ip => '127.0.0.1',    :tq => 0.000,         :captured_request_cookie => nil,
+            :timestamp => 20110315063645, :tw => 0.000,         :captured_response_cookie => nil,
+            :frontend_name => 'as-proxy', :tc => 0.000,         :clientside_persistence_cookie => 'N',
+            :server_name => 'mc-search-2',:tr => 0.730,         :serverside_persistence_cookie => 'N',
+            :status_code => 200,          :tt => 0.731,         :termination_event_code => nil,
+            :bytes_read => 29404,         :listener_conn => 54, :terminated_session_state => nil,
+            :backend_queue => 0,          :process_conn => 54,  :captured_request_headers => '{66.249.68.216}',
+            :srv_queue => 0,              :srv_conn => 2,       :captured_response_headers => nil,
+            :http_request => 'GET /neighbor/26014153 HTTP/1.0')
+    }
 
-  it "should parse and convert edge case sample fields correctly" do
-    @log_parser.parse_io(StringIO.new(@sample2)) do |request|
-      request[:accept_date].should                    == 20031015151906
-      request[:server_name].should                    == '<NOSRV>'
-      request[:tq].should                             == nil
-      request[:tw].should                             == nil
-      request[:tc].should                             == nil
-      request[:tr].should                             == nil
-      request[:tt].should                             == 50.001
-      request[:bytes_read].should                     == 2750
-      request[:captured_request_cookie].should        == nil
-      request[:captured_response_cookie].should       == nil
-      request[:termination_event_code].should         == 'c'
-      request[:terminated_session_state].should       == 'R'
-      request[:clientside_persistence_cookie].should  == nil
-      request[:serverside_persistence_cookie].should  == nil
-      request[:retries].should                        == 2
-      request[:captured_request_headers].should       == nil
-      request[:captured_response_headers].should      == nil
-      request[:http_request].should                   == nil
+    it { should parse_line(sample_haproxy11, 'an haproxy 1.1 access line').and_capture(
+            :client_ip => '127.0.0.1',      :tq => 0.009,       :captured_request_cookie => nil,
+            :timestamp => 20031015083217,   :tc => 0.007,       :captured_response_cookie => nil,
+            :frontend_name => 'relais-http',:tr => 0.014,       :clientside_persistence_cookie => nil,
+            :server_name => 'Srv1',         :tt => 0.030,       :serverside_persistence_cookie => nil,
+            :status_code => 502,            :listener_conn => 2,:termination_event_code => 'P',
+            :bytes_read => 243,             :process_conn => 3, :terminated_session_state => 'H',
+            :captured_request_headers => nil,                   :captured_response_headers => nil,
+            :http_request => nil)
+    }
+    
+    it { should parse_line(sample_errors, 'a failed access line').and_capture(
+            :timestamp => 20031015151906, :tq => nil,    :captured_request_cookie => nil,
+            :server_name => '<NOSRV>',    :tw => nil,    :captured_response_cookie => nil,
+            :bytes_read => 2750,          :tc => nil,    :clientside_persistence_cookie => nil,
+            :retries => 2,                :tr => nil,    :serverside_persistence_cookie => nil,
+            :http_request => nil,         :tt => 50.001, :termination_event_code => 'c',
+                                                         :terminated_session_state => 'R',
+                                                         :captured_request_headers => nil,
+                                                         :captured_response_headers => nil)
+    }
+    
+    it { should_not parse_line('nonsense') }
+  end
+  
+  describe '#parse_io' do
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) }
+    let(:snippet)    { log_snippet(sample_haproxy13, sample_haproxy12, sample_haproxy11, sample_errors, 'nonsense') }
+    
+    it "should parse a log snippet without warnings" do
+      log_parser.should_receive(:handle_request).exactly(4).times
+      log_parser.should_not_receive(:warn)
+      log_parser.parse_io(snippet)
     end
   end
-
 end

data/spec/unit/file_format/line_definition_spec.rb

@@ -2,74 +2,67 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::LineDefinition do
 
-  before(:each) do
-    @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, {
+  subject { 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
-      @line_definition.matches("nonmatching").should be_false
+      subject.matches("nonmatching").should be_false
     end
 
     it "should return false when only the teaser matches" do
-      @line_definition.matches("Testing LineDefinition").should be_false
+      subject.matches("Testing LineDefinition").should be_false
     end
 
     it "should parse a line and capture the expected values" do
-      @line_definition.matches("Testing LineDefinition, tries: 123").should == {:line_definition => @line_definition, :captures => ['LineDefinition', '123'] }
+      subject.matches("Testing LineDefinition, tries: 123").should == {:line_definition => subject, :captures => ['LineDefinition', '123'] }
     end
 
     it "should know which names it can capture" do
-      @line_definition.captures?(:what).should be_true
-      @line_definition.captures?(:tries).should be_true
-      @line_definition.captures?(:bogus).should be_false
+      subject.captures?(:what).should be_true
+      subject.captures?(:tries).should be_true
+      subject.captures?(:bogus).should be_false
     end
-    
   end
 
   describe '#convert_captured_values' do
-
-    before(:each) do
-      @request = mock('request')
-      @request.stub!(:convert_value).and_return('foo')
-    end
+    let(:request) { mock('request', :convert_value => 'foo') }
 
     it "should call convert_value for every captured value" do
-      @request.should_receive(:convert_value).twice
-      @line_definition.convert_captured_values(['test', '123'], @request)
+      request.should_receive(:convert_value).twice
+      subject.convert_captured_values(['test', '123'], request)
     end
 
     it "should set the converted values" do
-      @line_definition.convert_captured_values(['test', '123'], @request).should == {:what => 'foo', :tries => 'foo'}
+      subject.convert_captured_values(['test', '123'], request).should == {:what => 'foo', :tries => 'foo'}
     end
 
     context 'when using :provides option' do
-      before(:each) do
-        @ld = RequestLogAnalyzer::LineDefinition.new(:test, :regexp   => /Hash\: (\{.+\})/,
-            :captures => [{ :name => :hash, :type => :hash, :provides => {:bar => :string}}])
-
-        @request = mock('request')
-
-        @request.stub!(:convert_value).with("{:bar=>'baz'}", anything).and_return(:bar => 'baz')
-        @request.stub!(:convert_value).with('baz', anything).and_return('foo')
+      
+      subject { RequestLogAnalyzer::LineDefinition.new(:test, 
+          :regexp   => /Hash\: (\{.+\})/,
+          :captures => [{ :name => :hash, :type => :hash, :provides => {:bar => :string}}]) 
+      } 
+      
+      before do
+        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)
-        @ld.convert_captured_values(["{:bar=>'baz'}"], @request)
+        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 set the provides fields" do
-        # The captures field must be set and converted as well
-        @ld.convert_captured_values(["{:bar=>'baz'}"], @request)[:bar].should eql('foo')
+      it "should return the converted hash" do
+        subject.convert_captured_values(["{:bar=>'baz'}"], request).should include(:bar => 'foo')
       end
     end
-
   end
 end