One thing that has always been a pain with remote web services is testing. The HttpMock class makes it easy to test your Active Resource models by creating a set of mock responses to specific requests.
To test your Active Resource model, you simply call the ::respond_to method with an attached block. The block declares a set of URIs with expected input, and the output each request should return. The passed in block has any number of entries in the following generalized format:
mock.http_method(path, request_headers = {}, body = nil, status = 200, response_headers = {})
http_method
- The HTTP method to listen for. This can be
get
, post
, put
, delete
or head
.
path
- A string, starting with a "/", defining the URI that is
expected to be called.
request_headers
- Headers that are expected along with the
request. This argument uses a hash format, such as {
"Content-Type" => "application/xml" }
. This
mock will only trigger if your tests sends a request with identical
headers.
body
- The data to be returned. This should be a string of
Active Resource parseable content, such as XML.
status
- The HTTP response code, as an integer, to return with
the response.
response_headers
- Headers to be returned with the response.
Uses the same hash format as request_headers
listed above.
In order for a mock to deliver its content, the incoming request must match
by the http_method
, path
and
request_headers
. If no match is found an InvalidRequestError exception will be
raised showing you what request it could not find a response for and also
what requests and response pairs have been recorded so you can create a new
mock for that request.
def setup @matz = { :id => 1, :name => "Matz" }.to_xml(:root => "person") ActiveResource::HttpMock.respond_to do |mock| mock.post "/people.xml", {}, @matz, 201, "Location" => "/people/1.xml" mock.get "/people/1.xml", {}, @matz mock.put "/people/1.xml", {}, nil, 204 mock.delete "/people/1.xml", {}, nil, 200 end end def test_get_matz person = Person.find(1) assert_equal "Matz", person.name end
Returns an array of all request objects that have been sent to the mock. You can use this to check if your model actually sent an HTTP request.
def setup @matz = { :id => 1, :name => "Matz" }.to_xml(:root => "person") ActiveResource::HttpMock.respond_to do |mock| mock.get "/people/1.xml", {}, @matz end end def test_should_request_remote_service person = Person.find(1) # Call the remote service # This request object has the same HTTP method and path as declared by the mock expected_request = ActiveResource::Request.new(:get, "/people/1.xml") # Assert that the mock received, and responded to, the expected request from the model assert ActiveResource::HttpMock.requests.include?(expected_request) end
# File lib/active_resource/http_mock.rb, line 91 def requests @@requests ||= [] end
Deletes all logged requests and responses.
# File lib/active_resource/http_mock.rb, line 183 def reset! requests.clear responses.clear end
Accepts a block which declares a set of requests and responses for the HttpMock to respond to in the following format:
mock.http_method(path, request_headers = {}, body = nil, status = 200, response_headers = {})
@matz = { :id => 1, :name => "Matz" }.to_xml(:root => "person") ActiveResource::HttpMock.respond_to do |mock| mock.post "/people.xml", {}, @matz, 201, "Location" => "/people/1.xml" mock.get "/people/1.xml", {}, @matz mock.put "/people/1.xml", {}, nil, 204 mock.delete "/people/1.xml", {}, nil, 200 end
Alternatively, accepts a hash of {Request => Response}
pairs allowing you to generate these the following format:
ActiveResource::Request.new(method, path, body, request_headers) ActiveResource::Response.new(body, status, response_headers)
ActiveResource::Request.new(:#{method}, path, nil, request_headers)
@matz = { :id => 1, :name => "Matz" }.to_xml(:root => "person") create_matz = ActiveResource::Request.new(:post, '/people.xml', @matz, {}) created_response = ActiveResource::Response.new("", 201, {"Location" => "/people/1.xml"}) get_matz = ActiveResource::Request.new(:get, '/people/1.xml', nil) ok_response = ActiveResource::Response.new("", 200, {}) pairs = {create_matz => created_response, get_matz => ok_response} ActiveResource::HttpMock.respond_to(pairs)
Note, by default, every time you call respond_to
, any previous
request and response pairs stored in HttpMock
will be deleted giving you a clean slate to work on.
If you want to override this behaviour, pass in false
as the
last argument to respond_to
ActiveResource::HttpMock.respond_to do |mock| mock.send(:get, "/people/1", {}, "XML1") end ActiveResource::HttpMock.responses.length #=> 1 ActiveResource::HttpMock.respond_to(false) do |mock| mock.send(:get, "/people/2", {}, "XML2") end ActiveResource::HttpMock.responses.length #=> 2
This also works with passing in generated pairs of requests and responses, again, just pass in false as the last argument:
ActiveResource::HttpMock.respond_to do |mock| mock.send(:get, "/people/1", {}, "XML1") end ActiveResource::HttpMock.responses.length #=> 1 get_matz = ActiveResource::Request.new(:get, '/people/1.xml', nil) ok_response = ActiveResource::Response.new("", 200, {}) pairs = {get_matz => ok_response} ActiveResource::HttpMock.respond_to(pairs, false) ActiveResource::HttpMock.responses.length #=> 2
# File lib/active_resource/http_mock.rb, line 171 def respond_to(*args) #:yields: mock pairs = args.first || {} reset! if args.last.class != FalseClass responses.concat pairs.to_a if block_given? yield Responder.new(responses) else Responder.new(responses) end end
Returns the list of requests and their mocked responses. Look up a response for a request using responses.assoc(request).
# File lib/active_resource/http_mock.rb, line 97 def responses @@responses ||= [] end