request-log-analyzer 1.13.1 → 1.13.3

data/spec/lib/testing_format.rb

@@ -1,30 +1,29 @@
 # Simple log file specification, used to test log parser.
 class TestingFormat < RequestLogAnalyzer::FileFormat::Base
-
   format_definition.first do |line|
     line.header = true
     line.teaser = /processing /
     line.regexp = /processing request (\d+)/
-    line.captures = [{ :name => :request_no, :type => :integer }]
+    line.captures = [{ name: :request_no, type: :integer }]
   end
 
   format_definition.test do |line|
     line.teaser = /testing /
     line.regexp = /testing is (\w+)(?: in (\d+\.\d+)ms)?/
-    line.captures = [{ :name => :test_capture, :type => :test_type },
-                     { :name => :duration, :type => :duration, :unit => :msec }]
+    line.captures = [{ name: :test_capture, type: :test_type },
+                     { name: :duration, type: :duration, unit: :msec }]
   end
 
   format_definition.eval do |line|
     line.regexp = /evaluation (\{.*\})/
-    line.captures = [{ :name => :evaluated, :type => :eval, :provides => { :greating => :string, :what => :string } }]
+    line.captures = [{ name: :evaluated, type: :eval, provides: { greating: :string, what: :string } }]
   end
 
   format_definition.last do |line|
     line.footer = true
     line.teaser = /finishing /
     line.regexp = /finishing request (\d+)/
-    line.captures = [{ :name => :request_no, :type => :integer }]
+    line.captures = [{ name: :request_no, type: :integer }]
   end
 
   format_definition.combined do |line|
@@ -34,13 +33,12 @@ class TestingFormat < RequestLogAnalyzer::FileFormat::Base
   end
 
   report do |analyze|
-    analyze.frequency :test_capture, :title => 'What is testing exactly?'
+    analyze.frequency :test_capture, title: 'What is testing exactly?'
   end
 
   class Request < RequestLogAnalyzer::Request
-    def convert_test_type(value, definition)
+    def convert_test_type(value, _definition)
       "Testing is #{value}"
     end
   end
-
-end
+end

data/spec/spec_helper.rb

@@ -9,7 +9,7 @@ module RequestLogAnalyzer::RSpec
 end
 
 # Include all files in the spec_helper directory
-Dir[File.dirname(__FILE__) + "/lib/**/*.rb"].each do |file|
+Dir[File.dirname(__FILE__) + '/lib/**/*.rb'].each do |file|
   require file
 end
 
@@ -21,4 +21,8 @@ RSpec.configure do |config|
   config.include RequestLogAnalyzer::RSpec::Helpers
 
   config.extend RequestLogAnalyzer::RSpec::Macros
+
+  config.expect_with :rspec do |c|
+    c.syntax = :should
+  end
 end

data/spec/unit/aggregator/database_inserter_spec.rb

@@ -21,7 +21,7 @@ describe RequestLogAnalyzer::Aggregator::DatabaseInserter do
       @database_inserter.prepare
     end
 
-    it "should set the file_format" do
+    it 'should set the file_format' do
       @database.should_receive(:file_format=).with(testing_format)
       @database_inserter.prepare
     end
@@ -48,46 +48,46 @@ describe RequestLogAnalyzer::Aggregator::DatabaseInserter do
     context "using a #{name} database" do
 
       before(:each) do
-        @database_inserter = RequestLogAnalyzer::Aggregator::DatabaseInserter.new(@log_parser, :database => connection, :reset_database => true)
+        @database_inserter = RequestLogAnalyzer::Aggregator::DatabaseInserter.new(@log_parser, database: connection, reset_database: true)
         @database_inserter.prepare
 
-        @incomplete_request = testing_format.request( {:line_type => :first, :request_no => 564})
-        @completed_request  = testing_format.request( {:line_type => :first, :request_no => 564},
-                              {:line_type => :test, :test_capture => "awesome"},
-                              {:line_type => :test, :test_capture => "indeed"},
-                              {:line_type => :eval, :evaluated => { :greating => 'howdy'}, :greating => 'howdy' },
-                              {:line_type => :last, :request_no   => 564})
+        @incomplete_request = testing_format.request(line_type: :first, request_no: 564)
+        @completed_request  = testing_format.request({ line_type: :first, request_no: 564 },
+                                                     { line_type: :test, test_capture: 'awesome' },
+                                                     { line_type: :test, test_capture: 'indeed' },
+                                                     { line_type: :eval, evaluated: { greating: 'howdy' }, greating: 'howdy' },
+                                                     { line_type: :last, request_no: 564 })
       end
 
       after(:each) do
         @database_inserter.database.send :remove_orm_classes!
       end
 
-      it "should insert a record in the request table" do
-        lambda {
+      it 'should insert a record in the request table' do
+        lambda do
           @database_inserter.aggregate(@incomplete_request)
-        }.should change(RequestLogAnalyzer::Database::Request, :count).from(0).to(1)
+        end.should change(RequestLogAnalyzer::Database::Request, :count).from(0).to(1)
       end
 
-      it "should insert a record in the first_lines table" do
-        lambda {
+      it 'should insert a record in the first_lines table' do
+        lambda do
           @database_inserter.aggregate(@incomplete_request)
-        }.should change(@database_inserter.database.get_class(:first), :count).from(0).to(1)
+        end.should change(@database_inserter.database.get_class(:first), :count).from(0).to(1)
       end
 
-      it "should insert records in all relevant line tables" do
+      it 'should insert records in all relevant line tables' do
         @database_inserter.aggregate(@completed_request)
         request = RequestLogAnalyzer::Database::Request.first
-        request.should have(2).test_lines
-        request.should have(1).first_lines
-        request.should have(1).eval_lines
-        request.should have(1).last_lines
+        request.should satisfy { |r| r.test_lines.length == 2 }
+        request.should satisfy { |r| r.first_lines.length == 1 }
+        request.should satisfy { |r| r.eval_lines.length == 1 }
+        request.should satisfy { |r| r.last_lines.length == 1 }
       end
 
-      it "should log a warning in the warnings table" do
-        RequestLogAnalyzer::Database::Warning.should_receive(:create!).with(hash_including(:warning_type => 'test_warning'))
-        @database_inserter.warning(:test_warning, "Testing the warning system", 12)
+      it 'should log a warning in the warnings table' do
+        RequestLogAnalyzer::Database::Warning.should_receive(:create!).with(hash_including(warning_type: 'test_warning'))
+        @database_inserter.warning(:test_warning, 'Testing the warning system', 12)
       end
     end
   end
-end
+end

data/spec/unit/aggregator/summarizer_spec.rb

@@ -3,23 +3,23 @@ require 'spec_helper'
 describe RequestLogAnalyzer::Aggregator::Summarizer do
 
   before(:each) do
-    @summarizer = RequestLogAnalyzer::Aggregator::Summarizer.new(mock_source, :output => mock_output)
+    @summarizer = RequestLogAnalyzer::Aggregator::Summarizer.new(mock_source, output: mock_output)
     @summarizer.prepare
   end
 
-  it "not raise exception when creating a report after aggregating multiple requests" do
-    @summarizer.aggregate(request(:data => 'bluh1'))
-    @summarizer.aggregate(request(:data => 'bluh2'))
+  it 'not raise exception when creating a report after aggregating multiple requests' do
+    @summarizer.aggregate(request(data: 'bluh1'))
+    @summarizer.aggregate(request(data: 'bluh2'))
 
     lambda { @summarizer.report(mock_output) }.should_not raise_error
   end
 
-  it "not raise exception when creating a report after aggregating a single request" do
-    @summarizer.aggregate(request(:data => 'bluh1'))
+  it 'not raise exception when creating a report after aggregating a single request' do
+    @summarizer.aggregate(request(data: 'bluh1'))
     lambda { @summarizer.report(mock_output) }.should_not raise_error
   end
 
-  it "not raise exception when creating a report after aggregating no requests" do
+  it 'not raise exception when creating a report after aggregating no requests' do
     lambda { @summarizer.report(mock_output) }.should_not raise_error
   end
 

data/spec/unit/controller/controller_spec.rb

@@ -2,40 +2,40 @@ require 'spec_helper'
 
 describe RequestLogAnalyzer::Controller do
 
-  it "should use a custom output generator correctly" do
-    
+  it 'should use a custom output generator correctly' do
+
     mock_output = double('RequestLogAnalyzer::Output::Base')
     mock_output.stub(:io).and_return(mock_io)
     mock_output.should_receive(:header)
     mock_output.should_receive(:footer)
 
-    controller  = RequestLogAnalyzer::Controller.new(mock_source, :output => mock_output)
+    controller  = RequestLogAnalyzer::Controller.new(mock_source, output: mock_output)
 
     controller.run!
   end
 
-  it "should call aggregators correctly when run" do
-    controller  = RequestLogAnalyzer::Controller.new(mock_source, :output => mock_output)
-    
-    mock_aggregator = double('RequestLogAnalyzer::Aggregator::Base') 
+  it 'should call aggregators correctly when run' do
+    controller  = RequestLogAnalyzer::Controller.new(mock_source, output: mock_output)
+
+    mock_aggregator = double('RequestLogAnalyzer::Aggregator::Base')
     mock_aggregator.should_receive(:prepare).once.ordered
     mock_aggregator.should_receive(:aggregate).with(an_instance_of(testing_format.request_class)).twice.ordered
     mock_aggregator.should_receive(:finalize).once.ordered
     mock_aggregator.should_receive(:report).once.ordered
-  
+
     controller.aggregators << mock_aggregator
     controller.run!
   end
-  
-  it "should call filters when run" do
-    controller  = RequestLogAnalyzer::Controller.new(mock_source, :output => mock_output)
-    
+
+  it 'should call filters when run' do
+    controller  = RequestLogAnalyzer::Controller.new(mock_source, output: mock_output)
+
     mock_filter = double('RequestLogAnalyzer::Filter::Base')
     mock_filter.should_receive(:filter).twice.and_return(nil)
     controller.should_receive(:aggregate_request).twice.and_return(nil)
-    
+
     controller.filters << mock_filter
     controller.run!
   end
-  
+
 end

data/spec/unit/controller/log_processor_spec.rb

@@ -8,11 +8,11 @@ describe RequestLogAnalyzer::LogProcessor, 'stripping log files' do
     @log_stripper = RequestLogAnalyzer::LogProcessor.new(testing_format, :strip, {})
   end
 
-  it "should remove a junk line" do
+  it 'should remove a junk line' do
     @log_stripper.strip_line("junk line\n").should be_empty
   end
 
-  it "should keep a teaser line intact" do
+  it 'should keep a teaser line intact' do
     @log_stripper.strip_line("processing 1234\n").should be_empty
   end
-end
+end

data/spec/unit/database/base_class_spec.rb

@@ -5,14 +5,14 @@ describe RequestLogAnalyzer::Database::Base do
 
   describe '.subclass_from_line_definition' do
     before(:all) do
-      @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, { :regexp   => /Testing (\w+), tries\: (\d+)/,
-                          :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer },
-                            { :name => :evaluated, :type => :hash, :provides => {:evaluated_field => :duration} }]})
+      @line_definition = RequestLogAnalyzer::LineDefinition.new(:test,  regexp: /Testing (\w+), tries\: (\d+)/,
+                                                                        captures: [{ name: :what, type: :string }, { name: :tries, type: :integer },
+                                                                                   { name: :evaluated, type: :hash, provides: { evaluated_field: :duration } }])
     end
 
     before(:each) do
       @orm_class = double('Line ActiveRecord::Base class')
-      @orm_class.stub("table_name=")
+      @orm_class.stub('table_name=')
       @orm_class.stub(:belongs_to)
       @orm_class.stub(:serialize)
       @orm_class.stub(:line_definition=)
@@ -24,41 +24,41 @@ describe RequestLogAnalyzer::Database::Base do
       RequestLogAnalyzer::Database::Base.stub(:database).and_return(@database)
     end
 
-    it "should create a new subclass using the Base class as parent" do
+    it 'should create a new subclass using the Base class as parent' do
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
 
-    it "should store the LineDefinition" do
+    it 'should store the LineDefinition' do
       @orm_class.should_receive(:line_definition=).with(@line_definition)
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
 
-    it "should set the table name for the subclass" do
-      @orm_class.should_receive("table_name=").with('test_lines')
+    it 'should set the table name for the subclass' do
+      @orm_class.should_receive('table_name=').with('test_lines')
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
 
-    it "should set the :belongs_to relationship with the Request class" do
-      @orm_class.should_receive(:belongs_to).with(:request, {:class_name=>"RequestLogAnalyzer::Database::Request"})
+    it 'should set the :belongs_to relationship with the Request class' do
+      @orm_class.should_receive(:belongs_to).with(:request, class_name: 'RequestLogAnalyzer::Database::Request')
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
 
-    it "should set a :has_many relationship in the request class" do
+    it 'should set a :has_many relationship in the request class' do
       RequestLogAnalyzer::Database::Request.should_receive(:has_many).with(:test_lines)
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
 
-    it "should set a :has_many relationship in the source class" do
+    it 'should set a :has_many relationship in the source class' do
       RequestLogAnalyzer::Database::Source.should_receive(:has_many).with(:test_lines)
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
 
-    it "should set the :belongs_to relationship with the Source class" do
-      @orm_class.should_receive(:belongs_to).with(:source, {:class_name=>"RequestLogAnalyzer::Database::Source"})
+    it 'should set the :belongs_to relationship with the Source class' do
+      @orm_class.should_receive(:belongs_to).with(:source, class_name: 'RequestLogAnalyzer::Database::Source')
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
 
-    it "should serialize a complex field" do
+    it 'should serialize a complex field' do
       @orm_class.should_receive(:serialize).with(:evaluated, Hash)
       RequestLogAnalyzer::Database::Base.subclass_from_line_definition(@line_definition, @orm_class)
     end
@@ -76,32 +76,32 @@ describe RequestLogAnalyzer::Database::Base do
       RequestLogAnalyzer::Database::Base.stub(:database).and_return(@database)
 
       @klass = double('ActiveRecord ORM class')
-      @klass.stub(:column_names).and_return(['id', 'request_id', 'source_id', 'lineno', 'duration'])
-      @klass.stub("table_name=")
+      @klass.stub(:column_names).and_return(%w(id request_id source_id lineno duration))
+      @klass.stub('table_name=')
       @klass.stub(:belongs_to)
     end
 
-    it "should set the table name" do
-      @klass.should_receive("table_name=").with('completed_lines')
+    it 'should set the table name' do
+      @klass.should_receive('table_name=').with('completed_lines')
       RequestLogAnalyzer::Database::Base.subclass_from_table('completed_lines', @klass)
     end
 
-    it "should create the :belongs_to relation to the request class" do
-      @klass.should_receive(:belongs_to).with(:request, {:class_name=>"RequestLogAnalyzer::Database::Request"})
+    it 'should create the :belongs_to relation to the request class' do
+      @klass.should_receive(:belongs_to).with(:request, class_name: 'RequestLogAnalyzer::Database::Request')
       RequestLogAnalyzer::Database::Base.subclass_from_table('completed_lines', @klass)
     end
 
-    it "should create the :has_many relation in the request class" do
+    it 'should create the :has_many relation in the request class' do
       RequestLogAnalyzer::Database::Request.should_receive(:has_many).with(:completed_lines)
       RequestLogAnalyzer::Database::Base.subclass_from_table('completed_lines', @klass)
     end
 
-    it "should create the :belongs_to relation to the source class" do
-      @klass.should_receive(:belongs_to).with(:source, {:class_name=>"RequestLogAnalyzer::Database::Source"})
+    it 'should create the :belongs_to relation to the source class' do
+      @klass.should_receive(:belongs_to).with(:source, class_name: 'RequestLogAnalyzer::Database::Source')
       RequestLogAnalyzer::Database::Base.subclass_from_table('completed_lines', @klass)
     end
 
-    it "should create the :has_many relation in the request class" do
+    it 'should create the :has_many relation in the request class' do
       RequestLogAnalyzer::Database::Source.should_receive(:has_many).with(:completed_lines)
       RequestLogAnalyzer::Database::Base.subclass_from_table('completed_lines', @klass)
     end
@@ -111,9 +111,9 @@ describe RequestLogAnalyzer::Database::Base do
   describe '#create_table' do
 
     before(:all) do
-      @line_definition = RequestLogAnalyzer::LineDefinition.new(:test, { :regexp   => /Testing (\w+), tries\: (\d+)/,
-                            :captures => [{ :name => :what, :type => :string }, { :name => :tries, :type => :integer },
-                              { :name => :evaluated, :type => :hash, :provides => {:evaluated_field => :duration} }]})
+      @line_definition = RequestLogAnalyzer::LineDefinition.new(:test,  regexp: /Testing (\w+), tries\: (\d+)/,
+                                                                        captures: [{ name: :what, type: :string }, { name: :tries, type: :integer },
+                                                                                   { name: :evaluated, type: :hash, provides: { evaluated_field: :duration } }])
     end
 
     before(:each) do
@@ -128,48 +128,47 @@ describe RequestLogAnalyzer::Database::Base do
       @database.remove_orm_classes!
     end
 
-    it "should call create_table with the correct table name" do
+    it 'should call create_table with the correct table name' do
       @database.connection.should_receive(:create_table).with(:test_lines)
       @klass.create_table!
     end
 
-    it "should not create a table based on the line type name if it already exists" do
+    it 'should not create a table based on the line type name if it already exists' do
       @klass.stub(:table_exists?).and_return(true)
       @database.connection.should_not_receive(:create_table).with(:test_lines)
       @klass.create_table!
     end
 
-    it "should create an index on the request_id field" do
+    it 'should create an index on the request_id field' do
       @database.connection.should_receive(:add_index).with(:test_lines, [:request_id])
       @klass.create_table!
     end
 
-    it "should create an index on the source_id field" do
+    it 'should create an index on the source_id field' do
       @database.connection.should_receive(:add_index).with(:test_lines, [:source_id])
       @klass.create_table!
     end
 
-    it "should create a request_id field to link the requests together" do
+    it 'should create a request_id field to link the requests together' do
       @database.connection.table_creator.should_receive(:column).with(:request_id, :integer)
       @klass.create_table!
     end
 
-    it "should create a lineno field to save the location of the line in the original file" do
+    it 'should create a lineno field to save the location of the line in the original file' do
       @database.connection.table_creator.should_receive(:column).with(:lineno, :integer)
       @klass.create_table!
     end
 
-    it "should create a field of the correct type for every defined capture field" do
+    it 'should create a field of the correct type for every defined capture field' do
       @database.connection.table_creator.should_receive(:column).with(:what, :string)
       @database.connection.table_creator.should_receive(:column).with(:tries, :integer)
       @database.connection.table_creator.should_receive(:column).with(:evaluated, :text)
       @klass.create_table!
     end
 
-    it "should create a field of the correct type for every provided field" do
+    it 'should create a field of the correct type for every provided field' do
       @database.connection.table_creator.should_receive(:column).with(:evaluated_field, :float)
       @klass.create_table!
     end
   end
 end
-

data/spec/unit/database/connection_spec.rb

@@ -3,32 +3,32 @@ require 'spec_helper'
 describe RequestLogAnalyzer::Database::Connection do
   describe '.from_string' do
 
-    it "should parse a name-value based string" do
+    it 'should parse a name-value based string' do
       string = 'adapter=sqlite3;database=filename.db'
-      RequestLogAnalyzer::Database::Connection.from_string(string).should == {:adapter => 'sqlite3', :database => 'filename.db'}
+      RequestLogAnalyzer::Database::Connection.from_string(string).should == { adapter: 'sqlite3', database: 'filename.db' }
     end
 
-    it "should parse an URI-based string for SQLite3" do
+    it 'should parse an URI-based string for SQLite3' do
       string = 'sqlite3://filename.db'
-      RequestLogAnalyzer::Database::Connection.from_string(string).should == {:adapter => 'sqlite3', :database => 'filename.db'}
+      RequestLogAnalyzer::Database::Connection.from_string(string).should == { adapter: 'sqlite3', database: 'filename.db' }
     end
 
-    it "should parse an URI-based string for MySQL" do
+    it 'should parse an URI-based string for MySQL' do
       string = 'mysql://localhost.local/database'
       RequestLogAnalyzer::Database::Connection.from_string(string).should ==
-              { :adapter => 'mysql', :database => 'database', :host => 'localhost.local' }
+              { adapter: 'mysql', database: 'database', host: 'localhost.local' }
     end
 
-    it "should parse an URI-based string for MySQL with only username" do
+    it 'should parse an URI-based string for MySQL with only username' do
       string = 'mysql://username@localhost.local/database'
       RequestLogAnalyzer::Database::Connection.from_string(string).should ==
-              { :adapter => 'mysql', :database => 'database', :host => 'localhost.local', :username => 'username' }
+              { adapter: 'mysql', database: 'database', host: 'localhost.local', username: 'username' }
     end
 
-    it "should parse an URI-based string for MySQL with username and password" do
+    it 'should parse an URI-based string for MySQL with username and password' do
       string = 'mysql://username:password@localhost.local/database'
       RequestLogAnalyzer::Database::Connection.from_string(string).should ==
-              { :adapter => 'mysql', :database => 'database', :host => 'localhost.local', :username => 'username', :password => 'password' }
+              { adapter: 'mysql', database: 'database', host: 'localhost.local', username: 'username', password: 'password' }
     end
   end
 end