request-log-analyzer 1.13.1 → 1.13.3

data/spec/unit/tracker/frequency_tracker_spec.rb

@@ -4,46 +4,45 @@ describe RequestLogAnalyzer::Tracker::Frequency do
 
   context 'static category' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(category: :category)
       @tracker.prepare
     end
 
-    it "should register a request in the right category" do
-      @tracker.update(request(:category => 'a', :blah => 0.2))
+    it 'should register a request in the right category' do
+      @tracker.update(request(category: 'a', blah: 0.2))
       @tracker.categories.should include('a')
     end
 
-    it "should register a request in the right category" do
-      @tracker.update(request(:category => 'a', :blah => 0.2))
-      @tracker.update(request(:category => 'b', :blah => 0.2))
-      @tracker.update(request(:category => 'b', :blah => 0.2))
+    it 'should register a request in the right category' do
+      @tracker.update(request(category: 'a', blah: 0.2))
+      @tracker.update(request(category: 'b', blah: 0.2))
+      @tracker.update(request(category: 'b', blah: 0.2))
 
       @tracker.frequency('a').should == 1
       @tracker.frequency('b').should == 2
       @tracker.overall_frequency.should == 3
     end
 
-    it "should sort correctly by frequency" do
-      @tracker.update(request(:category => 'a', :blah => 0.2))
-      @tracker.update(request(:category => 'b', :blah => 0.2))
-      @tracker.update(request(:category => 'b', :blah => 0.2))
+    it 'should sort correctly by frequency' do
+      @tracker.update(request(category: 'a', blah: 0.2))
+      @tracker.update(request(category: 'b', blah: 0.2))
+      @tracker.update(request(category: 'b', blah: 0.2))
 
       @tracker.sorted_by_frequency.should == [['b', 2], ['a', 1]]
     end
   end
-  
 
   context 'dynamic category' do
     before(:each) do
-      @categorizer = Proc.new { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
-      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => @categorizer)
+      @categorizer = proc { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(category: @categorizer)
       @tracker.prepare
     end
 
-    it "should use the categorizer to determine the right category" do
-      @tracker.update(request(:category => 'a', :duration => 0.2))
-      @tracker.update(request(:category => 'b', :duration => 0.3))
-      @tracker.update(request(:category => 'b', :duration => 0.4))
+    it 'should use the categorizer to determine the right category' do
+      @tracker.update(request(category: 'a', duration: 0.2))
+      @tracker.update(request(category: 'b', duration: 0.3))
+      @tracker.update(request(category: 'b', duration: 0.4))
 
       @tracker.frequency('fast').should == 1
       @tracker.frequency('slow').should == 2
@@ -53,36 +52,36 @@ describe RequestLogAnalyzer::Tracker::Frequency do
 
   describe '#report' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(category: :category)
       @tracker.prepare
     end
 
-    it "should generate a report without errors when one category is present" do
-      @tracker.update(request(:category => 'a', :blah => 0.2))
+    it 'should generate a report without errors when one category is present' do
+      @tracker.update(request(category: 'a', blah: 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', :blah => 0.2))
-      @tracker.update(request(:category => 'b', :blah => 0.2))
+    it 'should generate a report without errors when multiple categories are present' do
+      @tracker.update(request(category: 'a', blah: 0.2))
+      @tracker.update(request(category: 'b', blah: 0.2))
       lambda { @tracker.report(mock_output) }.should_not raise_error
     end
   end
 
   describe '#to_yaml_object' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(:category => :category)
+      @tracker = RequestLogAnalyzer::Tracker::Frequency.new(category: :category)
       @tracker.prepare
     end
 
-    it "should generate a YAML output" do
-      @tracker.update(request(:category => 'a', :blah => 0.2))
-      @tracker.update(request(:category => 'b', :blah => 0.2))
-      @tracker.to_yaml_object.should == { "a" => 1, "b" => 1 }
+    it 'should generate a YAML output' do
+      @tracker.update(request(category: 'a', blah: 0.2))
+      @tracker.update(request(category: 'b', blah: 0.2))
+      @tracker.to_yaml_object.should == { 'a' => 1, 'b' => 1 }
     end
   end
 end

data/spec/unit/tracker/hourly_spread_spec.rb

@@ -7,43 +7,43 @@ describe RequestLogAnalyzer::Tracker::HourlySpread do
     @tracker.prepare
   end
 
-  it "should store timestamps correctly" do
-    @tracker.update(request(:timestamp => 20090102000000))
-    @tracker.update(request(:timestamp => 20090101000000))
-    @tracker.update(request(:timestamp => 20090103000000))
+  it 'should store timestamps correctly' do
+    @tracker.update(request(timestamp: 20_090_102_000_000))
+    @tracker.update(request(timestamp: 20_090_101_000_000))
+    @tracker.update(request(timestamp: 20_090_103_000_000))
 
     @tracker.hour_frequencies[0].should eql(3)
   end
 
-  it "should count the number of timestamps correctly" do
-    @tracker.update(request(:timestamp => 20090102000000))
-    @tracker.update(request(:timestamp => 20090101000000))
-    @tracker.update(request(:timestamp => 20090103000000))
-    @tracker.update(request(:timestamp => 20090103010000))
+  it 'should count the number of timestamps correctly' do
+    @tracker.update(request(timestamp: 20_090_102_000_000))
+    @tracker.update(request(timestamp: 20_090_101_000_000))
+    @tracker.update(request(timestamp: 20_090_103_000_000))
+    @tracker.update(request(timestamp: 20_090_103_010_000))
 
     @tracker.total_requests.should eql(4)
   end
 
-  it "should set the first request timestamp correctly" do
-    @tracker.update(request(:timestamp => 20090102000000))
-    @tracker.update(request(:timestamp => 20090101000000))
-    @tracker.update(request(:timestamp => 20090103000000))
+  it 'should set the first request timestamp correctly' do
+    @tracker.update(request(timestamp: 20_090_102_000_000))
+    @tracker.update(request(timestamp: 20_090_101_000_000))
+    @tracker.update(request(timestamp: 20_090_103_000_000))
 
     @tracker.first_timestamp.should == DateTime.parse('Januari 1, 2009 00:00:00')
   end
 
-  it "should set the last request timestamp correctly" do
-    @tracker.update(request(:timestamp => 20090102000000))
-    @tracker.update(request(:timestamp => 20090101000000))
-    @tracker.update(request(:timestamp => 20090103000000))
+  it 'should set the last request timestamp correctly' do
+    @tracker.update(request(timestamp: 20_090_102_000_000))
+    @tracker.update(request(timestamp: 20_090_101_000_000))
+    @tracker.update(request(timestamp: 20_090_103_000_000))
 
     @tracker.last_timestamp.should == DateTime.parse('Januari 3, 2009 00:00:00')
   end
 
-  it "should return the correct timespan in days when multiple requests are given" do
-    @tracker.update(request(:timestamp => 20090102000000))
-    @tracker.update(request(:timestamp => 20090101000000))
-    @tracker.update(request(:timestamp => 20090103000000))
+  it 'should return the correct timespan in days when multiple requests are given' do
+    @tracker.update(request(timestamp: 20_090_102_000_000))
+    @tracker.update(request(timestamp: 20_090_101_000_000))
+    @tracker.update(request(timestamp: 20_090_103_000_000))
 
     @tracker.timespan.should == 2
   end
@@ -57,23 +57,23 @@ describe RequestLogAnalyzer::Tracker::HourlySpread, 'reporting' do
     @tracker.prepare
   end
 
-  it "should generate a report without errors when no request was tracked" do
+  it 'should generate a report without errors when no request was tracked' do
     lambda { @tracker.report(mock_output) }.should_not raise_error
   end
 
-  it "should generate a report without errors when multiple requests were tracked" do
-    @tracker.update(request(:timestamp => 20090102000000))
-    @tracker.update(request(:timestamp => 20090101000000))
-    @tracker.update(request(:timestamp => 20090103000000))
-    @tracker.update(request(:timestamp => 20090103010000))
+  it 'should generate a report without errors when multiple requests were tracked' do
+    @tracker.update(request(timestamp: 20_090_102_000_000))
+    @tracker.update(request(timestamp: 20_090_101_000_000))
+    @tracker.update(request(timestamp: 20_090_103_000_000))
+    @tracker.update(request(timestamp: 20_090_103_010_000))
     lambda { @tracker.report(mock_output) }.should_not raise_error
   end
-  
-  it "should generate a YAML output" do
-    @tracker.update(request(:timestamp => 20090102000000))
-    @tracker.update(request(:timestamp => 20090101000000))
-    @tracker.update(request(:timestamp => 20090103000000))
-    @tracker.update(request(:timestamp => 20090103010000))
-    @tracker.to_yaml_object.should == {"22:00 - 23:00"=>0, "9:00 - 10:00"=>0, "7:00 - 8:00"=>0, "2:00 - 3:00"=>0, "12:00 - 13:00"=>0, "11:00 - 12:00"=>0, "16:00 - 17:00"=>0, "15:00 - 16:00"=>0, "19:00 - 20:00"=>0, "3:00 - 4:00"=>0, "21:00 - 22:00"=>0, "20:00 - 21:00"=>0, "14:00 - 15:00"=>0, "13:00 - 14:00"=>0, "4:00 - 5:00"=>0, "10:00 - 11:00"=>0, "18:00 - 19:00"=>0, "17:00 - 18:00"=>0, "8:00 - 9:00"=>0, "6:00 - 7:00"=>0, "5:00 - 6:00"=>0, "1:00 - 2:00"=>1, "0:00 - 1:00"=>3, "23:00 - 24:00"=>0}
+
+  it 'should generate a YAML output' do
+    @tracker.update(request(timestamp: 20_090_102_000_000))
+    @tracker.update(request(timestamp: 20_090_101_000_000))
+    @tracker.update(request(timestamp: 20_090_103_000_000))
+    @tracker.update(request(timestamp: 20_090_103_010_000))
+    @tracker.to_yaml_object.should == { '22:00 - 23:00' => 0, '9:00 - 10:00' => 0, '7:00 - 8:00' => 0, '2:00 - 3:00' => 0, '12:00 - 13:00' => 0, '11:00 - 12:00' => 0, '16:00 - 17:00' => 0, '15:00 - 16:00' => 0, '19:00 - 20:00' => 0, '3:00 - 4:00' => 0, '21:00 - 22:00' => 0, '20:00 - 21:00' => 0, '14:00 - 15:00' => 0, '13:00 - 14:00' => 0, '4:00 - 5:00' => 0, '10:00 - 11:00' => 0, '18:00 - 19:00' => 0, '17:00 - 18:00' => 0, '8:00 - 9:00' => 0, '6:00 - 7:00' => 0, '5:00 - 6:00' => 0, '1:00 - 2:00' => 1, '0:00 - 1:00' => 3, '23:00 - 24:00' => 0 }
   end
-end
+end

data/spec/unit/tracker/numeric_value_tracker_spec.rb

@@ -4,37 +4,36 @@ describe RequestLogAnalyzer::Tracker::NumericValue do
 
   context 'static category' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(:category => :category, :value => :blah)
+      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(category: :category, value: :blah)
       @tracker.prepare
     end
 
-    it "should register a request in the right category" do
-      @tracker.update(request(:category => 'a', :blah => 2))
+    it 'should register a request in the right category' do
+      @tracker.update(request(category: 'a', blah: 2))
       @tracker.categories.should include('a')
     end
 
-    it "should register requests in the right category" do
-      @tracker.update(request(:category => 'a', :blah => 2))
-      @tracker.update(request(:category => 'b', :blah => 2))
-      @tracker.update(request(:category => 'b', :blah => 2))
+    it 'should register requests in the right category' do
+      @tracker.update(request(category: 'a', blah: 2))
+      @tracker.update(request(category: 'b', blah: 2))
+      @tracker.update(request(category: 'b', blah: 2))
 
       @tracker.categories['a'][:sum].should == 2
       @tracker.categories['b'][:sum].should == 4
     end
   end
 
-
   context 'dynamic category' do
     before(:each) do
-      @categorizer = Proc.new { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
-      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(:category => @categorizer, :value => :blah)
+      @categorizer = proc { |request| request[:duration] > 0.2 ? 'slow' : 'fast' }
+      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(category: @categorizer, value: :blah)
       @tracker.prepare
     end
 
-    it "should use the categorizer to determine the right category" do
-      @tracker.update(request(:category => 'a', :duration => 0.2, :blah => 2))
-      @tracker.update(request(:category => 'b', :duration => 0.3, :blah => 2))
-      @tracker.update(request(:category => 'b', :duration => 0.4, :blah => 2))
+    it 'should use the categorizer to determine the right category' do
+      @tracker.update(request(category: 'a', duration: 0.2, blah: 2))
+      @tracker.update(request(category: 'b', duration: 0.3, blah: 2))
+      @tracker.update(request(category: 'b', duration: 0.4, blah: 2))
 
       @tracker.categories['fast'][:sum].should == 2
       @tracker.categories['slow'][:sum].should == 4
@@ -43,57 +42,57 @@ describe RequestLogAnalyzer::Tracker::NumericValue do
 
   describe '#update' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(:value => :duration, :category => :category,
-                                                    :min_bucket_value => 0.0001, :max_bucket_value => 1000)
+      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(value: :duration, category: :category,
+                                                    min_bucket_value: 0.0001, max_bucket_value: 1000)
 
       @tracker.prepare
 
-      @tracker.update(request(:category => 'a', :duration => 0.4))
-      @tracker.update(request(:category => 'a', :duration => 0.2))
-      @tracker.update(request(:category => 'a', :duration => 0.3))
+      @tracker.update(request(category: 'a', duration: 0.4))
+      @tracker.update(request(category: 'a', duration: 0.2))
+      @tracker.update(request(category: 'a', duration: 0.3))
     end
 
-    it "should sum of the durations for a category correctly" do
+    it 'should sum of the durations for a category correctly' do
       @tracker.sum('a').should be_within(0.000001).of(0.9)
     end
 
-    it "should overall sum of the durations correctly" do
+    it 'should overall sum of the durations correctly' do
       @tracker.sum_overall.should be_within(0.000001).of(0.9)
     end
 
-    it "should keep track of the minimum and maximum duration" do
+    it 'should keep track of the minimum and maximum duration' do
       @tracker.min('a').should == 0.2
       @tracker.max('a').should == 0.4
     end
 
-    it "should calculate the mean duration correctly" do
+    it 'should calculate the mean duration correctly' do
       @tracker.mean('a').should be_within(0.000001).of(0.3)
     end
 
-    it "should calculate the overall mean duration correctly" do
+    it 'should calculate the overall mean duration correctly' do
       @tracker.mean_overall.should be_within(0.000001).of(0.3)
     end
 
-    it "should calculate the duration variance correctly" do
+    it 'should calculate the duration variance correctly' do
       @tracker.variance('a').should be_within(0.000001).of(0.01)
     end
 
-    it "should calculate the duration standard deviation correctly" do
+    it 'should calculate the duration standard deviation correctly' do
       @tracker.stddev('a').should be_within(0.000001).of(0.1)
     end
 
-    it "should calculate the bucket spread correctly" do
-      @tracker.update(request(:category => 'a', :duration => 0.3))
-      @tracker.update(request(:category => 'a', :duration => 0.3))
-      @tracker.update(request(:category => 'a', :duration => 0.3))
-      @tracker.update(request(:category => 'a', :duration => 0.3))
-      @tracker.update(request(:category => 'a', :duration => 0.3))
-      @tracker.update(request(:category => 'a', :duration => 0.3))
-      @tracker.update(request(:category => 'a', :duration => 0.3))
+    it 'should calculate the bucket spread correctly' do
+      @tracker.update(request(category: 'a', duration: 0.3))
+      @tracker.update(request(category: 'a', duration: 0.3))
+      @tracker.update(request(category: 'a', duration: 0.3))
+      @tracker.update(request(category: 'a', duration: 0.3))
+      @tracker.update(request(category: 'a', duration: 0.3))
+      @tracker.update(request(category: 'a', duration: 0.3))
+      @tracker.update(request(category: 'a', duration: 0.3))
       # 0.2, 0.3 and 0.4 are already there, so, 10 values in total
-      
+
       @tracker.median('a').should be_within(0.01).of(0.3)
-      
+
       @tracker.percentile_interval('a', 80).begin.should be_within(0.01).of(0.3)
       @tracker.percentile_interval('a', 80).end.should be_within(0.01).of(0.3)
       @tracker.percentile_interval('a', 90).begin.should be_within(0.01).of(0.2)
@@ -103,85 +102,85 @@ describe RequestLogAnalyzer::Tracker::NumericValue do
 
   describe '#report' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(:category => :category, :value => :blah)
+      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(category: :category, value: :blah)
       @tracker.prepare
     end
 
-    it "should generate a report without errors when one category is present" do
-      @tracker.update(request(:category => 'a', :blah => 2))
+    it 'should generate a report without errors when one category is present' do
+      @tracker.update(request(category: 'a', blah: 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', :blah => 2))
-      @tracker.update(request(:category => 'b', :blah => 2))
+    it 'should generate a report without errors when multiple categories are present' do
+      @tracker.update(request(category: 'a', blah: 2))
+      @tracker.update(request(category: 'b', blah: 2))
       lambda { @tracker.report(mock_output) }.should_not raise_error
     end
   end
 
   describe '#to_yaml_object' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(:category => :category, :value => :blah)
+      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(category: :category, value: :blah)
       @tracker.prepare
     end
 
-    it "should generate a YAML output" do
-      @tracker.update(request(:category => 'a', :blah => 2))
-      @tracker.update(request(:category => 'b', :blah => 3))
-      @tracker.to_yaml_object.keys.should =~ ['a', 'b']
-      
-      @tracker.to_yaml_object['a'].should include(:min => 2, :hits => 1, :max => 2, :mean => 2.0, :sum => 2, :sum_of_squares => 0.0)
+    it 'should generate a YAML output' do
+      @tracker.update(request(category: 'a', blah: 2))
+      @tracker.update(request(category: 'b', blah: 3))
+      @tracker.to_yaml_object.keys.should =~ %w(a b)
+
+      @tracker.to_yaml_object['a'].should include(min: 2, hits: 1, max: 2, mean: 2.0, sum: 2, sum_of_squares: 0.0)
       @tracker.to_yaml_object['a'][:interval_95_percent].should be_member(2)
-      
-      @tracker.to_yaml_object['b'].should include(:min => 3, :hits => 1, :max => 3, :mean => 3.0, :sum => 3, :sum_of_squares => 0.0)
+
+      @tracker.to_yaml_object['b'].should include(min: 3, hits: 1, max: 3, mean: 3.0, sum: 3, sum_of_squares: 0.0)
       @tracker.to_yaml_object['b'][:interval_95_percent].should be_member(3)
     end
   end
 
   describe '#display_value' do
     before(:each) do
-      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(:category => :category, :value => :blah)
+      @tracker = RequestLogAnalyzer::Tracker::NumericValue.new(category: :category, value: :blah)
       @tracker.prepare
     end
 
-    it "should not crash on nil" do
+    it 'should not crash on nil' do
       lambda { @tracker.display_value(nil) }.should_not raise_error
       @tracker.display_value(nil).should_not be_nil
-      @tracker.display_value(nil).should_not eql("")
+      @tracker.display_value(nil).should_not eql('')
     end
 
-    it "should not touch thousands" do
+    it 'should not touch thousands' do
       @tracker.display_value(1000).should eql('1000 ')
       @tracker.display_value(5000).should eql('5000 ')
       @tracker.display_value(9001).should eql('9001 ')
     end
 
-    it "should reduce milions to thousands (k)" do
-      @tracker.display_value(1000_000).should eql('1000k')
-      @tracker.display_value(5000_000).should eql('5000k')
-      @tracker.display_value(9000_001).should eql('9000k')
+    it 'should reduce milions to thousands (k)' do
+      @tracker.display_value(1_000_000).should eql('1000k')
+      @tracker.display_value(5_000_000).should eql('5000k')
+      @tracker.display_value(9_000_001).should eql('9000k')
     end
 
-    it "should reduce giga to millons (M)" do
-      @tracker.display_value(1000_000_000).should eql('1000M')
-      @tracker.display_value(5000_000_000).should eql('5000M')
-      @tracker.display_value(9000_000_001).should eql('9000M')
+    it 'should reduce giga to millons (M)' do
+      @tracker.display_value(1_000_000_000).should eql('1000M')
+      @tracker.display_value(5_000_000_000).should eql('5000M')
+      @tracker.display_value(9_000_000_001).should eql('9000M')
     end
 
-    it "should reduce teras to gigas (G)" do
-      @tracker.display_value(1000_000_000_000).should eql('1000G')
-      @tracker.display_value(5000_000_000_000).should eql('5000G')
-      @tracker.display_value(9000_000_001_001).should eql('9000G')
+    it 'should reduce teras to gigas (G)' do
+      @tracker.display_value(1_000_000_000_000).should eql('1000G')
+      @tracker.display_value(5_000_000_000_000).should eql('5000G')
+      @tracker.display_value(9_000_000_001_001).should eql('9000G')
     end
 
-    it "should reduce petas to teras (T)" do
-      @tracker.display_value(1000_000_000_000_000).should eql('1000T')
-      @tracker.display_value(5000_000_000_000_000).should eql('5000T')
-      @tracker.display_value(9000_000_001_001_000).should eql('9000T')
+    it 'should reduce petas to teras (T)' do
+      @tracker.display_value(1_000_000_000_000_000).should eql('1000T')
+      @tracker.display_value(5_000_000_000_000_000).should eql('5000T')
+      @tracker.display_value(9_000_000_001_001_000).should eql('9000T')
     end
   end
 end