bigbench 0.0.3 → 0.0.4

data/spec/post_processors/environment_spec.rb

@@ -0,0 +1,412 @@
+require_relative "../helpers"
+
+describe BigBench::PostProcessor::Environment do
+  
+  before(:each) do
+    BigBench.config.duration  = 7.seconds
+    BigBench.config.output    = "spec/tests/sample_results_small.ljson"
+    
+    class << self
+      include BigBench::PostProcessor::Environment
+    end
+    
+    @total_trackings = 3_875
+  end
+  
+  it "should allow to iterate over each tracking" do
+    all_trackings = 0
+    each_tracking do |tracking|
+      tracking.is_a?(Hash).should be_true
+      all_trackings += 1
+    end
+    
+    all_trackings.should == @total_trackings 
+  end
+  
+  it "should collect a trackings array with all trackings" do
+    trackings.size.should == @total_trackings
+    trackings.each do |tracking|
+      tracking.is_a?(Hash).should be_true
+    end
+  end
+  
+  context "statistics", :statistics do
+    
+    it "should calculate the minimum" do
+      statistics.durations.min.should == 1
+      statistics(1.minute).durations.min.should == 1
+      statistics.requests.min.should == 28
+      statistics.methods(:get).min.should == 19
+      statistics.statuses(200).min.should == 28
+      statistics.paths("/").min.should == 19
+    end
+    
+    it "should calculate the maximum" do
+      statistics.durations.max.should == 26
+      statistics.requests.max.should == 591
+      statistics.methods(:get).max.should == 394
+      statistics.statuses(200).max.should == 591
+      statistics.paths("/").max.should == 394
+    end
+    
+    it "should calculate the mean - average" do
+      statistics.durations.mean.should == 1.1945806451612904
+      statistics.durations.average.should == 1.1945806451612904
+      statistics.requests.mean.should == 484.375
+      statistics.methods(:get).mean.should == 323.0
+      statistics.statuses(200).mean.should == 484.375
+      statistics.paths("/").mean.should == 323.0
+    end
+    
+    it "should calculate the standard_deviation - sd" do
+      statistics.durations.standard_deviation.should == 0.3565219562955294
+      statistics.durations.sd.should == 0.3565219562955294
+      statistics.requests.sd.should == 114.09375
+      statistics.methods(:get).sd.should == 76.0
+      statistics.statuses(200).sd.should == 114.09375
+      statistics.paths("/").sd.should == 76.0
+    end
+    
+    it "should calculate the squared_deviation - variance" do
+      statistics.durations.squared_deviation.should == 1.8738803080123505
+      statistics.durations.variance.should == 1.8738803080123505
+      statistics.requests.variance.should == 30844.734375
+      statistics.methods(:get).variance.should == 13687.25
+      statistics.statuses(200).variance.should == 30844.734375
+      statistics.paths("/").variance.should == 13682.0
+    end
+    
+  end
+  
+  context "normal_distribution", :gauss do
+    
+    it "should work with durations" do
+      validate_normal_distribution(normal_distribution.durations).should be_true
+      normal_distribution.durations.formula.should == "1 / sqrt(2 * pi * 0.06692176830748373) * e**( -0.5 * (x - 1.1776612630893981)**2 / 0.06692176830748373)"
+    end
+    
+    it "should work with requests" do
+      validate_normal_distribution(normal_distribution.requests).should be_true
+      normal_distribution.requests.formula.should == "1 / sqrt(2 * pi * 114.09375) * e**( -0.5 * (x - 484.375)**2 / 114.09375)"
+    end
+    
+    it "should work with methods" do
+      validate_normal_distribution(normal_distribution.methods(:get)).should be_true
+      normal_distribution.methods(:get).formula.should == "1 / sqrt(2 * pi * 76.0) * e**( -0.5 * (x - 323.0)**2 / 76.0)"
+    end
+    
+    it "should work with statuses" do
+      validate_normal_distribution(normal_distribution.statuses(200)).should be_true
+      normal_distribution.statuses(200).formula.should == "1 / sqrt(2 * pi * 114.09375) * e**( -0.5 * (x - 484.375)**2 / 114.09375)"
+    end
+    
+    it "should work with paths" do
+      validate_normal_distribution(normal_distribution.paths("/")).should be_true
+      normal_distribution.paths("/").formula.should == "1 / sqrt(2 * pi * 76.0) * e**( -0.5 * (x - 323.0)**2 / 76.0)"
+    end
+    
+  end
+  
+  context "cluster", :cluster do
+    
+    it "should work with timesteps" do
+      cluster.timesteps.size.should           == 8
+      cluster(1.second).timesteps.size.should == 8
+      cluster(1.minute).timesteps.size.should == 1
+    end
+    
+    it "should work with durations" do
+      cluster.durations.size.should == 8
+      cluster.durations.each{ |duration| duration.is_a?(Float) }
+    end
+    
+    it "should work with requests" do
+      cluster.requests.size.should == 8
+      cluster.requests.each{ |requests| requests.is_a?(Integer) }
+    end
+    
+    it "should work with methods" do
+      cluster.methods(:get).size.should       == 8
+      cluster.methods(:post).size.should      == 8
+      cluster.methods(:nothing).size.should   == 8
+      
+      cluster.methods(:post).each{      |requests| requests.is_a?(Integer) }
+      cluster.methods(:nothing).each{   |requests| requests.is_a?(Integer) }
+    end
+    
+    it "should work with statuses" do
+      cluster.statuses(200).size.should       == 8
+      cluster.statuses(404).size.should       == 8
+      cluster.statuses("nothing").size.should == 8
+      
+      cluster.statuses(200).each{       |requests| requests.is_a?(Integer) }
+      cluster.statuses(404).each{       |requests| requests.is_a?(Integer) }
+    end
+    
+    it "should work with paths" do
+      cluster.paths("/").size.should          == 8
+      cluster.paths("/pages").size.should     == 8
+      cluster.paths("nothing").size.should    == 8
+      
+      cluster.paths("/").each{          |requests| requests.is_a?(Integer) }
+      cluster.paths("/pages").each{     |requests| requests.is_a?(Integer) }
+    end
+    
+  end
+  
+  context "linear regression", :linreg do
+    
+    it "should create durations with the default timebase" do
+      polynomial_regression.durations.x.size.should == 8
+      polynomial_regression.durations.y.size.should == 8
+      polynomial_regression.durations.derivation(0).size.should == 8
+      polynomial_regression.durations.derivation(1).size.should == 8
+      polynomial_regression.durations.degree.should == 1
+      polynomial_regression.durations.coefficients.should == [1.174433419687437, 0.0009222409719889246]
+      polynomial_regression.durations.formula.should == "1.174433419687437 + 0.0009222409719889246x^1"
+      polynomial_regression.durations.formula(1).should == "0.0009222409719889246"
+    end
+    
+    it "should create requests with the default timebase" do
+      polynomial_regression.requests.x.size.should == 8
+      polynomial_regression.requests.y.size.should == 8
+      polynomial_regression.requests.derivation(0).size.should == 8
+      polynomial_regression.requests.derivation(1).size.should == 8
+
+      polynomial_regression.requests.degree.should == 1
+      polynomial_regression.requests.coefficients.should == [334.5000000000001, 42.82142857142857]
+      polynomial_regression.requests.formula.should == "334.5000000000001 + 42.82142857142857x^1"
+      polynomial_regression.requests.formula(1).should == "42.82142857142857"
+    end
+    
+    it "should create methods with the default timebase" do
+      polynomial_regression.methods(:get).x.size.should == 8
+      polynomial_regression.methods(:get).y.size.should == 8
+      polynomial_regression.methods(:get).derivation(0).size.should == 8
+      polynomial_regression.methods(:get).derivation(1).size.should == 8
+
+      polynomial_regression.methods(:get).degree.should == 1
+      polynomial_regression.methods(:get).coefficients.should == [223.25000000000006, 28.499999999999996]
+      polynomial_regression.methods(:get).formula.should == "223.25000000000006 + 28.499999999999996x^1"
+      polynomial_regression.methods(:get).formula(1).should == "28.499999999999996"
+    end
+    
+    it "should create statuses with the default timebase" do
+      polynomial_regression.statuses(200).x.size.should == 8
+      polynomial_regression.statuses(200).y.size.should == 8
+      polynomial_regression.statuses(200).derivation(0).size.should == 8
+      polynomial_regression.statuses(200).derivation(1).size.should == 8
+
+      polynomial_regression.statuses(200).degree.should == 1
+      polynomial_regression.statuses(200).coefficients.should == [334.5000000000001, 42.82142857142857]
+      polynomial_regression.statuses(200).formula.should == "334.5000000000001 + 42.82142857142857x^1"
+      polynomial_regression.statuses(200).formula(1).should == "42.82142857142857"
+    end
+    
+    it "should create paths with the default timebase" do
+      polynomial_regression.paths("/").x.size.should == 8
+      polynomial_regression.paths("/").y.size.should == 8
+      polynomial_regression.paths("/").derivation(0).size.should == 8
+      polynomial_regression.paths("/").derivation(1).size.should == 8
+
+      polynomial_regression.paths("/").degree.should == 1
+      polynomial_regression.paths("/").coefficients.should == [223.00000000000006, 28.571428571428566]
+      polynomial_regression.paths("/").formula.should == "223.00000000000006 + 28.571428571428566x^1"
+      polynomial_regression.paths("/").formula(1).should == "28.571428571428566"
+    end
+    
+    it "should create durations with a too small custom timebase" do
+      lambda{ polynomial_regression(:timebase => 1.minute).durations.x.size.should == 1 }.should raise_exception, "Regression is not possible for a single time value, choose a smaller timebase"
+    end
+    
+    it "should create durations with a too small custom timebase" do
+      polynomial_regression(:timebase => 4.seconds).durations.x.size.should == 2
+      polynomial_regression(:timebase => 4.seconds).durations.y.size.should == 2
+      polynomial_regression(:timebase => 4.seconds).durations.derivation(0).size.should == 2
+      polynomial_regression(:timebase => 4.seconds).durations.derivation(1).size.should == 2
+      polynomial_regression(:timebase => 4.seconds).durations.degree.should == 1
+      polynomial_regression(:timebase => 4.seconds).durations.coefficients.should == [1.2389749702026223, -0.07830132432187575]
+      polynomial_regression(:timebase => 4.seconds).durations.formula.should == "1.2389749702026223 + -0.07830132432187575x^1"
+      polynomial_regression(:timebase => 4.seconds).durations.formula(1).should == "-0.07830132432187575"
+    end
+    
+  end
+  
+  context "quadratic regression", :quadreg do
+    
+    it "should create durations with the default timebase" do
+      polynomial_regression(:degree => 2).durations.x.size.should == 8
+      polynomial_regression(:degree => 2).durations.y.size.should == 8
+      polynomial_regression(:degree => 2).durations.derivation(0).size.should == 8
+      polynomial_regression(:degree => 2).durations.derivation(1).size.should == 8
+      polynomial_regression(:degree => 2).durations.degree.should == 2
+      polynomial_regression(:degree => 2).durations.coefficients.should == [1.1347571673566461, 0.04059849330278298, -0.005668036047256117]
+      polynomial_regression(:degree => 2).durations.formula.should == "1.1347571673566461 + 0.04059849330278298x^1 + -0.005668036047256117x^2"
+      polynomial_regression(:degree => 2).durations.formula(1).should == "0.04059849330278298 + 2*-0.005668036047256117x^1"
+    end
+    
+  end
+  
+  context "appearing", :appearing do
+    
+    it "should list statuses" do
+      appearing.statuses.should == [200]
+    end
+    
+    it "should list methods" do
+      appearing.methods.should == ["get", "post"]
+    end
+    
+    it "should list paths" do
+      appearing.paths.should == ["/", "/basic/auth"]
+    end
+    
+  end
+    
+  context "benchmark scope", :benchmark do
+    
+    before(:each) do
+      BigBench.config.output    = "spec/tests/sample_results_small.ljson"
+      BigBench.benchmark("index page" => "http://localhost:3001"){ get "/" }
+      BigBench.benchmark("logout page" => "http://localhost:3001"){ get "/" }
+    end
+    
+    it "should offer an iterator over the benchmarks and set the scope", :scope do      
+      run_benchmarks = []
+      each_benchmark do |benchmark|
+        scope.should == benchmark.name
+        run_benchmarks << scope
+      end
+      
+      run_benchmarks.should == ["index page", "logout page"]
+    end
+    
+    
+    it "should scope cluster" do      
+      scope_to_benchmark("index page") do
+        cluster.requests.size.should == 8
+      end
+      
+      scope_to_benchmark("logout page") do
+        cluster.requests.size.should == 8
+      end
+
+      lambda{ scope_to_benchmark("not existant"){}}.should raise_exception BigBench::PostProcessor::Environment::BenchmarkNotFound, "Could not find Benchmark: 'not existant'. Available benchmarks are: index page, logout page"
+    end
+    
+    it "should scope statistics" do      
+      scope_to_benchmark("index page") do
+        statistics.requests.min.should == 14
+        statistics.requests.mean.should == 470.75
+        statistics.requests.max.should == 577
+        statistics.requests.sd.should == 114.875
+        statistics.requests.variance.should == 31206.6875
+      end
+      
+      scope_to_benchmark("logout page") do
+        statistics.requests.min.should == 5
+        statistics.requests.mean.should == 13.625
+        statistics.requests.max.should == 42
+        statistics.requests.sd.should == 7.28125
+        statistics.requests.variance.should == 127.234375
+      end
+
+      lambda{ scope_to_benchmark("not existant"){}}.should raise_exception BigBench::PostProcessor::Environment::BenchmarkNotFound, "Could not find Benchmark: 'not existant'. Available benchmarks are: index page, logout page"
+    end
+    
+    it "should scope normal_distribution" do      
+      scope_to_benchmark("index page") do
+        validate_normal_distribution(normal_distribution.requests).should be_true
+        validate_normal_distribution(normal_distribution.durations).should be_true
+      end
+      
+      scope_to_benchmark("logout page") do
+        validate_normal_distribution(normal_distribution.requests).should be_true
+        validate_normal_distribution(normal_distribution.durations).should be_true
+      end
+      
+      lambda{ scope_to_benchmark("not existant"){}}.should raise_exception BigBench::PostProcessor::Environment::BenchmarkNotFound, "Could not find Benchmark: 'not existant'. Available benchmarks are: index page, logout page"
+    end
+    
+    
+    it "should scope polynomial_regression", :benchmark_regression do
+      
+      scope_to_benchmark("index page") do
+        polynomial_regression.durations.x.size.should == 8
+        polynomial_regression.durations.y.size.should == 8
+        polynomial_regression.durations.derivation(0).size.should == 8
+        polynomial_regression.durations.derivation(1).size.should == 8
+        polynomial_regression.durations.degree.should == 1
+        polynomial_regression.durations.coefficients.should == [1.1646812659828312, 0.0032629471307769192]
+        polynomial_regression.durations.formula.should == "1.1646812659828312 + 0.0032629471307769192x^1"
+        polynomial_regression.durations.formula(1).should == "0.0032629471307769192"
+      end
+      
+      scope_to_benchmark("logout page") do
+        polynomial_regression.durations.x.size.should == 8
+        polynomial_regression.durations.y.size.should == 8
+        polynomial_regression.durations.derivation(0).size.should == 8
+        polynomial_regression.durations.derivation(1).size.should == 8
+        polynomial_regression.durations.degree.should == 1
+        polynomial_regression.durations.coefficients.should == [1.0714285714285718, -0.0012755102040815924]
+        polynomial_regression.durations.formula.should == "1.0714285714285718 + -0.0012755102040815924x^1"
+        polynomial_regression.durations.formula(1).should == "-0.0012755102040815924"
+      end
+      
+      lambda{ scope_to_benchmark("not existant"){}}.should raise_exception BigBench::PostProcessor::Environment::BenchmarkNotFound, "Could not find Benchmark: 'not existant'. Available benchmarks are: index page, logout page"
+    end
+    
+  end
+  
+  context "inkonsistant test data", :inconsistant do
+    
+    before(:each) do
+      BigBench.config.duration  = 20.seconds
+      BigBench.config.output    = "spec/tests/result.ljson"
+    end
+    
+    it "should work with statistics" do
+      statistics.durations.min.should == 82
+      statistics(1.minute).durations.min.should == 82
+      statistics.requests.min.should == 0
+      statistics.methods(:get).min.should == 0
+      statistics.statuses(200).min.should == 0
+      statistics.paths("/").min.should == 0
+      
+      statistics.methods(:get).max.should == 9
+      statistics.durations.mean.should == 310.3720930232558
+      statistics.durations.average.should == 310.3720930232558
+      statistics.durations.sd.should == 330.36776636019465
+      statistics.requests.sd.should == 2.2675736961451247
+      statistics.durations.variance.should == 157094.37317468924
+      statistics.requests.variance.should == 8.616780045351472
+    end
+    
+    it "should work with normal_distribution" do
+      validate_normal_distribution(normal_distribution.durations).should be_true
+      normal_distribution.durations.formula.should == "1 / sqrt(2 * pi * 453.6664147140337) * e**( -0.5 * (x - 484.0502645502645)**2 / 453.6664147140337)"
+    end
+    
+    it "should work with clusters" do
+      cluster.timesteps.should have(21).timesteps
+      cluster(1.second).should have(21).timesteps
+      cluster(1.minute).should have(1).timesteps
+      cluster.methods(:get).should have(21).entries
+      cluster.methods(:post).should have(21).entries
+      cluster.methods(:nothing).should have(21).entries
+    end
+    
+    it "should work with a polynomial regression" do
+      polynomial_regression.durations.x.size.should == 21
+      polynomial_regression.durations.y.size.should == 21
+      polynomial_regression.durations.derivation(0).size.should == 21
+      polynomial_regression.durations.derivation(1).size.should == 21
+      polynomial_regression.durations.degree.should == 1
+      polynomial_regression.durations.coefficients.should == [695.226310726311, -21.117604617604627]
+      polynomial_regression.durations.formula.should == "695.226310726311 + -21.117604617604627x^1"
+      polynomial_regression.durations.formula(1).should == "-21.117604617604627"
+    end
+    
+  end
+   
+end

data/spec/post_processors/graphs_spec.rb

@@ -0,0 +1,23 @@
+require_relative "../helpers"
+require_relative "../../lib/bigbench/post_processor/graphs"
+
+describe BigBench::PostProcessor::Graphs do
+  
+  it "should run and create the following graphs" do    
+    folder = "spec/tmp/graphs_#{Time.now.to_i}"
+    
+    BigBench.config.duration = 2.minutes
+    BigBench.config.output = "spec/tests/sample_results_big.ljson"
+    BigBench.benchmark("index page" => "http://localhost:3001"){ get "/" }
+    BigBench.post_process :graphs, :folder => folder
+    
+    BigBench.benchmarks.should      have(1).benchmark
+    BigBench.post_processors.should have(1).processor
+    
+    lambda{ BigBench.post_processors.first.run! }.should_not raise_exception
+    Dir["#{folder}/*.png"].size.should == 18
+    
+    Dir["spec/tmp/*"].each{ |folder| FileUtils.rm_rf(folder) }
+  end
+  
+end

data/spec/post_processors/statistics_spec.rb

@@ -3,8 +3,9 @@ require_relative "../helpers"
 describe BigBench::PostProcessor::Statistics do
   
   it "should run and create the following statistics" do    
-
-    BigBench.config.output = "spec/tests/result.ljson"
+    BigBench.config.duration = 2.minutes
+    BigBench.config.output = "spec/tests/sample_results_big.ljson"
+    BigBench.benchmark("index page" => "http://localhost:3001"){ get "/" }
     BigBench.post_process :statistics
     
     lambda{ BigBench.post_processors.first.run! }.should_not raise_exception

data/spec/tests/local.rb

@@ -1,6 +1,6 @@
 BigBench.configure = {
   :duration => 1.seconds,
-  :output   => "spec/temp/local.ljson",
+  :output   => "spec/tmp/local.ljson",
   :users  => 1
 }