0.0
No commit activity in last 3 years
No release in over 3 years
RSpec extension library for Cramp.
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
 Dependencies

Development

>= 0

Runtime

~> 1.0.0
~> 1.3
~> 2.6
 Project Readme

A set of rspec matchers and helpers that make it easier to write specs for cramp.

Quick start

> gem install rspec-cramp



require 'rspec/cramp'

# Decorate your spec with :cramp => true
describe HelloWorld, :cramp => true do

  # You need to define this method
  def app
    HelloWorld # Here goes your cramp application, action or http routes.
  end

  # Matching on status code.
  it "should respond to a GET request" do
    get("/").should respond_with :status => :ok         # Matches responses from 200 to 299.
    get("/").should respond_with :status => 200         # Matches only 200.
    get("/").should respond_with :status => "200"       # Same as above.
    get("/").should respond_with :status => /^2.*/      # Matches response codes starting with 2.
    get("/").should_not respond_with :status => :error  # Matches any HTTP error.
  end

  # Matching on response body.
  it "should respond with text starting with 'Hello'" do
    get("/").should respond_with :body => /^Hello.*/
  end
  it "should respond with 'Hello, world!'" do
    get("/").should respond_with :body => "Hello, world!"
  end

  # Matching on response headers.
  it "should respond with html" do
    get("/").should respond_with :headers => {"Content-Type" => "text/html"}
    get("/").should_not respond_with :headers => {"Content-Type" => "text/plain"}
    get("/").should_not respond_with :headers => {"Unexpected-Header" => /.*/}
  end

  # Matching using lambdas.
  it "should match my sophisticated custom matchers" do
    # Entire headers.
    status_check = lambda {|status| status.between?(200, 299)}
    body_check = lambda {|body| body =~ /.*el.*/}
    headers_check = lambda {|headers| true} # Any headers will do.
    get("/").should respond_with :status => status_check, :body => body_check, :headers => headers_check
    # Header value.
    get("/").should respond_with :headers => {"Content-Type" => lambda {|value| value == "text/html"}}
    get("/").should_not respond_with :headers => {"Content-Type" => lambda {|value| value == "text/plain"}}
  end

  # Supports POST/GET/PUT/DELETE and you don't have to use the matcher.
  it "should work without a matcher" do
    get "/"
    post "/"
    put "/"
    delete "/"
  end

  # Request params & custom headers.
  it "should accept my params" do
    post("/", :params => {:text => "whatever"}, :headers => {"Custom-Header" => "blah"})
  end
end

The matcher is fairly flexible, supports regular expressions and also works with multipart responses (more than one Cramp::Action.render), SSE and so on. I'll create more examples and docs but for the time being, pls. take a look at the code and examples.

DISCLAIMER: I haven't done any work with WebSockets yet so if there is anyone willing to add support for WebSockets, please tweet me

Project status

IMPORTANT: This is work in progress.

There are still some things I'll take care of soon (esp. better failure messages).

If you have any comments regarding the code as it is now (I know it's a bit messy), please feel free to tweet @MartinBilski

Contributors

Ivan Fomichev

Notes

  1. The previous version had a problem handling exceptions raised in on_start or on_finish or with on_start that called finish without rendering anything because the request helper methods always try to read one body chunk after a successful response (200-299).

    Actually, it wasn't a very big deal, the call would simply time out and raise Timeout::Error with a special error message hinting at the problem: execution expired (No render call in action?).

    The current version, comes with a monkey-patched Cramp::Action which now renders the exception info if it is raised in on_start or in on_finish.

    See this example spec to see error handling in action.

    I'm definitely open to suggestions, especially how this can be fixed without the cramp surgery. Is the original timeout-based solution better? Unfortunately, the matcher by default always loads one chunk of response body for a successful response.

  2. This work is based on Pratik Naik's code and writing specs in a similar fashion is still supported though I added a helper for loading the body and a response matcher and some accessors to make your life easier.

     describe MyCrampAction, :cramp => true do
     	def app
     		MyCrampAction
     	end
     	it "should respond to a GET request" do
     		get("/") do |response|
     			response.status.should == 200
     			response.headers.should have_key "Content-Type"
     			response.should be_matching :status => :ok
     			stop # This is important.
     		end
     	end
     	it "should match the body" do
     		get("/") do |response|
     			response.read_body do
     				response.body.should include "Hello, world!"  # MockResponse::body returns an Array.
     				response.should be_matching :body => "Hello, world!"
     				# Note: no call to stop here.
     			end
     		end
     	end
     end  
    

    In general, I recommend using the 'respond_with' matcher whenever possible; I think it makes the specs more readable because it hides some gory details (for good or bad). But they are useful when you're debugging your cramp application if the failure message doesn't include all the details you need.