RubyGems - assert-response - Versions diffs - 0.0.3 - Mend

assert-response 0.0.3

Files changed (10) hide show

data/.document +5 -0
data/Gemfile +13 -0
data/LICENSE.txt +20 -0
data/README.rdoc +167 -0
data/Rakefile +44 -0
data/VERSION +1 -0
data/lib/assert-response.rb +254 -0
data/test/helper.rb +15 -0
data/test/test_assert-response.rb +135 -0
metadata +130 -0

data/.document ADDED Viewed

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+-
+features/**/*.feature
+LICENSE.txt

data/Gemfile ADDED Viewed

@@ -0,0 +1,13 @@
+source "http://rubygems.org"
+gem "rack-test"
+group :development do
+  gem "yard"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+  if RUBY_VERSION =~ /1.8/
+    gem 'backports'
+    gem 'minitest'
+  end
+end

data/LICENSE.txt ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Marc Rene Arns
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc ADDED Viewed

@@ -0,0 +1,167 @@
+= 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.

data/Rakefile ADDED Viewed

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "assert-response"
+  gem.homepage = "http://github.com/metakeule/assert-response"
+  gem.license = "MIT"
+  gem.summary = %Q{Assert-methods (sugar) and a tiny DSL to facilitate testing of rack apps with Rack::Test.}
+  #gem.description = %Q{TODO: longer description of your gem}
+  gem.email = "Base64.decode64('bGludXhAbWFyY3JlbmVhcm5zLmRl\n')"
+  gem.authors = ["Marc Rene Arns"]
+  gem.add_runtime_dependency 'rack-test'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+task :default => :test
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION ADDED Viewed

	@@ -0,0 +1 @@
1	+ 0.0.3

data/lib/assert-response.rb ADDED Viewed

@@ -0,0 +1,254 @@
+class AssertResponse
+  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
+  #
+  # @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
+  end
+  # 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 [MockResponse, Response] response the response object that is checked
+  def initialize(delegate_to, response, &code)
+    @delegate_to = delegate_to
+    @response = response
+    @error = nil
+    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+
+  def method_missing(meth, *args, &code)
+    case meth.to_s
+    when /^(is|found)_(.+)$/ # is_[content_type] methods
+      if ctype = CONTENT_TYPES[$2.to_sym]
+        ok()
+        return content_type(ctype)
+      end
+    when /^not_found_(.+)$/ # not_found_[content_type] methods
+      if ctype = CONTENT_TYPES[$1.to_sym]
+        content_type ctype
+        return body(args.first, 404)
+      end
+    else
+      if ctype = CONTENT_TYPES[meth] # [content_type] methods
+        ok()
+        content_type ctype
+        return body(args.first)
+      end
+    end
+    @delegate_to.send meth, *args, &code
+  end
+  # Checks if status is 200.
+  def ok()
+    status 200
+  end
+  # Checks if the status is +status+. For status other then 5xx and error is raised if the response has an error.
+  # For status other than 404 an error Status404 is thrown if response status is 404
+  #
+  # @params [Integer] status the expected status
+  def status(status)
+    raise_error() unless status =~ /^5/ or @response.errors.empty?
+    Kernel.raise(Status404, "not found") unless status == 404 or @response.status != 404
+    assert_equal(status, @response.status)
+  end
+  # Checks if the response status is 404.
+  def not_found()
+    status 404
+  end
+  # Checks if the status is 302, and the header "Location" matches the +pattern+
+  #
+  # @param [String,Regexp] pattern the pattern to match against.
+  def redirect(pattern)
+    status 302
+    header 'Location', pattern
+  end
+  # Checks if the header +key+ exists and / or if it matches +pattern+.
+  #
+  # @param [String] key the key to look for
+  # @param [String,Regexp,:exists] pattern the pattern to match against. +:exists+ just checks for existance of +key+.
+  def header(key, pattern=:exists)
+    if pattern == :exists
+      assert !@response.headers[key].to_s.empty?, "Header '#{key}' not found"
+    else
+      assert_match normalize_pattern(pattern), @response.headers[key].to_s
+    end
+  end
+  # Check if the +Content-Type+ matches +pattern+. Checks also if request is ok (see {#ok}).
+  #
+  # @param [String,Regexp] pattern the pattern to match against.
+  def content_type(pattern)
+    header 'Content-Type', pattern
+  end
+  # Check if body matches +pattern+ and status is +status+.
+  #
+  # @param [String,Regexp] pattern the pattern to match against.
+  # @params [Integer] status the expected status (default 200, see {#ok})
+  def body(pattern, status=200)
+    status(status)
+    assert_match normalize_pattern(pattern), @response.body
+  end
+  # Check if an error was raised.
+  #
+  # @param [Class] exception_class also check if error is_a? +exception_class+
+  # @param [String,Regexp] pattern also check if the error message matches +pattern+
+  def raises(exception_class=nil, pattern=nil)
+    assert_equal exception_class, @error.class if exception_class
+    assert_match normalize_pattern(pattern), @error.message if pattern
+    assert !@error.nil?
+  end
+  private
+  def normalize_pattern(pattern)
+    pattern.is_a?(Regexp) ? pattern : /#{Regexp.escape(pattern.to_s)}/
+  end
+  def check_for_error
+    normalize_error unless @response.errors.to_s.empty?
+  end
+  def normalize_error
+    message, backtrace = @response.errors.split "\n", 2
+    backtrace = backtrace.split
+    err_klass, message = message.split '-', 2
+    @error = Module.const_get(err_klass.strip.to_sym).new(message.strip)
+    @error.set_backtrace backtrace
+    @error
+  end
+  def raise_error()
+    Kernel.raise @error
+  end
+  # 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
+  #
+  # *Test::Unit*
+  # simple
+  #     require 'rack/test'
+  #     require 'assert-response'
+  #
+  #     class TestMe < Test::Unit::Testcase
+  #       include Rack::Test::Methods
+  #       def app
+  #         MyApp
+  #       end
+  #
+  #       def test_something
+  #         get '/works'
+  #         assert_response_html "should really work"
+  #       end
+  #     end
+  #
+  # without including +Rack::Test::Methods+
+  #
+  #     require 'rack/test'
+  #     require 'assert-response'
+  #
+  #     class AppWrapper
+  #       include Rack::Test::Methods
+  #       def app
+  #         MyApp
+  #       end
+  #     end
+  #
+  #     class TestMe < Test::Unit::Testcase
+  #       include AssertResponse::Methods
+  #
+  #       def test_something
+  #         server = AppWrapper.new
+  #         server.get '/works'
+  #         assert_response server.last_response do
+  #           html "should really work"
+  #         end
+  #       end
+  #     end
+  #
+  # *Minitest*
+  # simple
+  #     require 'rack/test'
+  #     require 'assert-response'
+  #     include Rack::Test::Methods
+  #
+  #     # write your tests here
+  #     it "should work" do
+  #       get '/works'
+  #       assert_response_html "should really work"
+  #     end
+  #
+  # without including +Rack::Test::Methods+
+  #     require 'rack/test'
+  #     require 'assert-response'
+  #
+  #     class AppWrapper
+  #       include Rack::Test::Methods
+  #       def app
+  #         MyApp
+  #       end
+  #     end
+  #
+  #     include AssertResponse::Methods
+  #
+  #     describe "my app" do
+  #       before do
+  #         @app = AppWrapper.new
+  #       end
+  #
+  #       it "should work" do
+  #         @app.get '/works'
+  #         assert_response(@app.last_response) do
+  #           html "should really work"
+  #         end
+  #       end
+  #     end
+  module Methods
+    alias_method :__assert_response_method_missing, :method_missing
+    # route assert_response_ methods to AssertResponse
+    def method_missing(meth, *args, &code)
+      if meth.to_s =~ /^assert_response_(.+)$/
+        AssertResponse.new(self, last_response).send($1.to_sym, *args)
+      else
+        super
+      end
+    end
+    # creates an {AssertResponse} Object and +instance_exec+ the code (DSL) in it
+    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)
+    end
+  end
+end
+module Rack::Test::Methods
+  include AssertResponse::Methods
+end

data/test/helper.rb ADDED Viewed

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'rack/test'

data/test/test_assert-response.rb ADDED Viewed

@@ -0,0 +1,135 @@
+require 'backports' if RUBY_VERSION =~ /1.8/
+require_relative "helper.rb"
+require_relative File.join("..", "lib", "assert-response.rb")
+include Rack::Test::Methods
+def handle_exception(env)
+  begin
+    yield
+  rescue Exception => err
+    env['rack.errors'] = StringIO.new("#{err.class} - #{err.message}\n#{err.backtrace.join("\n")}")
+  end
+end
+def tester
+end
+def app
+  proc { |env|
+    status = 200
+    headers = { 'Content-Type' => 'text/html' }
+    body = 'nothing to see here, move along'
+    case env['PATH_INFO']
+    when '/html'
+      body = '<body>my html</body>'
+    when '/js'
+      headers['Content-Type'] = 'application/javascript'
+      body = 'alert("hi");'
+    when '/css'
+      headers['Content-Type'] = 'text/css'
+      body = 'body{ color: black; }'
+    when '/json'
+      headers['Content-Type'] = 'application/json'
+      body = '{"response":"ok"}'
+    when '/text'
+      headers['Content-Type'] = 'text/plain'
+      body = 'foo-bar and others'
+    when '/error'
+      handle_exception(env) do
+        raise "my error"
+      end
+      status = 500
+    when '/redirect'
+      headers['Location'] = '/target'
+      status = 302
+    when '/arg_error'
+      handle_exception(env) do
+        tester 234
+      end
+      status = 500
+    when '/not_found'
+      status = 404
+      body = "<body>Not found</body>"
+    else
+      status = 404
+    end
+    [status, headers, [body]]
+  }
+end
+describe "assert-response" do
+  it "should check json" do
+    get '/json'
+    assert_response_json /ok/
+  end
+  it "should check html" do
+    get '/html'
+    assert_response_html '<body>'
+  end
+  it "should check css" do
+    get '/css'
+    assert_response_css 'color'
+  end
+  it "should check js" do
+    get '/js'
+    assert_response_js 'alert'
+  end
+  it "should check text" do
+    get '/text'
+    assert_response do
+      is_text
+      body 'foo-bar'
+    end
+  end
+  it "should check redirect" do
+    get '/redirect'
+    assert_response_redirect '/target'
+  end
+  it "should not find missing pages" do
+    get '/settings'
+    assert_response_not_found
+  end
+  it "check errors for some kind of sinatra errors" do
+    get '/error'
+    assert_response_raises
+  end
+  it "check errors for some other sinatra errors" do
+    get '/arg_error'
+    assert_response_raises ArgumentError
+  end
+  it "should raise errors for some other sinatra errors" do
+    get '/error'
+    assert_raises RuntimeError do
+      assert_response_ok
+    end
+  end
+  it "should raise errors for some other sinatra errors" do
+    get '/arg_error'
+    assert_raises ArgumentError do
+      assert_response_ok
+    end
+  end
+  it "should raise error for not_found when body is expected" do
+    get '/not_there'
+    assert_raises AssertResponse::Status404 do
+      assert_response_html "hiho"
+    end
+  end
+  it "should check not found html page" do
+    get '/not_found'
+    assert_response_not_found_html "<body>Not found</body>"
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: assert-response
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease:
+platform: ruby
+authors:
+- Marc Rene Arns
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-12-13 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &24401940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *24401940
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &24401460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *24401460
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &24400980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *24400980
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &24400500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *24400500
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &24400020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *24400020
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &24399540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *24399540
+description:
+email: ! 'Base64.decode64(''bGludXhAbWFyY3JlbmVhcm5zLmRl
+  '')'
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/assert-response.rb
+- test/helper.rb
+- test/test_assert-response.rb
+homepage: http://github.com/metakeule/assert-response
+licenses:
+- MIT
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 652417119344286028
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.6
+signing_key:
+specification_version: 3
+summary: Assert-methods (sugar) and a tiny DSL to facilitate testing of rack apps
+  with Rack::Test.
+test_files:
+- test/helper.rb
+- test/test_assert-response.rb