kametori 0.0.2 → 0.0.3

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/README.md

@@ -1,6 +1,6 @@
 # Kametori
 
-TODO: Write a gem description
+Kametori helps you to write a benchmark test suite
 
 ## Installation
 
@@ -18,7 +18,26 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+The best way to use this gem is adding a profile to your
+cucumber.yml file (usually located in config in Rails projects).
+Like:
+benchmark: --format progress -r features/support/benchmark.rb
+
+And in features/support/benchmark.rb you write:
+
+ Kametori.scenario_limits = [{ tag: "fast_scenario", limit:1 },
+{tag:"slow_scenario", limit:10}]
+   
+ Kametori.raise_errors = true
+
+ Around do |scenario, block|
+   Kametori.scenario_benchmark(scenario) do
+     block.call
+   end
+ end
+
+
+
 
 ## Contributing
 

data/kametori.gemspec

@@ -17,4 +17,6 @@ Gem::Specification.new do |gem|
   gem.version       = Kametori::VERSION
 
   gem.add_development_dependency("rspec", [">= 2.2.0"])
+  gem.add_development_dependency("timecop")
+  gem.add_development_dependency("debugger")
 end

data/lib/kametori/version.rb

@@ -1,3 +1,3 @@
 module Kametori
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/kametori.rb

@@ -2,36 +2,89 @@ require "kametori/version"
 
 module Kametori
   # exception classes
-  class Error < RuntimeError
-  end
-  class Timeout < RuntimeError
-
+  class Timeout < StandardError
   end
 
   class << self
-    def limits=(limits)
-      raise Error if !limits.is_a? Array
+    attr_accessor :raise_errors
+    def reset!
+      @raise_errors = false
+      @limits = []
+      @repeat_count = 1
+    end
+    def scenario_limits=(limits)
+      check_limits (limits)
       @limits = limits
     end
 
-    def limits
-      @limits
+    def scenario_limits
+      @limits || []
+    end
+
+    def average_over=(count)
+      raise( ArgumentError, "Wrong average over count") unless count.is_a? Integer
+      raise( ArgumentError, "Wrong average over count") if count < 1
+      @repeat_count = count
+    end
+
+    def current_scenario
+      @current_scenario || {}
     end
 
-    def benchmark_scenario(scenario, options={})
-      under_test = @limits.find{ |limit| limit[:tag] == scenario.tag}
+    def average_over
+      current_scenario[:average_over] || @repeat_count || 1
+    end
+
+    def scenario_benchmark(scenario, options={}, &block)
+      under_test = find_scenario_under_test(scenario)
       return nil if under_test.nil?
-      before = Time.now
-        yield if block_given?
-      after = Time.now
-      elapsed = after - before
-      if options[:raise]
-        if ( elapsed > under_test[:limit])
-          raise Timeout
-        end
-      end
+      return nil unless block_given?
+      
+      elapsed = execute_with_timing(average_over) { block.call }
+      limit = under_test[:limit]
+      check_finish_on_time(elapsed,limit)
       elapsed
     end
     
+    private
+
+    def check_limits(limits)
+      correct = limits.is_a?(Array) &&
+                limits.all? { |l| l.include?(:tag) && l.include?(:limit) && l[:limit].is_a?(Numeric)}
+      raise( ArgumentError, "wrong scenario limits") unless correct
+    end
+
+    def find_scenario_under_test(scenario)
+      @current_scenario = @limits.find{ |limit| scenario.source_tag_names.include? limit[:tag] }
+    end
+
+    def execute_with_timing(average_over)
+      elapsed = []
+      average_over.times do
+        before = Time.now
+        yield
+        after = Time.now
+        elapsed.push (after - before)
+      end
+      mean(elapsed)
+    end
+
+    def check_finish_on_time( elapsed, limit )
+      if raise_errors
+        if ( elapsed > limit)
+          raise Timeout, "Scenario timed out with #{format_float(elapsed)} > #{limit}"
+        end
+      end
+    end
+
+    def format_float(float)
+      "%.3f" % float
+    end
+
+    def mean(array)
+      sum = array.inject(0){ |accum, i| accum + i }
+      sum / array.length.to_f
+    end
+
   end
 end

data/spec/kametori_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+# our mock for a cucumber scenario
+class Scenario
+  attr_accessor :source_tag_names
+  attr_accessor :execution_time
+  attr_reader :times_called
+  def initialize (names)
+    @source_tag_names = [*names]
+    @execution_time = 0.1
+    @times_called = 0
+  end
+  def execute
+    Timecop.travel Time.now + @execution_time
+    @times_called += 1
+  end
+end
+
+describe Kametori do 
+
+=begin
+  describe '.standard=' do 
+    it 'raises Kametori::Error if is an unknown standard' do
+      expect {Kametori.standard='asdfasdf'}.to raise_error(Kamitori::Error)
+    end
+  end
+
+  describe '.speed_test' do
+  end
+=end
+  describe '.scenario_limits=' do 
+    it 'should raise an error if the param is not an array' do
+      expect { Kametori.scenario_limits= 2 }.to raise_error(ArgumentError, "wrong scenario limits")
+    end
+    it 'should raise an error if there is no limit for tag' do
+      expect { Kametori.scenario_limits=[{tag:"aa"}] }.to raise_error(ArgumentError, "wrong scenario limits")
+    end
+    it 'should raise and error if there is no tag for limit' do 
+      expect { Kametori.scenario_limits=[{limit:2}] }.to raise_error(ArgumentError, "wrong scenario limits")
+    end
+    it 'should raise and error if limit is not numeric' do 
+      limits = [{ tag: "A", limit: "a"} ]
+      expect { Kametori.scenario_limits= limits }.to raise_error(ArgumentError, "wrong scenario limits")
+    end
+    it 'should set the limits for the tags' do 
+      limits = [{ tag: "A", limit: 1} ]
+      Kametori.scenario_limits = limits
+      Kametori.scenario_limits.should == limits 
+    end
+  end
+  
+  describe '.reset!' do
+    it 'should reset to the defaults' do
+      Kametori.reset!
+      Kametori.average_over.should == 1
+      Kametori.scenario_limits.should be_empty
+      Kametori.raise_errors.should be_false
+    end
+  end
+  describe '.average_over' do
+    it 'should raise an error if the parameter is not integer' do
+      expect { Kametori.average_over=1.2 }.to raise_error(ArgumentError, "Wrong average over count")
+    end
+    it 'should raise an error if the parameter is less than 1' do 
+      expect { Kametori.average_over=0 }.to raise_error(ArgumentError, "Wrong average over count")
+    end
+    it 'defaults to 1 executions' do
+      Kametori.average_over.should == 1
+      Kametori.average_over= 10
+      Kametori.average_over.should == 10
+    end
+  end
+
+  describe '.scenario_benchmark' do
+    before do
+      @time_limit = 0.2
+      Timecop.freeze Time.now
+      limits = [{ tag: "MyTag", limit: @time_limit}, {tag: "MyTag2", limit:@time_limit} ]
+      Kametori.scenario_limits = limits
+      Kametori.average_over= 1
+    end
+    it 'should return nil if we do not have a limit for this scenario' do
+      scenario = Scenario.new("OtherTag")
+      Kametori.scenario_benchmark( scenario ) do
+        scenario.execute
+      end.should == nil
+    end
+    it 'should return nil if no block given' do
+      scenario = Scenario.new("MyTag")
+      Kametori.scenario_benchmark( scenario ).should == nil
+    end
+    it 'should return the time it took to finish the scenario' do
+      scenario = Scenario.new("MyTag")
+      Kametori.scenario_benchmark( scenario ) do
+        scenario.execute
+      end.should >= 0.1
+    end
+
+    it 'should work with scenarios with several tags' do
+      scenario = Scenario.new(["MyTag", "otherTag", "one_more"])
+      Kametori.scenario_benchmark( scenario ) do
+        scenario.execute
+      end.should >= 0.1
+    end
+
+    describe '.average_over' do 
+      it 'should call average_over times the block passed' do
+        scenario = Scenario.new("MyTag")
+        Kametori.average_over = 5
+        Kametori.scenario_benchmark( scenario ) do
+          scenario.execute
+        end
+        scenario.times_called.should == 5
+        Kametori.average_over = 1
+      end
+      it '.average_over can be overriden by the value in the hash' do
+        old_limits = Kametori.scenario_limits
+        limits = [{ tag: "MyTag", limit: @time_limit, average_over: 2}, {tag: "MyTag2", limit:@time_limit} ]
+        Kametori.scenario_limits = limits
+        Kametori.average_over = 5
+        scenario = Scenario.new("MyTag")
+        Kametori.scenario_benchmark( scenario ) do
+          scenario.execute
+        end
+        scenario.times_called.should == 2
+        Kametori.scenario_limits = old_limits
+      end
+    end
+
+    describe '.raise_errors' do
+      it 'should return the time it took to finish the scenario and not raise if it finished before the limit' do
+        scenario = Scenario.new("MyTag")
+        Kametori.raise_errors = true
+        Kametori.scenario_benchmark( scenario ) do
+          scenario.execute
+        end.should < 0.2
+      end
+
+      it 'should raise Kametori::Timeout if the scenario is slower than its limit and we set to raise' do
+        scenario = Scenario.new("MyTag")
+        scenario.execution_time = 0.21
+        Kametori.raise_errors = true
+        expect do
+          Kametori.scenario_benchmark( scenario ) do
+            scenario.execute
+          end
+        end.to raise_error( Kametori::Timeout, /Scenario timed out with [0-9]*\.?[0-9]{3} > #{@time_limit}/ )
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require_relative '../lib/kametori'
+require 'timecop'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kametori
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -27,6 +27,38 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A gem to create benchmark suites for your app. It allows you to keep
   track of your performance
 email:
@@ -36,6 +68,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE
 - README.md
@@ -43,6 +76,8 @@ files:
 - kametori.gemspec
 - lib/kametori.rb
 - lib/kametori/version.rb
+- spec/kametori_spec.rb
+- spec/spec_helper.rb
 homepage: http://www.github.com/JordiPolo/kametori
 licenses: []
 post_install_message: 
@@ -67,5 +102,7 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A gem to create benchmark suites for your app.
-test_files: []
+test_files:
+- spec/kametori_spec.rb
+- spec/spec_helper.rb
 has_rdoc: