harper 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.log

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm_install_on_use_flag=1
+rvm --create use ruby-1.8.7-p330@harper

data/Gemfile

@@ -0,0 +1,20 @@
+source "http://rubygems.org"
+
+gemspec
+
+# source :gemcutter
+
+# gem "rake", "0.8.7"
+# gem "sinatra"
+# gem "httparty"
+# gem "json", "~> 1.4.6"
+
+# group :test do
+#   gem "rack-test"
+#   gem "sham_rack"
+#   gem "rspec"
+#   gem "machinist"
+#   gem "faker"  
+#   gem "cucumber", ">= 0.10"
+#   gem "cucumber-sinatra"
+# end

data/Gemfile.lock

@@ -0,0 +1,62 @@
+PATH
+  remote: .
+  specs:
+    harper (0.0.1)
+      httparty
+      json (>= 1.4.6)
+      sinatra (>= 1.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    crack (0.1.8)
+    cucumber (0.10.3)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (>= 2.3.8)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.5)
+    cucumber-sinatra (0.3.1)
+      templater (>= 1.0.0)
+    diff-lcs (1.1.2)
+    extlib (0.9.15)
+    gherkin (2.3.9)
+      json (>= 1.4.6)
+    highline (1.6.2)
+    httparty (0.7.7)
+      crack (= 0.1.8)
+    json (1.4.6)
+    rack (1.3.0)
+    rack-test (0.6.0)
+      rack (>= 1.0)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.3)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    sham_rack (1.3.3)
+      rack
+    sinatra (1.2.6)
+      rack (~> 1.1)
+      tilt (>= 1.2.2, < 2.0)
+    templater (1.0.0)
+      diff-lcs (>= 1.1.2)
+      extlib (>= 0.9.5)
+      highline (>= 1.4.0)
+    term-ansicolor (1.0.5)
+    tilt (1.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cucumber (>= 0.10)
+  cucumber-sinatra
+  harper!
+  rack-test
+  rspec
+  sham_rack

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rspec/core/rake_task'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'bundler'
+
+namespace :gem do
+  Bundler::GemHelper.install_tasks
+end
+
+namespace :test do
+  RSpec::Core::RakeTask.new(:rspec) do |t|
+    t.rspec_opts = "--color"
+  end
+
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.cucumber_opts = "features --format pretty"
+  end
+end
+
+desc "Run all tests"
+task :test => ['test:rspec', 'test:features']

data/bin/harper

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "harper"
+
+port = ARGV.shift || 4567
+
+Rack::Server.start :app => Harper, :Port => port

data/features/mock_http_rpc_service.feature

@@ -0,0 +1,67 @@
+Feature: Mock an HTTP RPC web service
+  As a developer who cares about feedback cycles
+  I want to be able to easily mock service endpoints
+  So that I can fluently describe my test scenarios
+
+  Scenario: Submit a simple service request to mock
+    Given the following response mock, known as "original":
+      """
+      {
+        "url": "/service",
+        "method": "GET",
+        "content-type": "text/plain",
+        "body": "fake body"
+      }
+      """
+    When  the application POSTs the mock "original" to "/h/mocks"
+    Then  the response code should be "201"
+    And   the "original" mock is available at the URL in the "Location" header
+    When  the application issues a "GET" request for "/service"
+    Then  the response code should be "200"
+    And   the response "content-type" header should be "text/plain"
+    And   the response body should be:
+      """
+      fake body
+      """
+    When the application removes the mock "original"
+    And  the application issues a "GET" request for "/service"
+    Then the response code should be "503"
+
+  Scenario Outline: All HTTP methods can be mocked
+    Given a defined response mock with a "method" of "<METHOD>"
+    When the application issues a "<METHOD>" request to the mock
+    Then the response code should be "200"
+  Examples:
+    | METHOD |
+    | GET    |
+    | POST   |
+    | DELETE |
+    | PUT    |
+
+  Scenario Outline: HTTP status codes can be mocked
+    Given a defined response mock with a "status" of "<STATUS>"
+    When  the application issues a "GET" request to the mock
+    Then  the response code should be "<STATUS>"
+  Examples:
+    | STATUS |
+    |    200 |
+    |    201 |
+    |    206 |
+    |    301 |
+    |    304 |
+    |    401 |
+    |    403 |
+    |    404 |
+    |    500 |
+    |    503 |
+    
+  Scenario Outline: Responses from the server can be delayed
+    Given a defined response mock with a "delay" of "<MILLISECONDS>"
+    When  the application issues a "GET" request to the mock
+    Then  the response time should be at least "<MILLISECONDS>"
+  Examples:
+    | MILLISECONDS |
+    |            0 |
+    |           10 |
+    |          100 |
+    |         1000 |

data/features/step_definitions/http_steps.rb

@@ -0,0 +1,34 @@
+When /^the application issues an? "([A-Z]+)" request for "([^"]*)"$/ do |method, url|
+  case method
+  when "GET"
+    get :from => url
+  when "POST"
+    post :to => url
+  when "DELETE"
+    delete :at => url
+  when "PUT"
+    put :to => url
+  else
+    method.should == "unsupported HTTP method"
+  end
+end
+
+When /^the application issues an? "([A-Z]+)" request to the mock$/ do |method|
+  When %{the application issues a "#{method}" request for "/service"}
+end
+
+Then /^the response code should be "(\d+)"$/ do |expected|
+  response.code.should == expected.to_i
+end
+
+Then /^the response "([^"]*)" header should be "([^"]*)"$/ do |header, expected|
+  response.headers[header].should match(expected)
+end
+
+Then /^the response body should be:$/ do |expected|
+  response.body.should == expected
+end
+
+Then /^the response time should be at least "(\d*)"$/ do |min_time|
+  response.time.should >= min_time.to_i
+end

data/features/step_definitions/mock_definition_steps.rb

@@ -0,0 +1,26 @@
+Given /^the following response mock, known as "([^"]*)":$/ do |name, mock|
+  known_mock name, :body => mock
+end
+
+Given /^a defined response mock with a "([^"]*)" of "([^"]*)"$/ do |field, value|
+  known_mock "defined", :body => { :url => "/service",
+    :method => "GET",
+    'content-type' => "text/plain",
+    :body => "fake body" }.merge(field.to_sym => value).to_json
+  define_mock "defined"
+end
+
+When %r{^the application POSTs the mock "([^"]*)" to "/h/mocks"$} do |name|
+  define_mock name
+end
+
+When /^the application removes the mock "([^"]*)"$/ do |name|
+  remove_mock name
+end
+
+Then /^the "([^"]*)" mock is available at the URL in the "([^"]*)" header$/ do |name, header|
+  id_url = response.headers[header]
+  known_mock name, :url => id_url
+  get :from => id_url
+  response.code.should == 200
+end

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,219 @@
+# Taken from the cucumber-rails project.
+# IMPORTANT: This file is generated by cucumber-sinatra - edit at your own peril.
+# It is recommended to regenerate this file in the future when you upgrade to a
+# newer version of cucumber-sinatra. Consider adding your own code to a new file
+# instead of editing this one. Cucumber will automatically load all features/**/*.rb
+# files.
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(locator) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^\"]*)"(?: within "([^\"]*)")?$/ do |button, selector|
+  with_scope(selector) do
+    click_button(button)
+  end
+end
+
+When /^(?:|I )follow "([^\"]*)"(?: within "([^\"]*)")?$/ do |link, selector|
+  with_scope(selector) do
+    click_link(link)
+  end
+end
+
+When /^(?:|I )fill in "([^\"]*)" with "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, value, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+end
+
+When /^(?:|I )fill in "([^\"]*)" for "([^\"]*)"(?: within "([^\"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    fill_in(field, :with => value)
+  end
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following(?: within "([^\"]*)")?:$/ do |selector, fields|
+  with_scope(selector) do
+    fields.rows_hash.each do |name, value|
+      When %{I fill in "#{name}" with "#{value}"}
+    end
+  end
+end
+
+When /^(?:|I )select "([^\"]*)" from "([^\"]*)"(?: within "([^\"]*)")?$/ do |value, field, selector|
+  with_scope(selector) do
+    select(value, :from => field)
+  end
+end
+
+When /^(?:|I )check "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    check(field)
+  end
+end
+
+When /^(?:|I )uncheck "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    uncheck(field)
+  end
+end
+
+When /^(?:|I )choose "([^\"]*)"(?: within "([^\"]*)")?$/ do |field, selector|
+  with_scope(selector) do
+    choose(field)
+  end
+end
+
+When /^(?:|I )attach the file "([^\"]*)" to "([^\"]*)"(?: within "([^\"]*)")?$/ do |path, field, selector|
+  with_scope(selector) do
+    attach_file(field, path)
+  end
+end
+
+Then /^(?:|I )should see JSON:$/ do |expected_json|
+  require 'json'
+  expected = JSON.pretty_generate(JSON.parse(expected_json))
+  actual   = JSON.pretty_generate(JSON.parse(response.body))
+  expected.should == actual
+end
+
+Then /^(?:|I )should see "([^\"]*)"(?: within "([^\"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_content(text)
+    else
+      assert page.has_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/(?: within "([^\"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_xpath('//*', :text => regexp)
+    else
+      assert page.has_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^(?:|I )should not see "([^\"]*)"(?: within "([^\"]*)")?$/ do |text, selector|
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_content(text)
+    else
+      assert page.has_no_content?(text)
+    end
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/(?: within "([^\"]*)")?$/ do |regexp, selector|
+  regexp = Regexp.new(regexp)
+  with_scope(selector) do
+    if page.respond_to? :should
+      page.should have_no_xpath('//*', :text => regexp)
+    else
+      assert page.has_no_xpath?('//*', :text => regexp)
+    end
+  end
+end
+
+Then /^the "([^\"]*)" field(?: within "([^\"]*)")? should contain "([^\"]*)"$/ do |field, selector, value|
+  with_scope(selector) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should
+      field_value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^\"]*)" field(?: within "([^\"]*)")? should not contain "([^\"]*)"$/ do |field, selector, value|
+  with_scope(selector) do
+    field = find_field(field)
+    field_value = (field.tag_name == 'textarea') ? field.text : field.value
+    if field_value.respond_to? :should_not
+      field_value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field_value)
+    end
+  end
+end
+
+Then /^the "([^\"]*)" checkbox(?: within "([^\"]*)")? should be checked$/ do |label, selector|
+  with_scope(selector) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should == 'checked'
+    else
+      assert_equal 'checked', field_checked
+    end
+  end
+end
+
+Then /^the "([^\"]*)" checkbox(?: within "([^\"]*)")? should not be checked$/ do |label, selector|
+  with_scope(selector) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should_not
+      field_checked.should_not == 'checked'
+    else
+      assert_not_equal 'checked', field_checked
+    end
+  end
+end
+
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')}
+
+  if actual_params.respond_to? :should
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end

data/features/support/client_application.rb

@@ -0,0 +1,55 @@
+require 'httparty'
+require 'json'
+require 'benchmark'
+
+module HTTParty
+  class Response
+    attr_accessor :time
+  end
+end
+
+class ClientApplication
+  include HTTParty
+
+  base_uri 'example.com'
+
+  attr_reader :response
+
+  def initialize
+    @known_mocks = Hash.new { |h, k| h[k] = {} }
+  end
+
+  def known_mock(name, description = {})
+    @known_mocks[name].merge!(description)
+  end
+
+  def define_mock(name)
+    @response = self.class.post "/h/mocks", :body => @known_mocks[name][:body]
+  end
+
+  def remove_mock(name)
+    @response = self.class.delete @known_mocks[name][:url]
+  end
+
+  def get(options)
+    timed { @response = self.class.get options[:from] }
+  end
+
+  def post(options)
+    timed { @response = self.class.post options[:to] }
+  end
+
+  def delete(options)
+    timed { @response = self.class.delete options[:at] }
+  end
+
+  def put(options)
+    timed { @response = self.class.put options[:to] }
+  end
+
+  def timed
+    val = nil
+    timed = time { val = yield }
+    val.time = timed
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,25 @@
+# Generated by cucumber-sinatra. (Wed May 25 23:29:21 -0700 2011)
+
+ENV['RACK_ENV'] = 'test'
+
+require File.join(File.dirname(__FILE__), '..', '..', 'lib/harper.rb')
+require File.join(File.dirname(__FILE__), 'client_application')
+
+require 'sham_rack'
+require 'rspec'
+
+require File.join(File.dirname(__FILE__), '..', '..', 'spec/spec_helper')
+
+class HarperWorld
+  include RSpec::Expectations
+  include RSpec::Matchers
+end
+
+World do
+  HarperWorld.new
+  ClientApplication.new
+end
+
+ShamRack.at("example.com").rackup do
+  run Harper.new
+end

data/features/support/paths.rb

@@ -0,0 +1,29 @@
+# Taken from the cucumber-rails project.
+
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in web_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+
+    when /the home\s?page/
+      '/'
+
+    # Add more mappings here.
+    # Here is an example that pulls values out of the Regexp:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(NavigationHelpers)

data/harper.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "harper"
+
+Gem::Specification.new do |s|
+  s.name        = "harper"
+  s.version     = Harper::Version
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Giles Alexander"]
+  s.email       = ["giles.alexander@gmail.com"]
+  s.homepage    = "http://github.com/gga/harper"
+  s.summary     = %q{Dead simple mocking for HTTP services}
+  s.description = %q{Dead simple mocking for HTTP services, a Sinatra app}
+
+  s.rubyforge_project = "harper"
+
+  s.required_rubygems_version = ">= 1.3.6"
+
+  s.add_dependency "sinatra", ">= 1.0.0"
+  s.add_dependency "httparty"
+  s.add_dependency "json", ">= 1.4.6"
+
+  s.add_development_dependency "rack-test"
+  s.add_development_dependency "sham_rack"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "cucumber", ">= 0.10"
+  s.add_development_dependency "cucumber-sinatra"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/harper.rb

@@ -0,0 +1,81 @@
+require 'base64'
+require 'sinatra/base'
+require 'logger'
+require 'json'
+
+class Harper < Sinatra::Base
+
+  Version = "0.0.2"
+
+  @@mocks = {}
+
+  enable :logging
+
+  configure do
+    LOGGER = Logger.new("sinatra.log")
+  end
+
+  helpers do
+    def logger
+      LOGGER
+    end
+
+    def mock_id(url)
+      [url].pack('m').tr("+/=", "-_.").gsub("\n", '')
+    end
+  end
+
+  post '/h/mocks' do
+    mock = JSON(request.body.read)
+
+    mock['url'] = mock['url'][1..-1] if mock['url'] =~ /^\//
+
+    mock['id'] = mock_id(mock['url'])
+    mock['method'].upcase!
+    mock['delay'] = mock['delay'].to_f / 1000.0
+    @@mocks[mock['id']] = mock
+
+    logger.info("Created mock for endpoint: '#{mock['url']}'")
+    
+    headers['location'] = "/h/mocks/#{mock['id']}"
+    status "201"
+  end
+
+  delete '/h/mocks' do
+    @@mocks = {}
+  end
+
+  get '/h/mocks/:mock_id' do |mock_name|
+    content_type :json
+    status "200"
+    @@mocks[mock_name].to_json
+  end
+
+  delete '/h/mocks/:mock_id' do |mock_name|
+    @@mocks[mock_name] = nil
+
+    status "200"
+  end
+
+  [:get, :post, :put, :delete].each do |method|
+    self.send(method, '*') do
+      mock_id = mock_id(request.path[1..-1])
+
+      logger.debug("#{request.request_method} request for a mock: '#{request.path}'")
+
+      mock = @@mocks[mock_id]
+      if mock && request.request_method == mock['method']
+        content_type mock['content-type']
+        status mock['status'] || "200"
+        sleep mock['delay']
+        
+        logger.info("Serving mocked body for endpoint: '#{mock['url']}'")
+
+        mock['body']
+      else
+        status "503"
+      end
+    end
+  end
+
+end

data/spec/harper_spec.rb

@@ -0,0 +1,151 @@
+require 'spec/spec_helper'
+require 'harper'
+
+describe Harper do
+  include Rack::Test::Methods
+
+  supported_verbs = ["GET", "POST", "PUT", "DELETE"]
+
+  let(:app) { Harper.new }
+
+  let(:method) { "GET" }
+  let(:url) { "/service" }
+  let(:status_code) { 200 }
+  let(:content_type) { "text/plain" }
+  let(:body) { "fake body" }
+  let(:delay) { 0 }
+  
+  let(:mock_def) do
+    { :method => method,
+      :url => url,
+      :delay => delay,
+      :'content-type' => content_type,
+      :body => body }.to_json
+  end
+
+  it "should allow all mocks to be deleted" do
+    post '/h/mocks', mock_def
+
+    delete '/h/mocks'
+    last_response.should be_ok
+    get url
+    last_response.status.should == 503
+  end
+
+  describe "mock methods are case insensitive:" do
+    supported_verbs.each do |http_verb|
+      [lambda { |v| v.upcase },
+       lambda { |v| v.downcase },
+       lambda { |v| v[0..0] + v[1..-1].downcase}].each do |fn|
+          cased_verb = fn.call(http_verb)
+          context cased_verb do
+            let(:method) { cased_verb }
+
+            before(:each) do
+              post '/h/mocks', mock_def
+              @created_mock = last_response.headers['location']
+            end
+
+            after(:each) do
+              delete @created_mock
+            end
+
+            it "is a valid method" do
+              self.send(cased_verb.downcase.to_sym, url)
+              last_response.should be_ok
+            end
+          end
+      end
+    end
+  end
+
+  supported_verbs.each do |http_verb|
+    context "#{http_verb} mock" do
+      let(:method) { http_verb }
+
+      before(:each) do
+        post '/h/mocks', mock_def
+      end
+      
+      it "should respond with a 201 created" do
+        last_response.status.should == 201
+      end
+      
+      it "should point to a newly created mock resource" do
+        last_response.headers['Location'].should match(%r{/h/mocks/})
+      end
+
+      context "long service urls" do
+        let(:url) { "http://www.averylong.com/url/thathas/multiple/slashes/and/thelike/" }
+        it "should be queryable" do
+          get last_response.headers['Location']
+          last_response.status.should == 200
+        end
+      end
+
+      context "is a mock" do
+        before(:each) do
+          self.send(method.downcase.to_sym, url)
+        end
+
+        it "has a mocked status code" do
+          last_response.status.should == status_code
+        end
+        it "has a mocked content-type" do
+          last_response.headers['Content-Type'].should match(content_type)
+        end
+        it "has a mocked body" do
+          last_response.body.should == body
+        end
+        it "should not support unmocked HTTP methods" do
+          (supported_verbs - [method]).each do |non_method|
+            self.send(non_method.downcase.to_sym, url)
+            last_response.status.should == 503
+          end
+        end
+      end
+
+      it "should allow the mock resource to be deleted" do
+        delete last_response.headers['Location']
+        last_response.should be_ok
+        self.send(method.downcase.to_sym, url)
+        last_response.status.should == 503
+      end
+    end
+  end
+
+  context "delayed mocks" do
+
+    before(:each) do
+      post '/h/mocks', mock_def
+      @created_mock = last_response.headers['location']
+    end
+
+    after(:each) do
+      delete @created_mock
+    end
+
+    context "short delay" do
+      let(:delay) { 100 }
+
+      it "should take at least the specified delay to provide a response" do
+        time { get url }.should >= delay
+      end
+    end
+    context "long delay" do
+      let(:delay) { 1000 }
+
+      it "should take at least the specified delay to provide a response" do
+        time { get url }.should >= delay
+      end
+    end
+    context "no delay specified" do
+      let(:delay) { nil }
+
+      it "should take close to 0 delay in providing a response" do
+        time { get url }.should <= 1.0
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rack/test'
+require 'sinatra'
+require 'rspec/mocks/standalone'
+
+$: << File.dirname(__FILE__) + "/.."
+
+def time
+  start = Time.now
+  yield
+  (Time.now - start) * 1000.0
+end

metadata

@@ -0,0 +1,210 @@
+--- !ruby/object:Gem::Specification 
+name: harper
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Giles Alexander
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sham_rack
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 10
+        version: "0.10"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: cucumber-sinatra
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
+description: Dead simple mocking for HTTP services, a Sinatra app
+email: 
+- giles.alexander@gmail.com
+executables: 
+- harper
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- bin/harper
+- features/mock_http_rpc_service.feature
+- features/step_definitions/http_steps.rb
+- features/step_definitions/mock_definition_steps.rb
+- features/step_definitions/web_steps.rb
+- features/support/client_application.rb
+- features/support/env.rb
+- features/support/paths.rb
+- harper.gemspec
+- lib/harper.rb
+- spec/harper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/gga/harper
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: harper
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Dead simple mocking for HTTP services
+test_files: 
+- features/mock_http_rpc_service.feature
+- features/step_definitions/http_steps.rb
+- features/step_definitions/mock_definition_steps.rb
+- features/step_definitions/web_steps.rb
+- features/support/client_application.rb
+- features/support/env.rb
+- features/support/paths.rb
+- spec/harper_spec.rb
+- spec/spec_helper.rb