request-log-analyzer 1.10.1 → 1.11.0

data/spec/unit/file_format/merb_format_spec.rb

@@ -2,51 +2,36 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::FileFormat::Merb do
 
-  it "should be a valid file format" do
-    RequestLogAnalyzer::FileFormat.load(:merb).should be_valid
-  end
+  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 }
 
   describe '#parse_line' do
-    before(:each) do
-      @file_format = RequestLogAnalyzer::FileFormat.load(:merb)
-    end
+    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(: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 a :started line correctly" do
-      line = '~ Started request handling: Fri Aug 29 11:10:23 +0200 2008'
-      @file_format.should parse_line(line).as(:started).and_capture(:timestamp => 20080829111023)
-    end
-
-    it "should parse a prefixed :started line correctly" do
-      line = '~ Aug 31 18:35:24 typekit-web001 merb:  ~ Started request handling: Mon Aug 31 18:35:25 +0000 2009'
-      @file_format.should parse_line(line).as(:started).and_capture(:timestamp => 20090831183525)
-    end
+    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 a :params line correctly" do
-      line = '~ Params: {"_method"=>"delete", "authenticity_token"=>"[FILTERED]", "action"=>"delete", "controller"=>"session"}'
-      @file_format.should parse_line(line).as(:params).and_capture(:controller => 'session', :action => 'delete', :namespace => nil)
-    end
-
-    it "should parse a :completed line correctly" do
-      line = '~ {:dispatch_time=>0.006117, :after_filters_time=>6.1e-05, :before_filters_time=>0.000712, :action_time=>0.005833}'
-      @file_format.should parse_line(line).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
-    before(:each) do
-      @log_parser = RequestLogAnalyzer::Source::LogParser.new(RequestLogAnalyzer::FileFormat.load(:merb))
-    end
+    let(:log_parser) { RequestLogAnalyzer::Source::LogParser.new(subject) } 
 
-    it "should parse a stream and find valid Merb requests" do
-      @log_parser.parse_file(log_fixture(:merb)) do |request|
-        request.should be_kind_of(RequestLogAnalyzer::FileFormat::Merb::Request)
-      end
-    end
-  
-    it "should find 11 completed requests" do
-      @log_parser.should_receive(:handle_request).exactly(11).times
-      @log_parser.parse_file(log_fixture(:merb))
+    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))
     end
   end
 end

data/spec/unit/file_format/mysql_format_spec.rb

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

data/spec/unit/file_format/oink_format_spec.rb

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

data/spec/unit/file_format/postgresql_format_spec.rb

@@ -5,7 +5,7 @@ describe RequestLogAnalyzer::FileFormat::Postgresql do
   subject { RequestLogAnalyzer::FileFormat.load(:Postgresql) }
   let(:log_parser)  { RequestLogAnalyzer::Source::LogParser.new(subject) }
   
-  it { should be_valid }
+  it { should be_well_formed }
 
   describe '#parse_line' do
     it "should parse a :query line correctly" do
@@ -32,10 +32,8 @@ describe RequestLogAnalyzer::FileFormat::Postgresql do
         2010-10-10 15:00:02 GMT [38747]: [1670-1] LOCATION:  exec_simple_query, postgres.c:1081
       EOS
 
-      request_counter.should_receive(:hit!).exactly(1).times
       log_parser.should_not_receive(:warn)
-      log_parser.parse_io(StringIO.new(fixture)) do |request|
-        request_counter.hit! if request.kind_of?(RequestLogAnalyzer::FileFormat::Postgresql::Request) && request.completed?
+      log_parser.parse_string(fixture) do |request|
         request[:query].should == 'INSERT INTO delayed_jobs (failed_at, locked_by, created_at, handler, updated_at, priority, run_at, attempts, locked_at, last_error) VALUES(NULL, NULL, :string, E:string, :string, :int, :string, :int, NULL, NULL) RETURNING id'
       end
     end