request-log-analyzer 1.13.1 → 1.13.3

data/spec/unit/filter/field_filter_spec.rb

@@ -3,64 +3,64 @@ require 'spec_helper'
 describe RequestLogAnalyzer::Filter::Field, 'string in accept mode' do
 
   before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :select)
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, field: :test, value: 'test', mode: :select)
   end
 
-  it "should reject a request if the field value does not match" do
-    @filter.filter(request(:test => 'not test')).should be_nil
+  it 'should reject a request if the field value does not match' do
+    @filter.filter(request(test: 'not test')).should be_nil
   end
 
-  it "should reject a request if the field name does not match" do
-    @filter.filter(request(:testing => 'test')).should be_nil
+  it 'should reject a request if the field name does not match' do
+    @filter.filter(request(testing: 'test')).should be_nil
   end
 
-  it "should accept a request if the both name and value match" do
-    @filter.filter(request(:test => 'test')).should_not be_nil
+  it 'should accept a request if the both name and value match' do
+    @filter.filter(request(test: 'test')).should_not be_nil
   end
 
-  it "should accept a request if the value is not the first value" do
-    @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should_not be_nil
+  it 'should accept a request if the value is not the first value' do
+    @filter.filter(request([{ test: 'ignore' }, { test: 'test' }])).should_not be_nil
   end
 end
 
 describe RequestLogAnalyzer::Filter::Field, 'string in reject mode' do
 
   before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => 'test', :mode => :reject)
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, field: :test, value: 'test', mode: :reject)
   end
 
-  it "should accept a request if the field value does not match" do
-    @filter.filter(request(:test => 'not test')).should_not be_nil
+  it 'should accept a request if the field value does not match' do
+    @filter.filter(request(test: 'not test')).should_not be_nil
   end
 
-  it "should accept a request if the field name does not match" do
-    @filter.filter(request(:testing => 'test')).should_not be_nil
+  it 'should accept a request if the field name does not match' do
+    @filter.filter(request(testing: 'test')).should_not be_nil
   end
 
-  it "should reject a request if the both name and value match" do
-    @filter.filter(request(:test => 'test')).should be_nil
+  it 'should reject a request if the both name and value match' do
+    @filter.filter(request(test: 'test')).should be_nil
   end
 
-  it "should reject a request if the value is not the first value" do
-    @filter.filter(request([{:test => 'ignore'}, {:test => 'test'}])).should be_nil
+  it 'should reject a request if the value is not the first value' do
+    @filter.filter(request([{ test: 'ignore' }, { test: 'test' }])).should be_nil
   end
 end
 
 describe RequestLogAnalyzer::Filter::Field, 'regexp in accept mode' do
 
   before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, :field => :test, :value => '/test/', :mode => :select)
+    @filter = RequestLogAnalyzer::Filter::Field.new(testing_format, field: :test, value: '/test/', mode: :select)
   end
 
-  it "should reject a request if the field value does not match" do
-    @filter.filter(request(:test => 'a working test')).should_not be_nil
+  it 'should reject a request if the field value does not match' do
+    @filter.filter(request(test: 'a working test')).should_not be_nil
   end
 
-  it "should reject a request if the field name does not match" do
-    @filter.filter(request(:testing => 'test')).should be_nil
+  it 'should reject a request if the field name does not match' do
+    @filter.filter(request(testing: 'test')).should be_nil
   end
 
-  it "should accept a request if the value is not the first value" do
-    @filter.filter(request([{:test => 'ignore'}, {:test => 'testing 123'}])).should_not be_nil
+  it 'should accept a request if the value is not the first value' do
+    @filter.filter(request([{ test: 'ignore' }, { test: 'testing 123' }])).should_not be_nil
   end
-end
+end

data/spec/unit/filter/filter_spec.rb

@@ -6,12 +6,12 @@ describe RequestLogAnalyzer::Filter::Base, 'base filter' do
     @filter = RequestLogAnalyzer::Filter::Base.new(testing_format)
   end
 
-  it "should return everything" do
-    @filter.filter(request(:ip => '123.123.123.123'))[:ip].should eql('123.123.123.123')
+  it 'should return everything' do
+    @filter.filter(request(ip: '123.123.123.123'))[:ip].should eql('123.123.123.123')
   end
 
-  it "should return nil on nil request" do
+  it 'should return nil on nil request' do
     @filter.filter(nil).should be_nil
   end
 
-end
+end

data/spec/unit/filter/timespan_filter_spec.rb

@@ -3,56 +3,56 @@ require 'spec_helper'
 describe RequestLogAnalyzer::Filter::Timespan, 'both before and after'  do
 
   before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'), :before => DateTime.parse('2009-02-02'))
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, after: DateTime.parse('2009-01-01'), before: DateTime.parse('2009-02-02'))
   end
 
-  it "should reject a request before the after date" do
-    @filter.filter(request(:timestamp => 20081212000000)).should be_nil
+  it 'should reject a request before the after date' do
+    @filter.filter(request(timestamp: 20_081_212_000_000)).should be_nil
   end
 
-  it "should reject a request after the before date" do
-    @filter.filter(request(:timestamp => 20090303000000)).should be_nil
+  it 'should reject a request after the before date' do
+    @filter.filter(request(timestamp: 20_090_303_000_000)).should be_nil
   end
 
-  it "should accept a request between the after and before dates" do
-    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  it 'should accept a request between the after and before dates' do
+    @filter.filter(request(timestamp: 20_090_102_000_000)).should_not be_nil
   end
 end
 
 describe RequestLogAnalyzer::Filter::Timespan, 'only before'  do
 
   before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :before => DateTime.parse('2009-02-02'))
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, before: DateTime.parse('2009-02-02'))
   end
 
-  it "should accept a request before the after date" do
-    @filter.filter(request(:timestamp => 20081212000000)).should_not be_nil
+  it 'should accept a request before the after date' do
+    @filter.filter(request(timestamp: 20_081_212_000_000)).should_not be_nil
   end
 
-  it "should reject a request after the before date" do
-    @filter.filter(request(:timestamp => 20090303000000)).should be_nil
+  it 'should reject a request after the before date' do
+    @filter.filter(request(timestamp: 20_090_303_000_000)).should be_nil
   end
 
-  it "should accept a request between the after and before dates" do
-    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  it 'should accept a request between the after and before dates' do
+    @filter.filter(request(timestamp: 20_090_102_000_000)).should_not be_nil
   end
 end
 
 describe RequestLogAnalyzer::Filter::Timespan, 'only after'  do
 
   before(:each) do
-    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, :after => DateTime.parse('2009-01-01'))
+    @filter = RequestLogAnalyzer::Filter::Timespan.new(testing_format, after: DateTime.parse('2009-01-01'))
   end
 
-  it "should reject a request before the after date" do
-    @filter.filter(request(:timestamp => 20081212000000)).should be_nil
+  it 'should reject a request before the after date' do
+    @filter.filter(request(timestamp: 20_081_212_000_000)).should be_nil
   end
 
-  it "should accept a request after the before date" do
-    @filter.filter(request(:timestamp => 20090303000000)).should_not be_nil
+  it 'should accept a request after the before date' do
+    @filter.filter(request(timestamp: 20_090_303_000_000)).should_not be_nil
   end
 
-  it "should accept a request between the after and before dates" do
-    @filter.filter(request(:timestamp => 20090102000000)).should_not be_nil
+  it 'should accept a request between the after and before dates' do
+    @filter.filter(request(timestamp: 20_090_102_000_000)).should_not be_nil
   end
-end
+end

data/spec/unit/mailer_spec.rb

@@ -2,41 +2,41 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::Mailer, 'mailer' do
 
-  it "should initialize correctly" do
-    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true) 
-    @mailer.host.should eql("localhost")
+  it 'should initialize correctly' do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', debug: true)
+    @mailer.host.should eql('localhost')
     @mailer.port.should eql(25)
   end
-  
-  it "should allow alternate port settings" do
-    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost:2525', :debug => true) 
-    @mailer.host.should eql("localhost")
-    @mailer.port.should eql("2525")
+
+  it 'should allow alternate port settings' do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost:2525', debug: true)
+    @mailer.host.should eql('localhost')
+    @mailer.port.should eql('2525')
   end
 
-  it "should store printed data" do
-    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true)
+  it 'should store printed data' do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', debug: true)
 
     @mailer << 'test1'
     @mailer.puts 'test2'
-    
-    @mailer.data.should eql(['test1', 'test2'])
+
+    @mailer.data.should eql(%w(test1 test2))
   end
 
-  it "should send mail" do
-    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', :debug => true)
+  it 'should send mail' do
+    @mailer = RequestLogAnalyzer::Mailer.new('alfa@beta.com', 'localhost', debug: true)
 
     @mailer << 'test1'
     @mailer.puts 'test2'
 
     mail = @mailer.mail
-    
-    mail[0].should include("contact@railsdoctors.com")
-    mail[0].should include("test1")
-    mail[0].should include("test2")
 
-    mail[1].should include("contact@railsdoctors.com")
-    mail[2].should include("alfa@beta.com")
+    mail[0].should include('contact@railsdoctors.com')
+    mail[0].should include('test1')
+    mail[0].should include('test2')
+
+    mail[1].should include('contact@railsdoctors.com')
+    mail[2].should include('alfa@beta.com')
   end
 
-end
+end

data/spec/unit/request_spec.rb

@@ -6,34 +6,34 @@ describe RequestLogAnalyzer::Request do
     @request = testing_format.request
   end
 
-  it "should be empty without any captured lines in it" do
+  it 'should be empty without any captured lines in it' do
     @request.should be_empty
   end
 
   context :incomplete do
 
     before(:each) do
-      @request << { :line_type => :test, :lineno => 1, :test_capture => 'awesome!' }
+      @request << { line_type: :test, lineno: 1, test_capture: 'awesome!' }
     end
 
-    it "should be single if only one line has been added" do
+    it 'should be single if only one line has been added' do
       @request.should_not be_empty
     end
 
-    it "should not be a completed request" do
+    it 'should not be a completed request' do
       @request.should_not be_completed
     end
 
-    it "should take the line type of the first line as global line_type" do
+    it 'should take the line type of the first line as global line_type' do
       @request.lines[0][:line_type].should == :test
       @request.should =~ :test
     end
 
-    it "should return the first field value" do
+    it 'should return the first field value' do
       @request[:test_capture].should == 'awesome!'
     end
 
-    it "should return nil if no such field is present" do
+    it 'should return nil if no such field is present' do
       @request[:nonexisting].should be_nil
     end
   end
@@ -41,70 +41,70 @@ describe RequestLogAnalyzer::Request do
   context :completed do
 
     before(:each) do
-      @request << { :line_type => :first, :lineno =>  1, :name => 'first line!' }
-      @request << { :line_type => :test,  :lineno =>  4, :test_capture => 'testing' }
-      @request << { :line_type => :test,  :lineno =>  7, :test_capture => 'testing some more' }
-      @request << { :line_type => :last,  :lineno => 10, :time => 0.03 }
+      @request << { line_type: :first, lineno: 1, name: 'first line!' }
+      @request << { line_type: :test,  lineno: 4, test_capture: 'testing' }
+      @request << { line_type: :test,  lineno: 7, test_capture: 'testing some more' }
+      @request << { line_type: :last,  lineno: 10, time: 0.03 }
     end
 
-    it "should not be empty when multiple liness are added" do
+    it 'should not be empty when multiple liness are added' do
       @request.should_not be_empty
     end
 
-    it "should be a completed request" do
+    it 'should be a completed request' do
       @request.should be_completed
     end
 
-    it "should recognize all line types" do
+    it 'should recognize all line types' do
       [:first, :test, :last].each { |type| @request.should =~ type }
     end
 
-    it "should detect the correct field value" do
+    it 'should detect the correct field value' do
       @request[:name].should == 'first line!'
       @request[:time].should == 0.03
     end
 
-    it "should detect the first matching field value" do
+    it 'should detect the first matching field value' do
       @request.first(:test_capture).should == 'testing'
     end
 
-    it "should detect the every matching field value" do
-      @request.every(:test_capture).should == ['testing', "testing some more"]
+    it 'should detect the every matching field value' do
+      @request.every(:test_capture).should == ['testing', 'testing some more']
     end
 
-    it "should set the first_lineno for a request to the lowest lineno encountered" do
+    it 'should set the first_lineno for a request to the lowest lineno encountered' do
       @request.first_lineno.should eql(1)
     end
 
-    it "should set the first_lineno for a request if a line with a lower lineno is added" do
-      @request << { :line_type => :test, :lineno =>  0 }
+    it 'should set the first_lineno for a request if a line with a lower lineno is added' do
+      @request << { line_type: :test, lineno: 0 }
       @request.first_lineno.should eql(0)
     end
 
-    it "should set the last_lineno for a request to the highest encountered lineno" do
+    it 'should set the last_lineno for a request to the highest encountered lineno' do
       @request.last_lineno.should eql(10)
     end
 
-    it "should not set the last_lineno for a request if a line with a lower lineno is added" do
-      @request << { :line_type => :test, :lineno =>  7 }
+    it 'should not set the last_lineno for a request if a line with a lower lineno is added' do
+      @request << { line_type: :test, lineno: 7 }
       @request.last_lineno.should eql(10)
     end
 
-    it "should not have a timestamp if no such field is captured" do
+    it 'should not have a timestamp if no such field is captured' do
       @request.timestamp.should be_nil
     end
 
-    it "should set return a timestamp field if such a field is captured" do
-      @request << { :line_type => :first, :lineno =>  1, :name => 'first line!', :timestamp => Time.now}
+    it 'should set return a timestamp field if such a field is captured' do
+      @request << { line_type: :first, lineno: 1, name: 'first line!', timestamp: Time.now }
       @request.timestamp.should_not be_nil
     end
   end
 
   context 'single line' do
     # combined is both a header and a footer line
-    before(:each) { @request << { :line_type => :combined, :lineno => 1 } }
+    before(:each) { @request << { line_type: :combined, lineno: 1 } }
 
-    it "should be a completed request if the line is both header and footer" do
+    it 'should be a completed request if the line is both header and footer' do
       @request.should be_completed
     end
   end

data/spec/unit/source/log_parser_spec.rb

@@ -16,13 +16,13 @@ describe RequestLogAnalyzer::Source::LogParser do
 
     it "should set the :source for every parsed line" do
       @log_parser.parse_file(log_fixture(:rails_22)) do |request|
-        request.lines.all? { |line| line[:source] == log_fixture(:rails_22) }.should be_true
+        request.lines.all? { |line| line[:source] == log_fixture(:rails_22) }.should == true
       end
     end
 
     it "should set the :lineno for every parsed line" do
       @log_parser.parse_file(log_fixture(:rails_22)) do |request|
-        request.lines.all? { |line| line.has_key?(:lineno) }.should be_true
+        request.lines.all? { |line| line.has_key?(:lineno) }.should == true
       end
     end
 
@@ -39,7 +39,7 @@ describe RequestLogAnalyzer::Source::LogParser do
 
     it "should parse all request values when spanned over multiple files" do
       @log_parser.parse_files([log_fixture(:multiple_files_1), log_fixture(:multiple_files_2)]) do |request|
-        request.lines.should have(4).items
+        request.lines.length.should be 4
         request[:request_no].should == 1
         request[:test_capture].should == "Testing is amazing" # Note the custom converter
       end
@@ -113,7 +113,7 @@ describe RequestLogAnalyzer::Source::LogParser do
         @log_parser.parsed_lines.should > 0
       end
     end
-  
+
     if `which unzip` != ""
       it "should parse a rails zipped log file" do
         @log_parser.should_receive(:handle_request).once
@@ -122,4 +122,4 @@ describe RequestLogAnalyzer::Source::LogParser do
       end
     end
   end
-end
+end

data/spec/unit/tracker/duration_tracker_spec.rb

@@ -5,53 +5,53 @@ describe RequestLogAnalyzer::Tracker::Duration do
   describe '#report' do
 
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::Duration.new(:category => :category, :value => :duration)
+      @tracker = RequestLogAnalyzer::Tracker::Duration.new(category: :category, value: :duration)
       @tracker.prepare
     end
 
-    it "should generate a report without errors when one category is present" do
-      @tracker.update(request(:category => 'a', :duration => 0.2))
+    it 'should generate a report without errors when one category is present' do
+      @tracker.update(request(category: 'a', duration: 0.2))
       lambda { @tracker.report(mock_output) }.should_not raise_error
     end
 
-    it "should generate a report without errors when no category is present" do
+    it 'should generate a report without errors when no category is present' do
       lambda { @tracker.report(mock_output) }.should_not raise_error
     end
 
-    it "should generate a report without errors when multiple categories are present" do
-      @tracker.update(request(:category => 'a', :duration => 0.2))
-      @tracker.update(request(:category => 'b', :duration => 0.2))
+    it 'should generate a report without errors when multiple categories are present' do
+      @tracker.update(request(category: 'a', duration: 0.2))
+      @tracker.update(request(category: 'b', duration: 0.2))
       lambda { @tracker.report(mock_output) }.should_not raise_error
     end
 
-    it "should generate a report with arrays of durations are present" do
-      @tracker.update(request(:category => 'a', :duration => [0.1, 0.2]))
-      @tracker.update(request(:category => 'a', :duration => [0.2, 0.3]))
+    it 'should generate a report with arrays of durations are present' do
+      @tracker.update(request(category: 'a', duration: [0.1, 0.2]))
+      @tracker.update(request(category: 'a', duration: [0.2, 0.3]))
       lambda { @tracker.report(mock_output) }.should_not raise_error
-      @tracker.to_yaml_object['a'].should include(:min => 0.1, :hits => 4, :max => 0.3, :mean => 0.2, :sum => 0.8)
+      @tracker.to_yaml_object['a'].should include(min: 0.1, hits: 4, max: 0.3, mean: 0.2, sum: 0.8)
     end
 
-    it "should generate a YAML output" do
-      @tracker.update(request(:category => 'a', :duration => 0.2))
-      @tracker.update(request(:category => 'b', :duration => 0.2))
-      @tracker.to_yaml_object.keys.should =~ ['a', 'b']
-      @tracker.to_yaml_object['a'].should include(:min => 0.2, :hits => 1, :max => 0.2, :mean => 0.2, :sum => 0.2, :sum_of_squares => 0.0)
-      @tracker.to_yaml_object['b'].should include(:min => 0.2, :hits => 1, :max => 0.2, :mean => 0.2, :sum => 0.2, :sum_of_squares => 0.0)
+    it 'should generate a YAML output' do
+      @tracker.update(request(category: 'a', duration: 0.2))
+      @tracker.update(request(category: 'b', duration: 0.2))
+      @tracker.to_yaml_object.keys.should =~ %w(a b)
+      @tracker.to_yaml_object['a'].should include(min: 0.2, hits: 1, max: 0.2, mean: 0.2, sum: 0.2, sum_of_squares: 0.0)
+      @tracker.to_yaml_object['b'].should include(min: 0.2, hits: 1, max: 0.2, mean: 0.2, sum: 0.2, sum_of_squares: 0.0)
     end
   end
-  
+
   describe '#display_value' do
-    before(:each) { @tracker = RequestLogAnalyzer::Tracker::Duration.new(:category => :category, :value => :duration) }
-    
-    it "should only display seconds when time < 60" do
+    before(:each) { @tracker = RequestLogAnalyzer::Tracker::Duration.new(category: :category, value: :duration) }
+
+    it 'should only display seconds when time < 60' do
       @tracker.display_value(33.12).should == '33.12s'
     end
 
-    it "should display minutes and wholeseconds when time > 60" do
+    it 'should display minutes and wholeseconds when time > 60' do
       @tracker.display_value(63.12).should == '1m03s'
     end
 
-    it "should display minutes and wholeseconds when time > 60" do
+    it 'should display minutes and wholeseconds when time > 60' do
       @tracker.display_value(3601.12).should == '1h00m01s'
     end
   end