rspec-performance 0.0.1

data/Rakefile

@@ -0,0 +1,27 @@
+require "rubygems"
+require "rake"
+require "rake/gempackagetask"
+require "spec/rake/spectask"
+
+load("rspec-performance.gemspec")
+
+task :default => :spec do
+end
+
+desc "Runs the rspec-performance ruby specs."
+Spec::Rake::SpecTask.new(:spec) do |t|
+  spec_options = File.readlines("spec/spec.opts").map {|line| line.chomp }
+
+  t.libs << 'lib'
+  t.libs << File.dirname(__FILE__)
+  t.spec_opts = spec_options
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Publish the gem via gem cutter"
+task :publish do
+  system "gem build rspec-performance.gemspec"
+  system "gem push rspec-performance-#{Spec::Performance::VERSION::STRING}.gem"
+end
+
+# Gem packaging tasks

data/lib/rspec-performance.rb

@@ -0,0 +1,4 @@
+require "spec/performance/version"
+require "spec/performance/client"
+require "spec/performance/configuration"
+require "spec/performance/example/performance_example_group"

data/lib/spec/performance/client/http_client.rb

@@ -0,0 +1,88 @@
+require "net/http"
+require "cgi"
+require "spec/performance/client/response"
+
+module Spec
+  module Performance
+    module Client
+      class HttpClient
+        attr_writer :recording, :cookies
+        attr_reader :base_uri, :cookies
+
+        def initialize(base_uri)
+          @base_uri = base_uri
+          @cookies = {}
+          @recording = true
+        end
+
+        def post(uri, params = {})
+          request = Net::HTTP::Post.new(uri.path, headers)
+          request.form_data = params
+          request.basic_auth uri.user, uri.password if uri.user
+          response = Net::HTTP.new(uri.host, uri.port).start do |http|
+            http.request(request)
+          end
+          capture(response) if recording?
+          create_http_client_response(response)
+        end
+
+        def get(uri, params = {})
+          if params && params.size > 0
+            query = params2query(params)
+            uri = URI.parse("#{uri}?#{query}")
+          end
+
+          http = Net::HTTP.start(uri.host, uri.port)
+          response = http.get(uri.request_uri, { "Cookie" => browser_cookies })
+          http.finish
+
+          create_http_client_response(response)
+        end
+
+        def recording?
+          @recording
+        end
+
+        private
+
+        def params2query(hash)
+          q = hash.inject([]) do |acc, (k, v)|
+            acc << CGI::escape(k.to_s) + "=" + CGI::escape(v.to_s)
+          end.join("&")
+        end
+
+        def capture(response)
+          if raw_cookies = response.get_fields("Set-Cookie")
+            cookie_jar = raw_cookies.inject({}) do |parsed_cookies, raw_cookie_string|
+              CGI::Cookie.parse(raw_cookie_string).each do |name, cookie|
+                parsed_cookies[name.to_sym] = cookie
+              end
+              parsed_cookies
+            end
+            @cookies.merge!(cookie_jar)
+          end
+        end
+
+        def headers
+          @cookies.values.inject({}) do |acc, cookie|
+            acc["Cookie"] = cookie.to_s
+            acc
+          end
+        end
+
+        def browser_cookies
+          cookies_to_send = @cookies.values.reject {|cookie| cookie.name == "path" || cookie.name == "domain" }
+          cookies_to_send.map do |cookie|
+            CGI::escape(cookie.name) + "=" + CGI::escape(cookie.value.first)
+          end.join("&")
+        end
+
+        def create_http_client_response(net_http_response)
+          attributes = { :code => net_http_response.code,
+                         :body => net_http_response.body  }
+          Response.new(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/spec/performance/client/response.rb

@@ -0,0 +1,25 @@
+
+module Spec
+  module Performance
+    module Client
+
+      class Response
+        attr_reader :code, :body, :cookies
+
+        def initialize(attributes = {})
+          @code = attributes[:code].to_i
+          @body = attributes[:body]
+        end
+
+        def success?
+          @code == 200
+        end
+
+        def redirect?
+          @code == 301 || @code == 302
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/performance/client.rb

@@ -0,0 +1 @@
+require "spec/performance/client/http_client"

data/lib/spec/performance/configuration.rb

@@ -0,0 +1,60 @@
+module Spec
+  module Performance
+    class Configuration
+      attr_reader :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      def concurrency=(value)
+        @options[:concurrency] = value
+      end
+
+      def iterations=(value)
+        @options[:iterations] = value
+      end
+
+      def iterations_per_second=(value)
+        @options[:iterations_per_second] = value
+      end
+
+      def maximum_iteration_time=(value)
+        @options[:maximum_iteration_time] = value
+      end
+
+      def performance_driver_class=(value)
+        @options[:performance_driver_class] = value
+      end
+
+      def performance_driver_base_uri=(value)
+        @options[:performance_driver_base_uri] = value
+      end
+
+      class << self
+        def instance
+          @@instance ||= new(default_options)
+        end
+
+        def configure(&block)
+          yield(instance)
+        end
+
+        def configured_options
+          instance.options
+        end
+
+        def default_options
+          {
+              :concurrency => 1,
+              :iterations => 20,
+              :iterations_per_second => nil,
+              :maximum_iteration_time => nil,
+              :performance_driver_class => Spec::Performance::Client::HttpClient,
+              :performance_driver_base_uri => "http://localhost/"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/spec/performance/example/performance_example_group.rb

@@ -0,0 +1,18 @@
+require "spec/performance/example/performance_example_group_methods"
+
+module Spec
+  module Performance
+    module Example
+      class PerformanceExampleGroup < Spec::Example::ExampleGroup
+        
+        attr_reader :performance_driver
+        before(:each) do
+          options = Spec::Performance::Configuration.configured_options
+          @performance_driver = options[:performance_driver_class].new(options[:performance_driver_base_uri])
+        end
+
+        extend PerformanceExampleGroupMethods
+      end
+    end
+  end
+end

data/lib/spec/performance/example/performance_example_group_methods.rb

@@ -0,0 +1,19 @@
+require "spec/performance/example/performance_execution_builder"
+
+module Spec
+  module Performance
+    module Example
+
+      module PerformanceExampleGroupMethods
+
+        def perform(description, options = {}, backtrace = nil, &implementation)
+          options = Spec::Performance::Configuration.configured_options.merge(options)
+
+          builder = PerformanceExecutionBuilder.new(options, &implementation)
+          example(description, options, backtrace, &builder.performance_proc)
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/performance/example/performance_execution_builder.rb

@@ -0,0 +1,71 @@
+module Spec
+  module Performance
+    module Example
+
+      class PerformanceExecutionBuilder
+        attr_reader :options
+
+        EXAMPLE_RUN_TIME_LABEL = "Performance Example Run Time"
+        ITERATION_RUN_TIME_LABEL = "Performance Iteration Run Time"
+
+        def initialize(options, &implementation)
+          @options = options
+          @impl = implementation
+        end
+
+        def performance_proc
+          iterations_per_slice = options[:iterations] / options[:concurrency]
+
+          # NOTE: Block execution only works if this is a local variable.
+          implementation = @impl
+
+          Proc.new do
+            extend(PerformanceHelpers)
+
+            example_run_time, maximum_iteration_time = _run_performance_loop(iterations_per_slice, &implementation)
+            _assert_iterations_per_second(example_run_time, iterations_per_slice, options[:iterations_per_second]) if options[:iterations_per_second]
+            _assert_maximum_iteration_time(maximum_iteration_time, options[:maximum_iteration_time]) if options[:maximum_iteration_time]
+          end
+        end
+
+        module PerformanceHelpers
+          private
+
+          def _run_performance_loop(iterations_per_slice, &implementation)
+            maximum_iteration_time = 0.0
+            example_run_time = _timed_operation EXAMPLE_RUN_TIME_LABEL do
+              (1..iterations_per_slice).each do |current_iteration|
+                iteration_run_time = _timed_operation ITERATION_RUN_TIME_LABEL do
+                  instance_eval(&implementation)
+                end
+                maximum_iteration_time = _calculate_average(current_iteration - 1, maximum_iteration_time, iteration_run_time)
+              end
+            end
+            [example_run_time, maximum_iteration_time]
+          end
+
+          def _assert_iterations_per_second(example_run_time, iterations_per_slice, acceptable_iterations_per_second)
+            estimated_iteration_run_time = example_run_time / iterations_per_slice
+            acceptable_estimated_iteration_run_time = 1.0 / acceptable_iterations_per_second
+            estimated_iteration_run_time.should <= acceptable_estimated_iteration_run_time
+          end
+
+          def _assert_maximum_iteration_time(maximum_iteration_time, acceptable_maximum_iteration_time)
+            maximum_iteration_time.should <= acceptable_maximum_iteration_time
+          end
+
+          def _calculate_average(sample_size, current_average, new_value)
+            (sample_size * current_average + new_value) / (sample_size + 1)
+          end
+
+          def _timed_operation(label, &block)
+            tic = Time.now.to_f
+            yield
+            Time.now.to_f - tic
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/spec/performance/version.rb

@@ -0,0 +1,11 @@
+module Spec
+  module Performance
+    module VERSION
+      MAJOR = 0
+      MINOR = 0
+      TINY  = 1
+
+      STRING = [MAJOR, MINOR, TINY].join(".")
+    end
+  end
+end

data/spec/helpers/integration_server.rb

@@ -0,0 +1,81 @@
+require "rubygems"
+require "thin"
+
+Thread.abort_on_exception = true
+
+class IntegrationServer
+  def initialize(port)
+    @server_thread = nil
+    @port = port
+    @running = false
+  end
+
+  def self.base_url
+    "http://localhost:#{@@port}/"
+  end
+
+  def self.instance
+    @@instance ||= new(@@port)
+  end
+
+  def self.start
+    instance.start
+  end
+
+  def self.kill
+    @@instance.kill
+  end
+
+  def self.port=(value)
+    @@port = value
+  end
+
+  def running?
+    @running
+  end
+
+  def start
+    return if running?
+
+    Thin::Logging.silent = true
+    @server_thread = Thread.new do
+      @server = Thin::Server.start('0.0.0.0', @port) do
+        map "/hello" do
+          run HelloAdapter.new
+        end
+
+        map "/cookie_echo" do
+          run CookieEchoAdapter.new
+        end
+      end
+    end
+    sleep 0.010 unless @server && @server.running?
+    @running = true
+  end
+
+  def kill
+    @server_thread.kill
+    @running = false
+  end
+
+  private
+
+  class HelloAdapter
+    def call(env)
+      body = ["<html><head><title>hi!</title></head><body>hello</body</html>"]
+      [ 200, { 'Content-Type' => 'text/html' }, body ]
+    end
+  end
+
+  class CookieEchoAdapter
+    def call(env)
+      cookies = env["rack.input"].read.split(/&/).inject([]) do |acc, pair|
+        name, value = pair.split(/=/).map {|p| CGI::unescape(p) }
+        acc << CGI::Cookie.new(name, value).to_s
+        acc
+      end
+      cookie_string = cookies.join("\n")
+      [200, { "Set-Cookie" => cookie_string }, ["echo"]]
+    end
+  end
+end

data/spec/lib/spec/performance/client/http_client_spec.rb

@@ -0,0 +1,112 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+
+describe Spec::Performance::Client::HttpClient do
+  attr_reader :client
+
+  before do
+    @client = Spec::Performance::Client::HttpClient.new("http://localhost")
+  end
+
+  describe "#initialize" do
+    it "initializes the cookie jar" do
+      client.cookies.should be_a(Hash)
+    end
+  end
+
+  describe "#post" do
+    attr_reader :uri, :params
+    before do
+      @uri = URI.join(IntegrationServer.base_url, "hello")
+      @params = { :foo => "bar", :baz => "quux" }
+    end
+
+    it "makes an HTTP post" do
+      mock.instance_of(Net::HTTP).request(anything) do |request|
+        request.should be_a(Net::HTTP::Post)
+        stub(Net::HTTPResponse.new(1.1, 200, nil)).body { "stubbed response body" }        
+      end
+      client.post(uri, params).should be_success
+    end
+
+    it "returns a response object" do
+      client.post(uri, params).should be_a(Spec::Performance::Client::Response)
+    end
+
+    describe "when the client is recording" do
+      before do
+        @uri = URI.join(IntegrationServer.base_url, "cookie_echo")
+        client.should be_recording
+      end
+
+      it "captures the cookie from the response" do
+        client.post(uri, params).should be_success
+        client.cookies[:foo].value.first.should == "bar"
+        client.cookies[:baz].value.first.should == "quux"
+      end
+    end
+
+    describe "when the client is not recording" do
+      before do
+        @uri = URI.join(IntegrationServer.base_url, "cookie_echo")
+        client.recording = false
+        client.should_not be_recording
+      end
+
+      it "does not capture cookies" do
+        client.post(uri, params).should be_success
+        client.cookies.should_not have_key(:foo)
+        client.cookies.should_not have_key(:baz)
+      end
+    end
+  end
+
+  describe "#get" do
+    attr_reader :uri, :params
+    before do
+      @params = { :monster_truck => "Truckasaurus", :us_president => "Grover Cleveland" }
+      @uri = URI.join(IntegrationServer.base_url, "hello")
+    end
+
+    it "sends an HTTP get request, sending the current cookies" do
+      expected_cookie  = CGI::Cookie.new("cookie-name", "cookie-value")
+      expected_headers = { "Cookie" => "cookie-name=cookie-value" }
+      client.cookies   = { "cookie-name".to_sym => expected_cookie }
+
+      mock_http = Object.new
+      mock(Net::HTTP).start("localhost", 8888) { mock_http }
+      mock(mock_http).get(anything, expected_headers) do |request_uri, headers|
+        request_uri.index("/hello?").should == 0
+        request_uri.should include("monster_truck=Truckasaurus")
+        request_uri.should include("us_president=Grover+Cleveland")
+        request_uri.should include("&")
+
+        stub(Net::HTTPResponse.new(1.1, 200, nil)).body { "stubbed response body" }
+      end
+      mock(mock_http).finish
+
+      response = client.get(uri, params)
+    end
+
+    it "returns a response object" do
+      response = client.get(uri, params)
+      response.should be_a(Spec::Performance::Client::Response)
+      response.should be_success
+    end
+
+    describe "when the client is recording" do
+      it "captures the cookie from the response" do
+      end
+    end
+
+    describe "when the client is not recording" do
+      it "does not capture" do
+      end
+    end
+  end
+
+  describe "#restore" do
+    it "resets after each run" do
+    end
+  end
+
+end

data/spec/lib/spec/performance/configuration_spec.rb

@@ -0,0 +1,39 @@
+require "#{File.dirname(__FILE__)}/../../../spec_helper"
+
+describe Spec::Performance::Configuration do
+  describe ".default_options" do
+    it "has correct configuration keys" do
+      options = Spec::Performance::Configuration.default_options
+      options.has_key?(:concurrency)
+      options.has_key?(:iterations)
+      options.has_key?(:iterations_per_second)
+      options.has_key?(:maximum_iteration_time)
+      options.has_key?(:performance_driver_class)
+      options.has_key?(:performance_driver_base_uri)
+    end
+  end
+
+  describe ".configure" do
+    it "sets a the options of Configuration singleton" do
+      Spec::Performance::Configuration.configure do |config|
+        config.concurrency = 10000
+        config.iterations_per_second = 20000
+      end
+
+      default_options = Spec::Performance::Configuration.default_options
+      configured_options = Spec::Performance::Configuration.instance.options
+      configured_options[:concurrency].should == 10000
+      configured_options[:iterations_per_second].should == 20000
+      configured_options[:maximum_iteration_time].should == default_options[:maximum_iteration_time]
+      configured_options[:iterations].should == default_options[:iterations]
+      configured_options[:performance_driver_class].should == default_options[:performance_driver_class]
+      configured_options[:performance_driver_base_uri].should == default_options[:performance_driver_base_uri]
+    end
+  end
+
+  describe ".configured_options" do
+    it "returns the configured options" do
+      Spec::Performance::Configuration.instance.options.should == Spec::Performance::Configuration.configured_options
+    end
+  end
+end

data/spec/lib/spec/performance/example/performance_example_group_methods_spec.rb

@@ -0,0 +1,98 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+
+describe Spec::Performance::Example::PerformanceExampleGroupMethods do
+  with_sandboxed_options do
+    attr_reader :example_group, :fake_run_options
+    before do
+      @example_group = Class.new(Spec::Performance::Example::PerformanceExampleGroup)
+      @fake_run_options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+      Spec::Performance::Runner::TestReporter.new(fake_run_options)
+    end
+
+    describe ".perform" do
+      context "configuration options" do
+        attr_reader :configured_options
+        before do
+          @configured_options = Spec::Performance::Configuration.configured_options
+        end
+
+        it "uses the global configuration options" do
+          mock(example_group).example(anything, configured_options, anything)
+          example_group.perform("do something") {}
+        end
+
+        describe "when options are passed on a per test level" do
+          attr_reader :spec_options, :expected_options
+          before do
+            @spec_options = { :concurrency => 100, :iterations => 200 }
+            @expected_options = configured_options.merge(spec_options)
+          end
+
+          it "overrides the global configuration options" do
+            mock(example_group).example(anything, expected_options, anything)
+            example_group.perform("do something", spec_options) {}
+          end
+        end
+      end
+
+      context "execution context" do
+        attr_reader :spec_options
+        before do
+          @spec_options = { :concurrency => 2, :iterations => 10, :iterations_per_second => nil, :maximum_iteration_time => nil }
+        end
+
+        it "executes the performance loop in the same context as the other examples" do
+          example_group.before do
+            @scope = self
+            @foo = "bar"
+          end
+
+          executed = false
+          example_group.perform "do performance loop", spec_options.merge(:iterations => 1, :concurrency => 1) do
+            (@scope == self).should be_true
+            @foo.should == "bar"
+            executed = true
+          end
+
+          example_group.run(fake_run_options)
+
+          @scope.should be_nil
+          @foo.should_not == "bar"
+          executed.should be_true
+        end
+      end
+
+      context "reporting" do
+        describe "when a performance test assertion fails" do
+          it "reports the failure" do
+            example_group.perform("do something") { 1.should == 0 }
+            example_group.run(fake_run_options)
+
+            fake_run_options.reporter.example_successes.should be_empty
+            fake_run_options.reporter.example_failures.should_not be_empty
+            error = fake_run_options.reporter.example_failures.first[:error]
+            error.should be_a(Spec::Expectations::ExpectationNotMetError)
+          end
+        end
+
+        describe "when a performance test passes" do
+          attr_reader :spec_options
+          before do
+            @spec_options = { :iterations => 1, :concurrency => 1, :maximum_iteration_time => 100000 }
+          end
+
+          it "reports the success" do
+            example_group.perform("reports the success", spec_options) { 1.should == 1 }
+            example_group.run(fake_run_options)
+            
+            fake_run_options.reporter.example_failures.should be_empty
+            example = fake_run_options.reporter.example_successes.first
+            example.description.should == "reports the success" 
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/spec/lib/spec/performance/example/performance_example_group_spec.rb

@@ -0,0 +1,48 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+
+describe Spec::Performance::Example::PerformanceExampleGroup do
+  with_sandboxed_options do
+
+    attr_reader :example_group, :fake_run_options, :spec_options
+    before do
+      @spec_options = { :iterations => 1, :concurrency => 1, :maximum_iteration_time => 1, :iterations_per_second => 1 }
+      @example_group = Class.new(Spec::Performance::Example::PerformanceExampleGroup)
+      @fake_run_options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+      Spec::Performance::Runner::TestReporter.new(fake_run_options)
+
+      fake_run_options.reporter.reset
+    end
+
+    it "sets a configured performance_driver attribute to an instance of the performance_driver_class before running each spec" do
+      driver_instance_in_before_block = nil
+      driver_instance_in_first_perform_block = nil
+      driver_instance_in_second_perform_block = nil
+
+      example_group.before do
+        driver_instance_in_before_block = performance_driver
+      end
+
+      example_group.perform "some description", spec_options do
+        driver_instance_in_first_perform_block = performance_driver
+      end
+
+      example_group.perform "some other description", spec_options do
+        driver_instance_in_second_perform_block = performance_driver
+      end
+
+      example_group.run(fake_run_options)
+      fake_run_options.reporter.example_failures.should be_empty
+
+      driver_instance_in_first_perform_block.should be_a(Spec::Performance::Client::HttpClient)
+      driver_instance_in_before_block.base_uri.should == "http://localhost/"
+
+      driver_instance_in_second_perform_block.should be_a(Spec::Performance::Client::HttpClient)
+      driver_instance_in_second_perform_block.base_uri.should == "http://localhost/"
+
+      driver_instance_in_first_perform_block.eql?(driver_instance_in_second_perform_block).should be_false
+
+      # the performance_driver from the before block retains the last value it was set to
+      driver_instance_in_before_block.eql?(driver_instance_in_second_perform_block).should be_true
+    end
+  end
+end

data/spec/lib/spec/performance/example/performance_execution_builder_spec.rb

@@ -0,0 +1,122 @@
+require "#{File.dirname(__FILE__)}/../../../../spec_helper"
+require "spec/performance/example/performance_execution_builder"
+
+describe Spec::Performance::Example::PerformanceExecutionBuilder do
+  attr_reader :spec_options
+  with_sandboxed_options do
+
+    describe ".performance_proc" do
+      context "performance loop" do
+        before do
+          @spec_options = { :concurrency => 2, :iterations => 10, :iterations_per_second => nil, :maximum_iteration_time => nil }
+        end
+
+        it "runs the performance loop N times where N is equal to iterations divided by concurrency" do
+          call_count = 0
+          expected_call_count = spec_options[:iterations] / spec_options[:concurrency]
+
+          builder = Spec::Performance::Example::PerformanceExecutionBuilder.new(spec_options) { call_count += 1 }
+          builder.performance_proc.call
+
+          call_count.should == expected_call_count
+        end
+
+        it "extends the ExampleGroup prior to test execution" do
+          builder = Spec::Performance::Example::PerformanceExecutionBuilder.new(spec_options) {}
+          mock(Spec::Performance::Example::PerformanceExecutionBuilder::PerformanceHelpers).extended(builder) {}
+          builder.performance_proc.call
+        end
+      end
+
+      context "extended tests" do
+        describe "when the spec should fail" do
+          attr_reader :builder
+
+          before do
+            @spec_options = { :concurrency => 1, :iterations => 2, :iterations_per_second => nil, :maximum_iteration_time => nil }
+          end
+
+          describe "when the iterations_per_second configuration option is set" do
+            before do
+              spec_options.merge!({ :iterations_per_second => 3 })
+              @builder = Spec::Performance::Example::PerformanceExecutionBuilder.new(spec_options)
+            end
+
+            it "fails when it does not match on iterations per second" do
+              stub(builder)._timed_operation(Spec::Performance::Example::PerformanceExecutionBuilder::EXAMPLE_RUN_TIME_LABEL) { 1.0 }
+
+              lambda do
+                builder.performance_proc.call
+              end.should raise_error(Spec::Expectations::ExpectationNotMetError)
+            end
+          end
+
+          describe "when the maximum_iteration_time configuration option is set" do
+            before do
+              spec_options.merge!({ :iterations => 5, :maximum_iteration_time => 0.100 })
+              @builder = Spec::Performance::Example::PerformanceExecutionBuilder.new(spec_options)
+            end
+
+            def create_stub_impl
+              lambda do |args, block|
+                label = Spec::VERSION::MAJOR == 1 && Spec::VERSION::MINOR > 2 ? args.first : args
+                return 0.2 if label == Spec::Performance::Example::PerformanceExecutionBuilder::ITERATION_RUN_TIME_LABEL
+                block.call
+                1.0
+              end
+            end
+
+            it "fails when the maximum_iteration_time falls below the configured value" do
+              stub(builder)._timed_operation(anything, &create_stub_impl)
+
+              lambda do
+                builder.performance_proc.call
+              end.should raise_error(Spec::Expectations::ExpectationNotMetError)
+            end
+          end
+        end
+      end
+    end
+
+    describe Spec::Performance::Example::PerformanceExecutionBuilder::PerformanceHelpers do
+      attr_reader :helper_instance
+      before do
+        @helper_instance = Class.new do
+          include Spec::Performance::Example::PerformanceExecutionBuilder::PerformanceHelpers
+        end.new
+      end
+
+      describe ".calculate_average" do
+        attr_reader :sample, :expected_average, :current_average
+        before do
+          @sample = [3, 3, 5, 7]
+          @expected_average = (sample.sum + 7) / (sample.size + 1)
+          expected_average.should == 5
+
+          @current_average = sample.sum / sample.size
+        end
+
+        it "calculates averages correctly" do
+          helper_instance.send(:_calculate_average, sample.size, current_average, 7).should == expected_average
+        end
+      end
+
+      describe ".timed_operation" do
+        before do
+          called = 0
+          stub(Time).now do
+            return_value = called > 0 ? 1 : 0
+            called += 1
+            return_value
+          end
+        end
+
+        it "returns the elapsed time of execution for a block" do
+          elapsed_time = helper_instance.send(:_timed_operation, "foo") {}
+          elapsed_time.should be_a(Float)
+          elapsed_time.should == 1.0
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,69 @@
+begin
+  require "spec"
+rescue LoadError
+  require "rubygems" unless ENV["NO_RUBYGEMS"]
+  gem "rspec"
+  require "spec"
+end
+
+$:.unshift(File.dirname(__FILE__) + "/../lib")
+dir = File.dirname(__FILE__)
+
+require "rspec-performance"
+require "#{dir}/helpers/integration_server"
+
+IntegrationServer.port = 8888
+IntegrationServer.start
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+module Spec::Performance::Runner
+  class TestReporter < Spec::Runner::Reporter
+    attr_reader :example_failures, :example_successes  
+
+    def initialize(options)
+      super(options)
+      reset
+    end
+
+    def example_failed(example, error)
+      @example_failures << { :example => example, :error => error }
+    end
+
+    def example_passed(example)
+      @example_successes << example
+    end
+
+    def reset
+      @example_failures = []
+      @example_successes = []
+    end
+  end
+end
+
+def with_sandboxed_options
+  attr_reader :options
+
+  before(:each) do
+    @original_rspec_options = ::Spec::Runner.options
+    ::Spec::Runner.use(@options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new))
+  end
+
+  after(:each) do
+    ::Spec::Runner.use(@original_rspec_options)
+  end
+
+  yield
+end
+
+class Array
+  def sum(&block)
+    inject(0.0) do |acc, x|
+      acc += block_given? ? yield(x) : x
+      acc
+    end
+  end
+end
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: rspec-performance
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Bob Remeika
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-01 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: rspec-performance adds a couple of utility methods for unit testing performance
+email: bob@grockit.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rspec-performance.rb
+- lib/spec/performance/client/http_client.rb
+- lib/spec/performance/client/response.rb
+- lib/spec/performance/client.rb
+- lib/spec/performance/configuration.rb
+- lib/spec/performance/example/performance_example_group.rb
+- lib/spec/performance/example/performance_example_group_methods.rb
+- lib/spec/performance/example/performance_execution_builder.rb
+- lib/spec/performance/version.rb
+- spec/helpers/integration_server.rb
+- spec/lib/spec/performance/client/http_client_spec.rb
+- spec/lib/spec/performance/configuration_spec.rb
+- spec/lib/spec/performance/example/performance_example_group_methods_spec.rb
+- spec/lib/spec/performance/example/performance_example_group_spec.rb
+- spec/lib/spec/performance/example/performance_execution_builder_spec.rb
+- spec/spec_helper.rb
+- Rakefile
+- README
+has_rdoc: true
+homepage: http://grockit.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- rspec-1.2.6
+rubyforge_project: rspec-performance
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby based make-like utility.
+test_files: []
+