@Chris Tierney: How do you invoke http://localhost:4000/foo so that MockServer#call method is given the right data? Sinatra gave me grief and ended up just using Rack::Test. Seems much simpler, exercieses the route and all I can see is that the MockServer call is never invoked – puzzled.

# my_code_that_should_make_post_request # to http://localhost:4000/foo
# request_received.should be_true

Tested informally on Ruby 1.9.1
I’ve only used it a little so far, so I’m unsure how much mileage I will get with this approach. Here’s the code:

#
require ‘rack’

#
## Bring up server in a new thread (do once?):
# @mock_server = MockServer.new(4000, 0.5)
#
#
## Pull down server:
# @mock_server.stop
#
#
## Expectations (rspec example):
# request_received = false
# @mock_server.attach do |env|
# request_received = true
# env['REQUEST_METHOD'].should == ‘POST’
# env['PATH_INFO'].should == ‘/foo’
# [ 200, { 'Content-Type' => 'text/plain', 'Content-Length' => '40' }, [ 'This gets returned from the HTTP request' ]]
# end
# request_received.should be_true
# my_code_that_should_make_post_request # to http://localhost:4000/foo
#
#
## After each test:
# @mock_server.detach
#
#

class MockServer
def initialize(port = 4000, pause = 1)
@block = nil
@parent_thread = Thread.current
@thread = Thread.new do
Rack::Handler::WEBrick.run(self, ort => port)
end

sleep pause # give the server time to fire up… YUK!
end

def stop
Thread.kill(@thread)
end

def attach(&block)
@block = block
end

def detach()
@block = nil
end

def call(env)
begin
raise “Specify a handler for the request using attach(block), the block should return a valid rack response and can test expectations” unless @block
@block.call(env)
rescue Exception => e
@parent_thread.raise e
[ 500, { 'Content-Type' => 'text/plain', 'Content-Length' => '13' }, [ 'Bad test code' ]]
end
end
end

require 'rubygems'
require 'rack'
require 'thin'

end

* Ability to specify an expectation as not being transient – i.e. not deleted after its response is served
* Run in a thread after instantiation (makes tests simpler to write)
* Facility to pass a lambda in as the expectation, to execute the value from the request against – allows you to do arbitrary matching of request elements against expectations

require ‘rubygems’
require ‘rack’
require ‘thin’

# Mock server for testing bad or heavyweight server responses; runs on localhost:4000 by default
#
# Example of use
#
# In setup method:
#
# @mock_server = MockServer.new # creating a new instance spawns a thread running the TCP server
# @mock_server.register( { ‘REQUEST_METHOD’ => ‘GET’ }, [ 200, { 'Content-Type' => 'text/plain', 'Content-Length' => '11' }, [ 'Hello World' ]])
# @mock_server.register( { ‘REQUEST_METHOD’ => ‘GET’ }, [ 200, { 'Content-Type' => 'text/plain', 'Content-Length' => '11' }, [ 'Hello Again' ]])
#
# After each test, to remove all expectations:
#
# @mock_server.clear
#
# In teardown method:
#
# @mock_server.stop

class MockServer

def initialize(options={})
host = options[:host] || ’127.0.0.1′
port = options[:port] || 4000
@expectations = []
@server = Thin::Server.new(host, port, self)
@thread = Thread.new { @server.start }
end

def stop
@server.stop!
Thread.kill(@thread)
end

# env should be a hash mapping elements of a Rack env to expected values (see examples above);
# note that an expected value can be a Proc which will be passed the value from the request
# and executed – if the Proc returns true on execution, the expectation is met
#
# For example, to check that the querystring contains the value ’1234′, env could be:
#
# { ‘QUERY_STRING’ => lambda { |qs| !((qs =~ /1234/).nil?) } }
#
# response should be a Rack-formatted response; i.e. [response_code, {'header' => 'value', ...}, response_body]
#
# options:
# :transient => false to prevent a response being removed after it has been served (default is true)
def register(env, response, options={})
transient = options[:transient]
transient = true if transient.nil?

@expectations < ‘text/plain’}, “Bad, bad, bad – couldn’t map request to expectation”]

@expectations.each_with_index do |expectation, index|
expectation_env, response, transient = expectation
matched = false

expectation_env.each do |env_key, value|
puts “Trying to match #{env_key} => #{value} to request”
matched = true

req_value = env[env_key]

if value.is_a? Proc
req_element_matches = value.call(req_value)
else
req_element_matches = (value == req_value)
end

unless req_element_matches
puts ” Value NOT matched: request value was #{env[env_key]} (needed #{value} to match)”
matched = false
break
end

end

if matched and transient
@expectations.delete_at(index)
break
end
end

response
end

end