assert-response 0.0.3 → 1.0.0

data/README.md

@@ -0,0 +1,131 @@
+assert-response: sugar around Rack::Test
+=================================================================================================
+
+When it comes to **Rack::Test** there are two things that I don't like:
+
+* If your rack app raises an error, it is not exposed as an error but hidden in last_response.errors
+* Most of the time a status 404 should be considered as an error - the only exeption being that we expect a 404 status
+* It's annoying to test for content-types
+
+**assert-response** is there to address these issues:
+
+* an error that occurs in your rack app will be raised (with original backtrace)
+* you may test the error class and message
+* a status 404 will raise an error everywhere execept from testing 404 responses
+* you get a shortcut for all content-types that come with Rack::Mime and may register your own
+* you get a little DSL to be able to do several test against the same response in a DRY way
+
+Installation
+------------
+_assert-response_ has been tested with _ruby 1.8.7_ and _1.9.2._ It should be usable with every 
+testing library and has been tested with _test/unit_ and _minitest_.
+
+Install it as a gem:
+
+    sudo gem install assert-response
+
+or in rvm:
+
+    gem install assert-response
+    
+
+
+Examples
+--------
+    require 'minitest'
+    require 'rack/test'
+    require 'assert-reponse'
+
+    include Rack::Test::Methods
+
+    def app
+      MyApp
+    end
+  
+_(for usage without the inclusion of Rack::Test::Methods or with Test::Unit, see AssertResponse::Methods)_
+
+And then in your test something like this:
+    get '/myroute'
+    assert_response_html 'my body'
+
+This will
+
+    # raise the error, if an error occures in MyApp
+    raise AssertResponse::Status404 if last_response.status is not 404
+    assert_equal200, last_response.status
+    assert "test/html", last_response.headers['Content-Type']
+    assert_match /my\ body/, last_response.body
+
+But you may also want to...
+check just the mime type:
+    get '/myroute'
+    assert_response_is_html
+
+check for a 404 page:
+    get '/myroute'
+    assert_response_not_found_html "Not found!"
+
+This one does:
+
+    assert 404, last_response.status
+    assert "test/html", last_response.headers['Content-Type']
+    assert_match /Not\ found!/, last_response.body
+
+For all mime types in Rack::Mime you get 3 methods, where [shortcut] is the file extension
+
+    assert_response_[shortcut] # checks for status 200, content-type and body matching
+    assert_response_is_[shortcut] # checks for content-type and status 200
+    assert_response_not_found_[shortcut] # checks for content-type, status 404 and body matching
+
+You may define your own content-type with
+
+    AssertResponse.add_content_type :my_shortcut, "text/mymimetype"
+
+    # later...
+    assert_response_my_shortcut "here the body"
+    assert_response_is_my_shortcut
+    assert_response_not_found_my_shortcut "Not found but correct content-type"
+
+There is some additional sugar like
+
+    assert_response_redirect
+    assert_response_raises
+    assert_response_body
+    assert_response_header
+    assert_response_not_found
+    assert_response_ok
+
+Everything after _assert\_response\__ is the called method of _AssertResponse_, look them up in the documentation.
+
+When using the _assert\_response\__ methods always the the *last_response* object is checked.
+
+If you want to check a saved response instead, you may use the little DSL
+
+    get '/myroute'
+    my_response = last_response
+    get '/other'
+    assert_response my_response do
+      is_html  # checks content-type
+      body 'my body' # same as 'body /my\ body/' 
+    end
+
+Now inside the code block you may use the methods of _AssertResponse_ (but without the *assert\_response\_* prefixes).
+
+
+Contributing to assert-response
+-------------------------------
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+---------
+
+Copyright (c) 2011 Marc Rene Arns. See LICENSE.txt for
+further details.
+

data/VERSION

@@ -1 +1 @@
-0.0.3
+1.0.0

data/lib/assert-response.rb

@@ -1,28 +1,32 @@
 class AssertResponse
+  
+  # error class, raised when a 404 status but another status was expected
   class Status404 < Exception ; end
-  # for each content-type there is a method
-  # * +is_[content_type]+ that checks if the response has the content-type
-  # * +[content_type]+ that checks the content-type and matches the body against the given pattern and checks for status 200
-  # * +not_found_[content_type]+ that checks the content-type, matches the body against the pattern and checks for status 404
-  # see method_missing
-  CONTENT_TYPES = {}
-  CONTENT_TYPES[:html] = 'text/html'
-  CONTENT_TYPES[:css] = 'text/css'
-  CONTENT_TYPES[:js] = 'application/javascript'
-  CONTENT_TYPES[:json] = 'application/json'
-  CONTENT_TYPES[:text] = 'text/plain'
 
-  # Adds custom content_types to AssertResponse::CONTENT_TYPES. We would then have all the test methods for the content-type
+  # Hash to collection available content-types (prefilled with the Rack::Mime::MIME_TYPES)
   #
+  # @see AssertResponse#method_missing
+  CONTENT_TYPES = {}
+
+  # Adds custom content_types to 
+  # {AssertResponse::CONTENT_TYPES}. We would then have all the test methods for the content-type
   # @param [Symbol] name name of the content_type
   # @param [String] content_type content_type (mime type, eg. "text/html")
   def AssertResponse.add_content_type(name, content_type)
-    CONTENT_TYPES.update name, content_type
+    CONTENT_TYPES.update(name => content_type)
+  end
+
+  # add all Rack::Mime::MIME_TYPES as content_types
+  Rack::Mime::MIME_TYPES.each do |fileext,mime|
+    AssertResponse.add_content_type fileext.sub(/^\./, '').to_sym, mime
   end
 
+  # add content_type 'text/plain' as :text
+  AssertResponse.add_content_type :text, 'text/plain'
+
   # Creates a new {AssertResponse} Object. Usually you will want to +instance_exec+ some code on it.
   #
-  # @param [Object] delegate_to the test object that has all the assert_xxx methods that we want to call
+  # @param [Object] delegate_to the test object that has all the +assert_equal+, +assert_match+ and +assert+ methods that we need
   # @param [MockResponse, Response] response the response object that is checked
   def initialize(delegate_to, response, &code)
     @delegate_to = delegate_to
@@ -31,10 +35,11 @@ class AssertResponse
     check_for_error()
   end
 
-  alias :_old_method_missing :method_missing 
-
-  # handles is_[content_type], not_found_[content_type] and [content_type] methods
-  # Delegates unknown methods to +@delegate_to+
+  # for each content-type in {AssertResponse::CONTENT_TYPES} these methods are served by method_missing
+  # * +is_[content_type]+ that checks if the response has the content-type
+  # * +[content_type]+ that checks the content-type and matches the body against the given pattern and checks for status 200
+  # * +not_found_[content_type]+ that checks the content-type, matches the body against the pattern and checks for status 404  
+  # further unknown methods are delegated to +@delegate_to+
   def method_missing(meth, *args, &code)
     case meth.to_s
     when /^(is|found)_(.+)$/ # is_[content_type] methods
@@ -148,11 +153,11 @@ class AssertResponse
 
   # these methods are included in Rack::Test::Methods to be used in a Test Class
   #
-  # call assert_response with a code block to use the DSL (methods from AssertResponse)
-  # or use a method like assert_response_xxx where xxx is the name of the method from AssertResponse you want to call
+  # call assert_response with a code block to use the DSL (methods from {AssertResponse})
+  # or use a method like assert_response_xxx where xxx is the name of the method from {AssertResponse} you want to call
+  # @see AssertResponse
   #
-  # *Test::Unit*
-  # simple
+  # @example with Test::Unit, simple
   #     require 'rack/test'
   #     require 'assert-response'
   #
@@ -168,8 +173,7 @@ class AssertResponse
   #       end
   #     end
   #
-  # without including +Rack::Test::Methods+
-  #
+  # @example without including +Rack::Test::Methods+
   #     require 'rack/test'
   #     require 'assert-response'
   #
@@ -192,8 +196,7 @@ class AssertResponse
   #       end
   #     end
   #
-  # *Minitest*
-  # simple
+  # @example with *Minitest*, simple
   #     require 'rack/test'
   #     require 'assert-response'
   #     include Rack::Test::Methods
@@ -204,7 +207,7 @@ class AssertResponse
   #       assert_response_html "should really work"
   #     end
   #
-  # without including +Rack::Test::Methods+
+  # @example without including +Rack::Test::Methods+
   #     require 'rack/test'
   #     require 'assert-response'
   #
@@ -230,9 +233,8 @@ class AssertResponse
   #       end
   #     end
   module Methods
-    alias_method :__assert_response_method_missing, :method_missing
-
-    # route assert_response_ methods to AssertResponse
+    # route assert_response_ methods to {AssertResponse}
+    # @see AssertResponse
     def method_missing(meth, *args, &code)
       if meth.to_s =~ /^assert_response_(.+)$/
         AssertResponse.new(self, last_response).send($1.to_sym, *args)
@@ -242,6 +244,7 @@ class AssertResponse
     end
 
     # creates an {AssertResponse} Object and +instance_exec+ the code (DSL) in it  
+    # @see AssertResponse
     def assert_response(response=last_response, &code) 
       file, line, rest = caller[0].split(':', 3)
       AssertResponse.new(self, response).instance_exec(file, line.to_i, &code)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: assert-response
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-13 00:00:00.000000000Z
+date: 2011-12-15 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack-test
-  requirement: &24401940 !ruby/object:Gem::Requirement
+  requirement: &16339740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *24401940
+  version_requirements: *16339740
 - !ruby/object:Gem::Dependency
   name: yard
-  requirement: &24401460 !ruby/object:Gem::Requirement
+  requirement: &16337540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24401460
+  version_requirements: *16337540
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &24400980 !ruby/object:Gem::Requirement
+  requirement: &16336000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *24400980
+  version_requirements: *16336000
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &24400500 !ruby/object:Gem::Requirement
+  requirement: &16333600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *24400500
+  version_requirements: *16333600
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &24400020 !ruby/object:Gem::Requirement
+  requirement: &16332240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24400020
+  version_requirements: *16332240
 - !ruby/object:Gem::Dependency
   name: rack-test
-  requirement: &24399540 !ruby/object:Gem::Requirement
+  requirement: &16329940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +76,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *24399540
+  version_requirements: *16329940
 description: 
 email: ! 'Base64.decode64(''bGludXhAbWFyY3JlbmVhcm5zLmRl
 
@@ -85,12 +85,12 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
+- README.md
 files:
 - .document
 - Gemfile
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - lib/assert-response.rb
@@ -111,7 +111,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 652417119344286028
+      hash: -850628618767669317
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/README.rdoc

@@ -1,167 +0,0 @@
-= assert-response
-== Description
-
-Assert-methods (sugar) and a tiny DSL to facilitate testing of rack apps with {Rack::Test}.
-The idea is that an error on the server side should be exposed to the tests as a real error (not hidden inside
-last_response.errors). +assert-response+ raises the correct error and gives us the backtrace back in our tests.
-
-Most of the time we check for the body of the response and then almost always a 404 - Not found is regarded as an error.
-Further we mostly want to check against Strings that are contained in the response body, while in some cases we need Regexps.
-
-So this methods and DSL makes the normal cases easier while making special cases possible. 
-
-To use it in your tests:
-    require 'rack/test'
-    require 'assert-reponse'
-    include Rack::Test::Methods
-
-(for usage without the inclusion of Rack::Test::Methods, see {AssertResponse::Methods}
-
-And then to test do something like this:
-    get '/myroute'
-    assert_response do
-      is_html  # checks content-type
-      body 'my body' # same as 'body /my\ body/' 
-    end
-
-the same could be shorter:
-    get '/myroute'
-    assert_response do
-      html 'my body'
-    end
-
-or even:
-    get '/myroute'
-    assert_response_html 'my body'
-
-Predefined are the content types of html, css, js and json. But you may register your own by calling {AssertResponse.add_content_type}. Then you get all that assert_response_[your_content_type], assert_response_is_[your_content_type] and assert_response_not_found_[your_content_type] methods for granted.
-
-== Installation
-    gem install assert-response
-
-Usually +assert_response+ checks +last_response+, but you could also pass a response Object:
-    get '/a'
-    a = last_response
-    get '/b'
-    assert_response a do # checks /a
-      html 'body of a'
-    end
-
-Inside the code block use the methods of {AssertResponse}.
-
-== Usage
-There are two ways to use assert-response: You could use the DSL or the assert_response_xxx methods.
-=== DSL
-The DSL mode is handy if you want to perform several tests against the same response.
-You call +asser_response+ and give it a code block.
-All methods of the DSL are methods of {AssertResponse} so have a look there.
-    get '/hello_world'
-    assert_response do
-      body '<body>body of hello_world</body>'
-      ok # same as "status 200" 
-      is_html
-    end
-=== assert_response_xxx methods
-Some of the checks could be done simpler since some assertions imply other.
-The code above could be simplified to
-    get '/hello_world'
-    assert_response_html '<body>body of hello_world</body>'
-A call to assert_response_[method] will be forwarded to the according method of {AssertResponse}.
-But it checks always +last_response+, so if you need to pass the response object you will have to use the DSL.
-
-== Examples
-
-=== HTML and other content
-lets see what the following does
-    get '/myroute'
-    assert_response { html 'my body' }
-or shorter:
-    get '/myroute'
-    assert_response_html 'my body' # with the cousins assert_response_css, assert_response_js and assert_response_json
-
-* It checks if +"/myroute"+ has the +Content-Type+ +"text/html"+ and the +body+ matches /my\ body/.
-* It also checks if +status+ of the response is +200+.
-* If the +status+ of the response is +500+ the original error of the rack app is raised (with original message and backtrace!)
-* If +status+ is +404+ an error of class {AssertResponse::Status404} is raised.
-
-=== Redirects
-To check if "/myredirect" returns +status+ 302 and the header +Location+ matches /\/mytarget/, try
-    get '/myredirect'
-    assert_response do
-      status 302
-      header 'Location', '/mytarget'
-    end
-or shorter:
-    get '/myredirect'
-    assert_response_redirect '/mytarget'
-
-
-=== Server Errors
-Server errors should not happen, but if they do we want them to show up as errors in our test cases.
-
-The following checks if the route +"/error"+ raises an error of class +RuntimeError+ with a message that matches +/my\ error\ message/+
-    get '/error'
-    assert_response { raises RuntimeError, "my error message" }
-or shorter
-    get '/error'
-    assert_response_raises RuntimeError, "my error message"
-
-If we are not interested in the error class or message we omit them.
-    get '/error'
-    assert_response_raises
-    
-=== 404 - not found
-If we expect a status 404, we could do
-    get '/not-existant'
-    assert_response_status 404
-or
-  get '/not-existant'
-    assert_response { not_found }
-or
-    get '/not-existant'
-    assert_response_not_found
-
-Most of the time we don't want a 404 response in our tests, so it's an error.
-If we test for a body of a known content-type (eg. with assert_html, assert_js and friends) it is assumed that we don't want a 404 response, so an error will be thrown if we get some.
-So to be able to check the body too to test a customer 404 page, we could do:
-    get '/not-existant'
-    assert_response do 
-      not_found
-      header('Content-Type', 'text/html') # {AssertResponse#is_html} could not be used since it implies a status 200
-      body "Page could not be found" # {AssertResponse#html} could not be used since it implies a status 200
-    end
-or
-    get '/not-existant'
-    assert_response_not_found_html "Page could not be found" # also 'assert_not_found_js' and friends
-
-=== Custom Headers
-    get '/special'
-    assert_response_header 'my_header', 'my header value' 
-
-=== Custom Content-Types
-    get '/special'
-    assert_response_content_type 'my/contenttype'
-
-or 
-    AssertResponse.add_content_type :my_type, 'my/contenttype'
-    # and then
-    get '/special'
-    assert_response_my_type 'here the body of my type'
-    
-
-
-== Contributing to assert-response
- 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
-* Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2011 Marc Rene Arns. See LICENSE.txt for
-further details.
-