scoot 0.0.4

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/metric_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Hitimes::Metric do
+  before( :each ) do
+    @metric = Hitimes::Metric.new( "testing" )
+  end
+
+  it 'has a name' do
+    @metric.name.must_equal "testing"
+  end
+
+  it "has associated data from initialization" do
+    m = Hitimes::Metric.new( "more-data", 'foo' => 'bar', 'this' => 'that' )
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
+    
+    m = Hitimes::Metric.new( "more-data", { 'foo' => 'bar', 'this' => 'that' } )
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
+  end
+
+  it "initially has no sampling times" do
+    @metric.sampling_start_time.must_be_nil
+    @metric.sampling_stop_time.must_be_nil
+  end
+end
+
+ 

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/mutex_stats_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Hitimes::MutexedStats do
+  before( :each ) do
+    @threads = 5
+    @iters   = 10_000
+    @final_value = @threads * @iters
+  end
+
+  def run_with_scissors( stats, threads, iters )
+    spool = []
+    threads.times do |t|
+      spool << Thread.new { iters.times{ stats.update( 1 ) } }
+    end
+    spool.each { |t| t.join }
+    return stats
+  end
+
+  if (not defined? RUBY_ENGINE) or (RUBY_ENGINE == "ruby") then
+    it "Hitimes::Stats is threadsafe" do
+      stats = run_with_scissors( ::Hitimes::Stats.new, @threads, @iters )
+      stats.count.must_equal @final_value
+    end
+  else
+    it "Hitimes::Stats is not threadsafe" do
+      stats = run_with_scissors( ::Hitimes::Stats.new, @threads, @iters )
+      stats.count.wont_equal @final_value
+    end
+  end
+
+  it "has a threadsafe update" do
+    stats = run_with_scissors( ::Hitimes::MutexedStats.new, @threads, @iters )
+    stats.count.must_equal @final_value
+  end
+
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/paths_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Hitimes::Paths do
+  it "can access the root dir of the project" do
+    Hitimes::Paths.root_dir.must_equal File.expand_path( File.join( File.dirname( __FILE__ ), ".." ) ) + ::File::SEPARATOR
+  end
+
+  it "can access the lib path of the project" do
+    Hitimes::Paths.lib_path.must_equal File.expand_path( File.join( File.dirname( __FILE__ ), "..", "lib" ) ) + ::File::SEPARATOR
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+if RUBY_VERSION >= '1.9.2' then
+  require 'simplecov'
+  puts "Using coverage!"
+  SimpleCov.start if ENV['COVERAGE']
+end
+
+gem 'minitest'
+require 'hitimes'
+require 'minitest/autorun'
+require 'minitest/pride'
+

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/stats_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'json'
+
+describe Hitimes::Stats do
+  before( :each ) do
+    @stats = Hitimes::Stats.new
+    @full_stats = Hitimes::Stats.new
+    
+    [ 1, 2, 3].each { |i| @full_stats.update( i ) }
+  end
+
+  it "is initialized with 0 values" do
+    @stats.count.must_equal 0
+    @stats.min.must_equal 0.0
+    @stats.max.must_equal 0.0
+    @stats.sum.must_equal 0.0
+    @stats.rate.must_equal 0.0
+  end
+
+  it "calculates the mean correctly" do
+    @full_stats.mean.must_equal 2.0
+  end
+
+  it "calculates the rate correctly" do
+    @full_stats.rate.must_equal 0.5
+  end
+
+  it "tracks the maximum value" do
+    @full_stats.max.must_equal 3.0
+  end
+
+  it "tracks the minimum value" do
+    @full_stats.min.must_equal 1.0
+  end
+
+  it "tracks the count" do
+    @full_stats.count.must_equal 3
+  end
+  
+  it "tracks the sum" do
+    @full_stats.sum.must_equal 6.0
+  end
+
+  it "calculates the standard deviation" do
+    @full_stats.stddev.must_equal 1.0
+  end 
+
+  it "calculates the sum of squares " do
+    @full_stats.sumsq.must_equal 14.0
+  end 
+
+  describe "#to_hash " do
+    it "converts to a Hash" do
+      h = @full_stats.to_hash
+      h.size.must_equal ::Hitimes::Stats::STATS.size
+      h.keys.sort.must_equal ::Hitimes::Stats::STATS
+    end
+
+    it "converts to a limited Hash if given arguments" do
+      h = @full_stats.to_hash( "min", "max", "mean" )
+      h.size.must_equal 3
+      h.keys.sort.must_equal %w[ max mean min  ]
+
+      h = @full_stats.to_hash( %w[ count rate ] )
+      h.size.must_equal 2
+      h.keys.sort.must_equal %w[ count rate ]
+    end
+
+    it "raises NoMethodError if an invalid stat is used" do
+      lambda { @full_stats.to_hash( "wibble" ) }.must_raise( NoMethodError )
+    end
+  end
+
+  describe "#to_json" do
+    it "converts to a json string" do
+      j = @full_stats.to_json
+      h = JSON.parse( j )
+      h.size.must_equal ::Hitimes::Stats::STATS.size
+      h.keys.sort.must_equal ::Hitimes::Stats::STATS
+    end
+
+    it "converts to a limited Hash if given arguments" do
+      j = @full_stats.to_json( "min", "max", "mean" )
+      h = JSON.parse( j )
+      h.size.must_equal 3
+      h.keys.sort.must_equal %w[ max mean min  ]
+
+      j = @full_stats.to_json( %w[ count rate ] )
+      h = JSON.parse( j )
+      h.size.must_equal 2
+      h.keys.sort.must_equal %w[ count rate ]
+    end
+
+    it "raises NoMethodError if an invalid stat is used" do
+      lambda { @full_stats.to_json( "wibble" ) }.must_raise( NoMethodError )
+    end
+  end
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/timed_metric_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe Hitimes::TimedMetric do
+  before( :each ) do
+    @tm = Hitimes::TimedMetric.new( 'test-timed-metric' )
+  end
+
+  it "knows if it is running or not" do
+    @tm.running?.must_equal false
+    @tm.start
+    @tm.running?.must_equal true
+    @tm.stop
+    @tm.running?.must_equal false
+  end
+
+  it "#split returns the last duration and the timer is still running" do
+    @tm.start
+    d = @tm.split
+    @tm.running?.must_equal true
+    d.must_be :>, 0
+    @tm.count.must_equal 1
+    @tm.duration.must_equal d
+  end
+
+  it "#stop returns false if called more than once in a row" do
+    @tm.start
+    @tm.stop.must_be :>, 0
+    @tm.stop.must_equal false
+  end
+
+  it "does not count a currently running interval as an interval in calculations" do
+    @tm.start
+    @tm.count.must_equal 0
+    @tm.split
+    @tm.count.must_equal 1
+  end
+
+  it "#split called on a stopped timer does nothing" do
+    @tm.start
+    @tm.stop
+    @tm.split.must_equal false
+  end
+
+  it "calculates the mean of the durations" do
+    2.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    @tm.mean.must_be_close_to(0.05, 0.002)
+  end
+
+  it "calculates the rate of the counts " do
+    5.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    @tm.rate.must_be_close_to(20.00, 0.5)
+  end
+
+
+  it "calculates the stddev of the durations" do
+    3.times { |x| @tm.start ; sleep(0.05 * x) ; @tm.stop }
+    @tm.stddev.must_be_close_to(0.05)
+  end
+
+  it "returns 0.0 for stddev if there is no data" do
+    @tm.stddev.must_equal 0.0
+  end
+
+  it "keeps track of the min value" do
+    2.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    @tm.min.must_be_close_to(0.05, 0.01)
+  end
+
+  it "keeps track of the max value" do
+    2.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    @tm.max.must_be_close_to(0.05, 0.01)
+  end
+
+  it "keeps track of the sum value" do
+    2.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    @tm.sum.must_be_close_to(0.10, 0.01)
+  end
+
+  it "keeps track of the sum of squars value" do
+    3.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    @tm.sumsq.must_be_close_to(0.0075)
+  end
+
+  it "keeps track of the minimum start time of all the intervals" do
+    f1 = Time.now.gmtime.to_f * 1_000_000
+    5.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    f2 = Time.now.gmtime.to_f * 1_000_000
+    @tm.sampling_start_time.must_be :>=, f1
+    @tm.sampling_start_time.must_be :<, f2
+    # distance from now to start time should be greater than the distance from
+    # the start to the min start_time
+    (f2 - @tm.sampling_start_time).must_be :>, ( @tm.sampling_start_time - f1 )
+  end
+
+  it "keeps track of the last stop time of all the intervals" do
+    f1 = Time.now.gmtime.to_f * 1_000_000
+    sleep 0.01
+    5.times { @tm.start ; sleep 0.05 ; @tm.stop }
+    sleep 0.01
+    f2 = Time.now.gmtime.to_f * 1_000_000
+    @tm.sampling_stop_time.must_be :>, f1
+    @tm.sampling_stop_time.must_be :<=, f2
+    # distance from now to max stop time time should be less than the distance
+    # from the start to the max stop time
+    (f2 - @tm.sampling_stop_time).must_be :<, ( @tm.sampling_stop_time - f1 )
+  end
+
+  it "can create an already running timer" do
+    t = Hitimes::TimedMetric.now( 'already-running' )
+    t.running?.must_equal true
+  end
+
+  it "can measure a block of code from an instance" do
+    t = Hitimes::TimedMetric.new( 'measure a block' )
+    3.times { t.measure { sleep 0.05 } }
+    t.duration.must_be_close_to(0.15, 0.01)
+    t.count.must_equal 3
+  end
+
+  it "returns the value of the block when measuring" do
+    t = Hitimes::TimedMetric.new( 'measure a block' )
+    x = t.measure { sleep 0.05; 42 }
+    t.duration.must_be_close_to(0.05, 0.002)
+    x.must_equal 42
+  end
+
+  describe "#to_hash" do
+
+    it "has name value" do
+      h = @tm.to_hash
+      h['name'].must_equal "test-timed-metric"
+    end
+
+    it "has an empty hash for additional_data" do
+      h = @tm.to_hash
+      h['additional_data'].must_equal Hash.new
+      h['additional_data'].size.must_equal 0
+    end
+
+    it "has the right sum" do
+      10.times { |x| @tm.measure { sleep 0.01*x  } }
+      h = @tm.to_hash
+      h['sum'].must_be_close_to(0.45, 0.01)
+    end
+
+    fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]
+    fields.each do |f|
+      it "has a value for #{f}" do
+        @tm.measure { sleep 0.001 }
+        h = @tm.to_hash
+        h[f].wont_be_nil
+      end
+    end
+  end 
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/timed_value_metric_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe Hitimes::TimedValueMetric do
+  before( :each ) do
+    @tm = Hitimes::TimedValueMetric.new( 'test-timed-value-metric' )
+  end
+
+  it "knows if it is running or not" do
+    @tm.running?.must_equal false
+    @tm.start
+    @tm.running?.must_equal true
+    @tm.stop( 1 )
+    @tm.running?.must_equal false
+  end
+
+  it "#split returns the last duration and the timer is still running" do
+    @tm.start
+    d = @tm.split( 1 )
+    @tm.running?.must_equal true
+    d.must_be :>, 0
+    @tm.value_stats.count.must_equal 1
+    @tm.timed_stats.count.must_equal 1
+    @tm.duration.must_equal d
+  end
+
+  it "#stop returns false if called more than once in a row" do
+    @tm.start
+    @tm.stop( 1 ).must_be :>, 0
+    @tm.stop( 1 ).must_equal false
+  end
+
+  it "does not count a currently running interval as an interval in calculations" do
+    @tm.start
+    @tm.value_stats.count.must_equal 0
+    @tm.timed_stats.count.must_equal 0
+    @tm.split( 1 )
+    @tm.value_stats.count.must_equal 1
+    @tm.timed_stats.count.must_equal 1
+  end
+
+  it "#split called on a stopped timer does nothing" do
+    @tm.start
+    @tm.stop( 1 )
+    @tm.split( 1 ).must_equal false
+  end
+
+  it "calculates the mean of the durations" do
+    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop(x) }
+    @tm.timed_stats.mean.must_be_close_to(0.05, 0.01)
+    @tm.value_stats.mean.must_equal 1.00
+  end
+
+  it "calculates the rate of the counts " do
+    5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
+    @tm.rate.must_be_close_to(40.0, 1.0)
+  end
+
+
+  it "calculates the stddev of the durations" do
+    3.times { |x| @tm.start ; sleep(0.05 * x) ; @tm.stop(x) }
+    @tm.timed_stats.stddev.must_be_close_to(0.05, 0.001)
+    @tm.value_stats.stddev.must_equal 1.0
+  end
+
+  it "returns 0.0 for stddev if there is no data" do
+    @tm.timed_stats.stddev.must_equal 0.0
+    @tm.value_stats.stddev.must_equal 0.0
+  end
+
+  it "keeps track of the min value" do
+    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
+    @tm.timed_stats.min.must_be_close_to( 0.05, 0.003 )
+    @tm.value_stats.min.must_equal 0
+  end
+
+  it "keeps track of the max value" do
+    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
+    @tm.timed_stats.max.must_be_close_to( 0.05, 0.003 )
+    @tm.value_stats.max.must_equal 2
+  end
+
+  it "keeps track of the sum value" do
+    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
+    @tm.timed_stats.sum.must_be_close_to( 0.15, 0.01 )
+    @tm.value_stats.sum.must_equal 3
+  end
+  
+  it "keeps track of the sum of squares value" do
+    3.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
+    @tm.timed_stats.sumsq.must_be_close_to(0.0075, 0.0005)
+    @tm.value_stats.sumsq.must_equal 5
+  end
+
+  it "keeps track of the minimum start time of all the intervals" do
+    f1 = Time.now.gmtime.to_f * 1000000
+    5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
+    f2 = Time.now.gmtime.to_f * 1000000
+    @tm.sampling_start_time.must_be :>=, f1
+    @tm.sampling_start_time.must_be :<, f2
+    # distance from now to start time should be greater than the distance from
+    # the start to the min start_time
+    (f2 - @tm.sampling_start_time).must_be :>, ( @tm.sampling_start_time - f1 )
+  end
+
+  it "keeps track of the last stop time of all the intervals" do
+    f1 = Time.now.gmtime.to_f * 1_000_000
+    5.times { @tm.start ; sleep 0.05 ; @tm.stop( 1 ) }
+    sleep 0.05
+    f2 = Time.now.gmtime.to_f * 1_000_000
+    @tm.sampling_stop_time.must_be :>, f1
+    @tm.sampling_stop_time.must_be :<=, f2
+    # distance from now to max stop time time should be less than the distance
+    # from the start to the max stop time
+    (f2 - @tm.sampling_stop_time).must_be :<, ( @tm.sampling_stop_time - f1 )
+  end
+
+  it "can create an already running timer" do
+    t = Hitimes::TimedValueMetric.now( 'already-running' )
+    t.running?.must_equal true
+  end
+
+  it "can measure a block of code from an instance" do
+    t = Hitimes::TimedValueMetric.new( 'measure a block' )
+    3.times { t.measure( 1 ) { sleep 0.05 } }
+    t.duration.must_be_close_to(0.15, 0.004)
+    t.timed_stats.count.must_equal 3
+    t.value_stats.count.must_equal 3
+  end
+
+  it "returns the value of the block when measuring" do
+    t = Hitimes::TimedValueMetric.new( 'measure a block' )
+    x = t.measure( 42 ) { sleep 0.05; 42 }
+    t.duration.must_be_close_to(0.05, 0.002)
+    x.must_equal 42
+  end
+
+  describe "#to_hash" do
+
+    it "has name value" do
+      h = @tm.to_hash
+      h['name'].must_equal "test-timed-value-metric"
+    end
+
+    it "has an empty has for additional_data" do
+      h = @tm.to_hash
+      h['additional_data'].must_equal Hash.new
+      h['additional_data'].size.must_equal 0
+    end
+
+    it "has a rate" do
+      5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
+      h = @tm.to_hash
+      h['rate'].must_be_close_to(40.0, 1.0)
+    end
+
+    it "has a unit_count" do
+      5.times { |x| @tm.start ; sleep 0.05 ; @tm.stop( x ) }
+      h = @tm.to_hash
+      h['unit_count'].must_equal  10
+    end
+
+    fields = %w[ name additional_data sampling_start_time sampling_stop_time value_stats timed_stats rate unit_count ]
+    fields.each do |f|
+      it "has a value for #{f}" do
+        3.times { |x| @tm.measure(x) { sleep 0.001 } }
+        h = @tm.to_hash
+        h[f].wont_be_nil
+      end
+    end
+  end 
+end

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/value_metric_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Hitimes::ValueMetric do
+  before( :each ) do
+    @metric = Hitimes::ValueMetric.new( "testing" )
+    10.times { |x| @metric.measure( x ) }
+  end
+
+  it 'has a name' do
+    @metric.name.must_equal "testing"
+  end
+
+  it "has associated data from initialization" do
+    m = Hitimes::ValueMetric.new( "more-data", 'foo' => 'bar', 'this' => 'that' )
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
+    
+    m = Hitimes::ValueMetric.new( "more-data", { 'foo' => 'bar', 'this' => 'that' } )
+    m.additional_data['foo'].must_equal 'bar'
+    m.additional_data['this'].must_equal 'that'
+  end
+
+  it "calculates the mean of the measurements" do
+    @metric.mean.must_equal 4.5
+  end
+
+  it "calculates the stddev of the measurements" do
+    @metric.stddev.must_be :>, 0.0
+  end
+
+  it "returns 0.0 for stddev if there is no data" do
+    m = Hitimes::ValueMetric.new('0-data')
+    m.stddev.must_equal 0.0
+  end
+
+  it "keeps track of the sum of data" do
+    @metric.sum.must_equal 45.0
+  end
+
+  it "keeps track of the sum of squars of data" do
+    @metric.sumsq.must_equal 285.0
+  end
+
+  it "retuns 0.0 for mean if there is no data" do
+    Hitimes::ValueMetric.new('0-data').mean.must_equal 0.0
+  end
+
+  it "keeps track of the min value" do
+    @metric.min.must_equal 0
+  end
+
+  it "keeps track of the max value" do
+    @metric.max.must_equal 9
+  end
+
+  it "keeps track of the first start time of all the measurements" do
+    m = Hitimes::ValueMetric.new( "first-start-time" )
+    f1 = Time.now.gmtime.to_f * 1_000_000
+    10.times{ |x| m.measure( x ); sleep 0.1 }
+    f2 = Time.now.gmtime.to_f * 1_000_000
+    m.sampling_start_time.must_be :>=, f1
+    m.sampling_start_time.must_be :<, f2
+    # distance from now to start time should be greater than the distance from
+    # the start to the min start_time
+    (f2 - m.sampling_start_time).must_be :>, ( m.sampling_start_time - f1 )
+  end
+
+  it "keeps track of the last stop time of all the intervals" do
+    m = Hitimes::ValueMetric.new( "last-stop-time" )
+    f1 = Time.now.gmtime.to_f * 1_000_000
+    10.times {|x| m.measure( x ); sleep 0.1  }
+    f2 = Time.now.gmtime.to_f * 1_000_000
+    m.sampling_stop_time.must_be :>, f1
+    m.sampling_stop_time.must_be :<=, f2
+    # distance from now to max stop time time should be less than the distance
+    # from the start to the max stop time
+    (f2 - m.sampling_stop_time).must_be :<, ( m.sampling_stop_time - f1 )
+  end
+
+  describe "#to_hash" do
+
+    it "has name value" do
+      h = @metric.to_hash
+      h['name'].must_equal "testing"
+    end
+
+    it "has an empty has for additional_data" do
+      h = @metric.to_hash
+      h['additional_data'].must_equal Hash.new
+      h['additional_data'].size.must_equal 0
+    end
+
+    it "has the right sum" do
+      h = @metric.to_hash
+      h['sum'].must_equal 45
+    end
+
+    fields = ::Hitimes::Stats::STATS.dup + %w[ name additional_data sampling_start_time sampling_stop_time ]
+    fields = fields - [ 'rate' ]
+    fields.each do |f|
+      it "has a value for #{f}" do
+        h = @metric.to_hash
+        h[f].wont_be_nil
+      end
+    end
+  end
+end
+

data/.bundle/gems/ruby/2.2.0/gems/hitimes-1.2.2/spec/version_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe "Hitimes::Version" do
+  it "should be accessable as a constant" do
+    Hitimes::VERSION.must_match(/\d+\.\d+\.\d+/)
+  end
+end