ryanbriones-ZenTest 3.11.1

data/lib/test/rails/functional_test_case.rb

@@ -0,0 +1,79 @@
+$TESTING_RTC = defined?($TESTING_RTC) && $TESTING_RTC
+
+##
+# FunctionalTestCase is an abstract class that sets up a controller instance
+# for its subclasses.
+
+class Test::Rails::FunctionalTestCase < Test::Rails::TestCase
+
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+
+  ##
+  # Sets up instance variables to allow tests depending on a controller work.
+  #
+  # setup uses the instance variable @controller_class_name to determine which
+  # controller class to instantiate.
+  #
+  # setup also instantiates a new @request and @response object.
+  #
+  # If you need to perform extra setup actions, define #setup_extra and
+  # FunctionalTestCase will call it after performing the rest of its setup
+  # actions.
+
+  def setup
+    return if self.class.name =~ /TestCase$/ and not $TESTING_RTC
+    super
+
+    @controller_class = Object.path2class @controller_class_name
+    raise "Can't determine controller class for #{self.class}" if @controller_class.nil?
+
+    @controller = @controller_class.new
+
+    @session = ActionController::TestSession.new
+
+    @flash = ActionController::Flash::FlashHash.new
+    @session['flash'] = @flash
+
+    @request = ActionController::TestRequest.new
+    @request.session = @session
+
+    # HACK There's probably an official way to do this
+    @controller.instance_variable_set :@_session, @request.session
+
+    @response = ActionController::TestResponse.new
+
+    setup_extra if respond_to? :setup_extra
+  end
+
+  ##
+  # Flash accessor.  The flash can be assigned to before calling process or
+  # render and it will Just Work (yay!)
+  #
+  # view:
+  #   <div class="error"><%= flash[:error] %></div>
+  #
+  # test:
+  #   flash[:error] = 'You did a bad thing.'
+  #   render
+  #   assert_tag :tag => 'div', :attributes => { :class => 'error' },
+  #              :content => 'You did a bad thing.'
+
+  attr_reader :flash
+
+  ##
+  # Session accessor.  The session can be assigned to before calling process
+  # or render and it will Just Work (yay!)
+  #
+  # test:
+  #
+  #   def test_logout
+  #     session[:user] = users(:herbert)
+  #     post :logout
+  #     assert_equal nil, session[:user]
+  #   end
+
+  attr_reader :session
+
+end
+

data/lib/test/rails/helper_test_case.rb

@@ -0,0 +1,64 @@
+##
+# Stub controller for testing helpers.
+
+class HelperTestCaseController < ApplicationController
+
+  attr_accessor :request
+
+  attr_accessor :url
+
+  ##
+  # Re-raise errors
+
+  def rescue_action(e)
+    raise e
+  end
+
+end
+
+##
+# HelperTestCase allows helpers to be easily tested.
+#
+# Original concept by Ryan Davis, original implementation by Geoff Grosenbach.
+
+class Test::Rails::HelperTestCase < Test::Rails::FunctionalTestCase
+
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+
+  # Are other helpers needed?
+
+  include ActionView::Helpers::ActiveRecordHelper
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::FormOptionsHelper
+  include ActionView::Helpers::FormHelper
+  include ActionView::Helpers::UrlHelper
+  include ActionView::Helpers::AssetTagHelper
+  include ActionView::Helpers::PrototypeHelper rescue nil # Rails 1.0 only
+  include ActionView::Helpers::TextHelper
+
+  ##
+  # Automatically includes the helper module into the test sublcass.
+
+  def self.inherited(helper_testcase)
+    super
+    helper_name = helper_testcase.name.sub 'Test', ''
+    helper_module = Object.path2class helper_name
+    helper_testcase.send :include, helper_module
+  rescue NameError
+    raise "Unable to find helper #{helper_name}"
+  end
+
+  def setup
+    return if self.class.name =~ /TestCase$/
+    @controller_class_name = 'HelperTestCaseController'
+    super
+    @controller.request = @request
+    @controller.url = ActionController::UrlRewriter.new @request, {} # url_for
+    
+    ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
+  end
+
+end
+

data/lib/test/rails/ivar_proxy.rb

@@ -0,0 +1,31 @@
+require 'test/rails'
+
+##
+# A wrapper that allows instance variables to be manipulated using +[]+ and
+# +[]=+
+
+class Test::Rails::IvarProxy
+
+  ##
+  # Wraps +object+ allowing its instance variables to be manipulated.
+
+  def initialize(object)
+    @object = object
+  end
+
+  ##
+  # Retrieves +ivar+ from the wrapped object.
+
+  def [](ivar)
+    @object.instance_variable_get "@#{ivar}"
+  end
+
+  ##
+  # Sets +ivar+ to +val+ on the wrapped object.
+
+  def []=(ivar, val)
+    @object.instance_variable_set "@#{ivar}", val
+  end
+
+end
+

data/lib/test/rails/pp_html_document.rb

@@ -0,0 +1,74 @@
+class HTML::Document
+  def pretty_print(q)
+    q.object_address_group self do
+      q.breakable
+      q.seplist @root.children_without_newlines do |v| q.pp v end
+    end
+  end
+end
+  
+class HTML::Node
+  def children_without_newlines
+    @children.reject do |c|
+      HTML::Text == c.class and c.content_without_whitespace == "\n"
+    end
+  end
+
+  def pretty_print(q)
+    q.group 1, '[NODE ', ']' do
+      q.breakable
+      q.seplist children_without_newlines do |v| q.pp v end
+    end
+  end
+end
+
+class HTML::Tag
+  def pretty_print(q)
+    case @closing
+    when :close then
+      q.text "[close #{@name}]"
+    when :self then
+      pretty_print_tag 'empty', q
+    when nil then
+      pretty_print_tag 'open ', q
+    else
+      raise "Unknown closing #{@closing.inspect}"
+    end
+  end
+
+  def pretty_print_tag(type, q)
+    q.group 1, "(#{type} #{@name.inspect}", ')' do
+      unless @attributes.empty? then
+        q.breakable
+        q.pp @attributes
+      end
+      unless children_without_newlines.empty? then
+        q.breakable
+        q.group 1, '[', ']' do
+          q.seplist children_without_newlines do |v|
+            q.pp v
+          end
+        end
+      end
+    end
+  end
+end
+
+class HTML::Text
+  def content_without_whitespace
+    @content.gsub(/^[ ]+/, '').sub(/[ ]+\Z/, '')
+  end
+
+  def pretty_print(q)
+    q.pp content_without_whitespace
+  end
+end
+
+class HTML::CDATA
+  def pretty_print(q)
+    q.group 1, '[', ']' do
+      q.pp @content
+    end
+  end
+end
+

data/lib/test/rails/rake_tasks.rb

@@ -0,0 +1,50 @@
+require 'code_statistics'
+
+def define_test_task(test_type)
+  desc "Run the #{test_type} tests in test/#{test_type}s"
+  Rake::TestTask.new "#{test_type}s" => [ 'db:test:prepare' ] do |t|
+    t.libs << 'test'
+    t.pattern = "test/#{test_type}s/**/*_test.rb"
+    t.verbose = true
+  end
+end
+
+namespace :test do
+  define_test_task 'helper'
+  define_test_task 'view'
+  define_test_task 'controller'
+end
+
+desc 'Run all tests'
+task :test => %w[
+  test:units
+  test:controllers
+  test:helpers
+  test:views
+  test:functionals
+  test:integration
+]
+
+dirs = [
+  %w[Libraries          lib/],
+  %w[Models             app/models],
+  %w[Unit\ tests        test/unit],
+  %w[Helpers            app/helpers],
+  %w[Helper\ tests      test/helpers],
+  %w[Components         components],
+  %w[Controllers        app/controllers],
+  %w[Controller\ tests  test/controllers],
+  %w[View\ tests        test/views],
+  %w[Functional\ tests  test/functional],
+  %w[Integration\ tests test/integration],
+  %w[APIs               app/apis],
+]
+
+dirs = dirs.map { |name, dir| [name, File.join(RAILS_ROOT, dir)] }
+dirs = dirs.select { |name, dir| File.directory? dir }
+
+STATS_DIRECTORIES.replace dirs
+
+new_test_types = ['Controller tests', 'Helper tests', 'View tests']
+CodeStatistics::TEST_TYPES.push(*new_test_types)
+

data/lib/test/rails/render_tree.rb

@@ -0,0 +1,93 @@
+##
+# test/rails/render_tree.rb adds debug rendering to ActionView::Base#render.
+#
+# Debug rendering prints out a tree of calls to render allowing you to easily
+# visualize where rendering occurs in unfamiliar code.
+
+class ActionView::Base
+
+  alias plain_render render # :nodoc:
+
+  ##
+  # List of render types for ActionView::Base#render
+
+  RENDERS = [:partial, :template, :file, :action, :text, :inline, :nothing,
+             :update]
+
+  ##
+  # Add debug output to rendering.
+  #
+  # When you include lib/rails/render_tree a tree of renders will be displayed
+  # in the console.  This is especially useful when writing tests.
+  #
+  # This test:
+  #
+  #   require 'test/test_helper'
+  #   require 'test/rails/render_tree'
+  #   
+  #   class ThingsViewTest < Test::Rails::ViewTestCase
+  #   
+  #     fixtures :goals
+  #   
+  #     def test_body
+  #       assigns[:goal] = goals(:first)
+  #       assigns[:related_goals_moved] = []
+  #       assigns[:related_goals_instead] = []
+  #   
+  #       render :partial => 'things/body'
+  #   
+  #       assert_tag :tag => 'div', :attributes => { :id => 'entriesbucket' }
+  #     end
+  #   
+  #   end
+  #
+  # Will give this output when run:
+  #
+  #   $ ruby test/views/things_view_test.rb -n test_body
+  #   Loaded suite test/views/things_view_test
+  #   Started
+  #   "things/_body"
+  #     :partial => "widgets/goals_gallery_teaser"
+  #       "widgets/_goals_gallery_teaser"
+  #     :partial => "entries_bucket"
+  #       "things/_entries_bucket"
+  #     :partial => "things/ask_a_question"
+  #       "things/_ask_a_question"
+  #     "widgets/forms/related_goals"
+  #   .
+  #   Finished in 1.293523 seconds.
+  #   
+  #   1 tests, 1 assertions, 0 failures, 0 errors
+
+  def render(*args)
+    @level ||= 0
+
+    print '  ' * @level
+
+    case args.first
+    when String then
+      p args.first
+    when Hash then
+      hash = args.first
+      if hash.include? :collection and hash.include? :partial then
+        puts "%p => %p" % [:collection, hash[:partial]]
+      else
+        found = hash.keys & RENDERS
+        if found.length == 1 then
+          puts "%p => %p" % [found.first, hash[found.first]]
+        else
+          raise "Dunno: %p" % [hash]
+        end
+      end
+    else
+      raise "Dunno: %p" % [args]
+    end
+
+    @level += 1
+    result = plain_render(*args)
+    @level -= 1
+    result
+  end
+
+end
+

data/lib/test/rails/test_case.rb

@@ -0,0 +1,28 @@
+##
+# Test::Rails::TestCase is an abstract test case for Test::Rails test cases.
+#--
+# Eventually this will hold the fixture setup stuff.
+
+class Test::Rails::TestCase < Test::Unit::TestCase
+
+  undef_method :default_test
+
+  # Set defaults because Rails has poor ones (and these don't inherit properly)
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+
+end
+
+module Test::Unit::Assertions
+  ##
+  # TODO: should this go in this file?
+  # Asserts that model indeed has a given callback
+  #
+  # assert_callback(Model, :before_save, :something)
+
+  def assert_callback(model_class, callback, method_name, message=nil)
+    vars = model_class.instance_variable_get(:@inheritable_attributes)
+    assert vars.has_key?(callback), message
+    assert_include vars[callback], method_name, message
+  end
+end

data/lib/test/rails/view_test_case.rb

@@ -0,0 +1,597 @@
+##
+# ViewTestCase allows views to be tested independent of their controllers.
+# Testcase implementors must set up the instance variables the view needs to
+# render itself.
+#
+# = Features
+#
+# * Allows testing of individual AJAX templates.
+# * Allows testing of individual partials.
+# * Large library of helpful assertions.
+#
+# = Naming
+#
+# The test class must be named after your controller class name, so if you're
+# testing views for the +RouteController+ you would name your test case
+# +RouteViewTest+. The test case will expect to find your view files in
+# <tt>app/views/route</tt>.
+#
+# The test names should be in the form of +test_view_edgecase+ where 'view'
+# corresponds to the name of the view file, and 'edgecase' describes the
+# scenario you are testing.
+#
+# If you are testing a view file named 'show.rhtml' your test should be named
+# +test_show+. If your view is behaves differently depending upon its
+# parameters then you can make the test name descriptive like
+# +test_show_photos+ and +test_show_no_photos+.
+#
+# = Examples
+#
+# == Typical View Test
+#
+#   class RouteViewTest < Test::Rails::ViewTestCase
+#   
+#     fixtures :users, :routes, :points, :photos
+#   
+#     def test_delete
+#       # Set up instance variables for template
+#       assigns[:loggedin_user] = users(:herbert)
+#       assigns[:route] = routes(:work)
+#   
+#       # render template for the delete action in RouteController
+#       render
+#   
+#       # assert that there's a form with an action of "/route/destroy"
+#       assert_form form_url, :post do
+#         # with a hidden id field
+#         assert_input :hidden, :id
+#         # And a submit button that says 'Delete!'
+#         assert_submit 'Delete!'
+#       end
+#   
+#       # And a link back to the route so you don't delete it
+#       assert_links_to "/route/show/#{routes(:work).id}", 'No, I do not!'
+#     end
+#   
+#   end
+#
+# == Typical Layout Test
+#
+#   require 'test/test_helper'
+#   
+#   # Create a dummy controller for layout views. This lets the setup use the
+#   # right path with minimum fuss.
+#   class LayoutsController < ApplicationController; end
+#   
+#   class LayoutsViewTest < Test::Rails::ViewTestCase
+#   
+#     fixtures :users, :routes, :points, :photos
+#   
+#     def test_default
+#       # Template set-up
+#       @request.request_uri = '/foo'
+#       assigns[:action_title] = 'Hello & Goodbye'
+#   
+#       # Render an empty string with the 'application' layout.
+#       render :text => '', :layout => 'application'
+#   
+#       # Assert content just like a regular view test.
+#       assert_links_to '/', 'Home'
+#       assert_links_to '/user', 'Login'
+#       deny_links_to '/user/logout', 'Logout'
+#       assert_title 'Hello &amp; Goodbye'
+#       assert_h 1, 'Hello &amp; Goodbye'
+#     end
+#   
+#   end
+#
+# = Deprecated Features
+#
+# Form assertions are now using assert_select, so you don't need to pass URLs
+# around everywhere and can instead use a block.  (See above example).
+#
+# The form assertions will still work using the old syntax, but in a future
+# release they will give warnings, then will be removed.
+
+class Test::Rails::ViewTestCase < Test::Rails::FunctionalTestCase
+
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+
+  ##
+  # Sets up the test case.
+
+  def setup
+    return if self.class == Test::Rails::ViewTestCase
+
+    @path_parameters ||= {}
+
+    klass_name = self.class.name.sub(/View/, 'Controller')
+    @controller_class_name ||= klass_name.sub 'Test', ''
+
+    super
+
+    @ivar_proxy = Test::Rails::IvarProxy.new @controller
+
+    # these go here so that flash and session work as they should.
+    @controller.send :initialize_template_class, @response
+    @controller.send :assign_shortcuts, @request, @response
+
+    assigns[:session] = @controller.session
+    @controller.class.send :public, :flash # make flash accessible to the test
+  end
+
+  ##
+  # Allows the view instance variables to be set like flash:
+  #
+  # test:
+  #   def test_show
+  #     assigns[:route] = routes(:work)
+
+  def assigns
+    @ivar_proxy
+  end
+
+  ##
+  # Renders the template. The template is determined from the test name. If
+  # you have multiple tests for the same view render will try to Do The Right
+  # Thing and remove parts of the name looking for the template file.
+  #
+  # By default, render has the added option <tt>:layout => false</tt>,
+  # so if want to test behavior in your layout add <tt>:layout => true</tt>.
+  #
+  # The action can be forced by using the options:
+  #
+  #   render :action => 'new'
+  #
+  #   render :template => 'profile/index'
+  #
+  # A test's path parameters may be overridden, allowing routes with
+  # additional parameters to work.
+  #
+  # == Working with Routes
+  #
+  # By default, a view tests sets the controller and action of a test to the
+  # controller name and action name for the test.  This may be overriden.
+  #
+  # A test involving routes like:
+  #
+  #   map.workspace '/users/:owner/workspace/:action',
+  #                 :controller => 'workspace', :action => 'workspace'
+  #
+  # Can be invoked by setting @path_parameters like this:
+  #
+  #   def test__app_entry
+  #     @path_parameters[:owner] = 'bob'
+  #     @path_parameters[:action] = 'apps'
+  #   
+  #     render :partial => 'apps/app_entry'
+  #   
+  #     # ...
+  #   end
+  #
+  # == View Lookup
+  #
+  # render strips off words trailing an _ in the test name one at a time until
+  # it finds a matching action.  It tries the extensions 'rhtml', 'rxml',
+  # 'rjs', and 'mab' in order for each action until a view is found.
+  #
+  # With this test case:
+  #
+  #   class RouteViewTest < Test::Rails::ViewTestCase
+  #     def test_show_photos
+  #       render
+  #     end
+  #     def test_show_no_photos
+  #       render
+  #     end
+  #   end
+  #
+  # In test_show_photos, render will look for:
+  # * app/views/route/show_photos.rhtml
+  # * app/views/route/show_photos.rxml
+  # * app/views/route/show_photos.rjs
+  # * app/views/route/show_photos.mab
+  # * app/views/route/show.[...]
+  #
+  # And in test_show_no_photos, render will look for:
+  # * app/views/route/show_no_photos.rhtml
+  # * app/views/route/show_no_photos.rxml
+  # * app/views/route/show_no_photos.rjs
+  # * app/views/route/show_no_photos.mab
+  # * app/views/route/show_no.[...]
+  # * app/views/route/show.[...]
+  #
+  # If a view cannot be found the test will flunk.
+
+  def render(options = {}, deprecated_status = nil)
+    @action_name = action_name caller[0] if options.empty?
+    assigns[:action_name] = @action_name
+
+    default_path_parameters = {
+      :controller => @controller.controller_name,
+      :action => @action_name
+    }
+
+    path_parameters = default_path_parameters.merge(@path_parameters)
+
+    @request.path_parameters = path_parameters
+
+    defaults = { :layout => false }
+    options = defaults.merge options
+
+    if Test::Rails.rails_version >= Test::Rails.v1_2 then
+      @controller.send :params=, @request.parameters
+    else
+      @controller.instance_variable_set :@params, @request.parameters
+    end
+    @controller.send :initialize_current_url
+    current_url = URI.parse @controller.url_for
+    @request.request_uri = current_url.request_uri
+
+    # Rails 1.0
+    @controller.send :assign_names rescue nil
+    @controller.send :fire_flash rescue nil
+
+    # Rails 1.1
+    @controller.send :forget_variables_added_to_assigns rescue nil
+
+    # Do the render
+    options[:TR_force] = true
+    @controller.render options, deprecated_status
+
+    # Rails 1.1
+    @controller.send :process_cleanup rescue nil
+  end
+
+  ##
+  # Asserts that there is an error on +field+ of type +type+.
+
+  def assert_error_on(field, type)
+    error_message = ActiveRecord::Errors.default_error_messages[type]
+    assert_select "div.errorExplanation li",
+                  :text => /^#{field} #{error_message}/i
+  end
+
+  ##
+  # A wrapper assert that calls both assert_input and assert_label.
+  #
+  # view:
+  #   <%= start_form_tag :controller => 'game', :action => 'save' %>
+  #   <label for="game_amount">Amount:</label>
+  #   <% text_field 'game', 'amount' %>
+  #
+  # test:
+  #   assert_field '/game/save', :text, :game, :amount
+
+  def assert_field(*args)
+    form_action, type, model, column, value =
+      Symbol === args.first ? [nil, *args] : args
+
+    if form_action then # HACK deprecate
+      assert_input form_action, type, "#{model}[#{column}]", value
+      assert_label form_action, "#{model}_#{column}"
+    else
+      assert_input type, "#{model}[#{column}]", value
+      assert_label "#{model}_#{column}"
+    end
+  end
+
+  ##
+  # Asserts that there is a form whose action is +form_action+.  Optionally,
+  # +method+ and +enctype+ may be specified.  If a block is given, assert_form
+  # behaves like assert_select, so assert_input and friends may be scoped to
+  # the selected form.
+  #
+  # view:
+  #   <%= start_form_tag :action => 'create_file' %>
+  #   # ...
+  #
+  # test:
+  #   assert_form '/game/save'
+  #
+  # or:
+  #   assert_form '/game/save' do
+  #     # ...
+  #   end
+
+  def assert_form(form_action, method = nil, enctype = nil, &block)
+    selector = "form[action='#{form_action}']"
+    selector << "[method='#{method}']" if method
+    selector << "[enctype='#{enctype}']" if enctype
+    assert_select selector, &block
+  end
+
+  ##
+  # Asserts a hN tag of level +level+ exists and contains +content+.
+  #
+  # view:
+  #   <h3>Recent Builds</h3>
+  #
+  # test:
+  #   assert_h 3, 'Recent Builds'
+
+  def assert_h(level, content)
+    assert_select "h#{level}", :text => content
+  end
+
+  ##
+  # Asserts that an image exists with a src of +src+.
+  #
+  # view:
+  #   <img src="/images/bucket.jpg" alt="Bucket">
+  #
+  # test:
+  #   assert_image '/images/bucket.jpg'
+
+  def assert_image(src)
+    assert_select "img[src='#{src}']"
+  end
+
+  ##
+  # Asserts that an input element of +type+ with a name of +name+, and
+  # optionally a value of +value+ exists.
+  #
+  # view:
+  #   <%= text_field 'game', 'amount' %>
+  #
+  # test:
+  #   assert_input :text, "game[amount]"
+
+  def assert_input(*args)
+    action, type, name, value = Symbol === args.first ? [nil, *args] : args
+
+    raise ArgumentError, 'supply type and name' if type.nil? or name.nil?
+
+    input_selector = "input[type='#{type}'][name='#{name}']"
+    input_selector << "[value='#{value}']" if value
+
+    assert_select_in_form action do assert_select input_selector end
+  end
+
+  ##
+  # Asserts that a label with a for attribute of +for_attribute+ exists.
+  #
+  # view:
+  #   <%= start_form_tag :controller => 'game', :action => 'save' %>
+  #   <label for="game_amount">Amount:</label>
+  #
+  # test:
+  #   assert_label 'game_amount'
+
+  def assert_label(*args)
+    action, for_attribute = args.length == 1 ? [nil, *args] : args
+
+    raise ArgumentError, 'supply for_attribute' if for_attribute.nil?
+
+    label_selector = "label[for='#{for_attribute}']"
+
+    assert_select_in_form action do assert_select label_selector end
+  end
+
+  ##
+  # Asserts that there is an anchor tag with an href of +href+ that optionally
+  # has +content+.
+  #
+  # view:
+  #   <%= link_to 'drbrain', :model => user %>
+  #
+  # test:
+  #   assert_links_to '/players/show/1', 'drbrain'
+
+  def assert_links_to(href, content = nil)
+    assert_select(*links_to_options_for(href, content))
+  end
+
+  ##
+  # Denies the existence of an anchor tag with an href of +href+ and
+  # optionally +content+.
+  #
+  # view (for /players/show/1):
+  #   <%= link_to_unless_current 'drbrain', :model => user %>
+  #
+  # test:
+  #   deny_links_to '/players/show/1'
+
+  def deny_links_to(href, content = nil)
+    selector, options = links_to_options_for(href, content)
+    options[:count] = 0
+
+    assert_select selector, options
+  end
+
+  ##
+  # Asserts that there is a form using the 'POST' method whose action is
+  # +form_action+ and uses the multipart content type.  If passed a block,
+  # works like assert_form.
+  #
+  # view:
+  #   <%= start_form_tag({ :action => 'create_file' }, :multipart => true) %>
+  #
+  # test:
+  #   assert_multipart_form '/game/save'
+
+  def assert_multipart_form(form_action, &block)
+    assert_form(form_action, :post, 'multipart/form-data', &block)
+  end
+
+  ##
+  # Asserts that there is a form using the 'POST' method whose action is
+  # +form_action+.  If passed a block, works like assert_form.
+  #
+  # view:
+  #   <%= start_form_tag :action => 'create_file' %>
+  #
+  # test:
+  #   assert_post_form '/game/save'
+
+  def assert_post_form(form_action, &block)
+    assert_form(form_action, :post, &block)
+  end
+
+  ##
+  # Asserts that a select element with a name of "+model+[+column+]" and
+  # +options+ with specified names and values exists.
+  #
+  # view:
+  #   <%= collection_select :game, :location_id, @locations, :id, :name %>
+  #
+  # test:
+  #   assert_select_tag :game, :location_id, 'Ballet' => 1, 'Guaymas' => 2
+
+  def assert_select_tag(*args)
+    action, model, column, options = Symbol === args.first ? [nil, *args] : args
+
+    assert_kind_of Hash, options, "options needs to be a Hash"
+    deny options.empty?, "options must not be empty"
+
+    select_selector = "select[name='#{model}[#{column}]']"
+
+    options.each do |option_name, option_value|
+      option_selector = "option[value='#{option_value}']"
+      selector = "#{select_selector} #{option_selector}"
+
+      assert_select_in_form action do
+        assert_select selector, :text => option_name
+      end
+    end
+  end
+
+  ##
+  # Asserts that a submit element with a value of +value+ exists.
+  #
+  # view:
+  #   <input type="submit" value="Create!" %>
+  #
+  # test:
+  #   assert_submit 'Create!'
+
+  def assert_submit(*args)
+    action, value = args.length == 1 ? [nil, *args] : args
+
+    submit_selector = "input[type='submit'][value='#{value}']"
+
+    assert_select_in_form action do assert_select submit_selector end
+  end
+
+  ##
+  # Asserts that a form with +form_action+ has a descendent that matches
+  # +options+ exists.
+  #
+  # Typically this is not used directly in tests. Instead use it to build
+  # expressive tests that assert which fields are in what form.
+  #
+  # view:
+  #   <%= start_form_tag :action => 'save' %>
+  #   [...]
+  #
+  # test:
+  #   assert_tag_in_form '/route/save', :tag => 'table'
+
+  def assert_tag_in_form(form_action, options)
+    assert_tag :tag => 'form', :attributes => { :action => form_action },
+                 :descendant => options
+  end
+
+  ##
+  # Asserts that a textarea with name +name+ and optionally +value+ exists.
+  #
+  # view:
+  #   <%= text_area 'post', 'body' %>
+  #
+  # test:
+  #   assert_text_area 'post[body]'
+  #
+  # view:
+  #   <textarea id="post_body" name="post[body]">
+  #   <%= @post.body %>
+  #   </textarea>
+  #
+  # test:
+  #   assert_text_area 'post[body]', posts(:post).body
+
+  def assert_text_area(*args)
+    action, name, value = args.first !~ /\A\// ? [nil, *args] : args
+
+    raise ArgumentError, 'supply name' if name.nil?
+
+    text_area_selector = ["textarea[name='#{name}']"]
+    text_area_selector << { :text => value } if value
+
+    assert_select_in_form action do assert_select(*text_area_selector) end
+  end
+
+  alias assert_textarea assert_text_area
+
+  ##
+  # Asserts that a title with +title+ exists.
+  #
+  # view:
+  #   <title>some content</title>
+  #
+  # test:
+  #   assert_title 'some content'
+
+  def assert_title(title)
+    assert_select 'title', :text => title
+  end
+
+  ##
+  # Opposite of assert_select.
+
+  def deny_select(selector)
+    assert_select selector, false
+  end
+
+  ##
+  # Creates a new Paginator that uses the current controller. +item_count+,
+  # +items_per_page+ and +page_number+ are passed straight through.
+
+  def util_make_paginator(item_count, items_per_page, page_number)
+    ActionController::Pagination::Paginator.new(@controller, item_count,
+                                                items_per_page, page_number)
+  end
+
+  ##
+  # Utility method for compatibility with old-style assert_tag form
+  # assertions.
+
+  def assert_select_in_form(action, &block) # :nodoc:
+    if action then
+      assert_form(action, &block)
+    else
+      block.call
+    end
+  end
+
+  ##
+  # Creates an assertion options hash for +href+ and +content+.
+
+  def links_to_options_for(href, content = nil)
+    selector = "a[href='#{href}']"
+    equality = content ? { :text => content } : {}
+    return selector, equality
+  end
+
+  ##
+  # Returns the action_name based on a backtrace line passed in as +test+.
+
+  def action_name(test)
+    orig_name = test = test.sub(/.*in `test_(.*)'/, '\1')
+    controller = @controller.class.name.sub('Controller', '').underscore
+
+    extensions = %w[rhtml rxml rjs mab]
+
+    while test =~ /_/ do
+      return test if extensions.any? { |ext| File.file? "app/views/#{controller}/#{test}.#{ext}" }
+
+      test = test.sub(/_[^_]+$/, '')
+    end
+
+    return test if extensions.any? { |ext| File.file? "app/views/#{controller}/#{test}.#{ext}" }
+
+    flunk "Couldn't find view for test_#{orig_name}"
+  end
+
+end
+