ryanbriones-ZenTest 3.11.1

data/lib/test/rails.rb

@@ -0,0 +1,295 @@
+require 'test/unit'
+require 'rubygems'
+require 'rubygems/version'
+require 'test_help' # hopefully temporary, required for Test::Rails to work
+                    # until we get rid of test_help so Test::Unit::TestCase
+                    # is kept virgin.
+require 'rails/version' unless defined? Rails::VERSION
+
+$TESTING = true
+
+##
+# = Introduction
+#
+# Test::Rails helps you build industrial-strength Rails code by:
+# * testing views separate from controllers
+# * enhancing the assertion vocabulary, and
+# * auditing your tests for consistency.
+#
+# = Details
+#
+# Test::Rails:
+# * splits Functional test into Controller and View tests.
+#   * Splits view assertions away from controller assertions.
+#   * Helps decouple views from controllers.
+#   * Allows you to test AJAX actions in isolation.
+#   * Allows you to test a single partial.
+#   * Clearer failures when assert_tag fails.
+# * An auditing script analyzes missing assertions in your controllers and
+#   views.
+# * Library of assertions for testing views.
+#
+# = How to Convert to Test::Rails
+#
+# You will need to make three small changes to test/test_helper.rb to set up
+# Test::Rails:
+#
+# First, add the following to 'test/test_helper.rb' before you require
+# +test_help+:
+#
+#   require 'test/rails'
+#
+# Next, change the class from "Unit" to "Rails" right after you
+# require +test_help+.
+#
+# Your 'test/test_helper.rb' will end up looking like this:
+#
+#   ENV["RAILS_ENV"] = "test"
+#   require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+#   require 'test/rails'
+#   require 'test_help'
+#   
+#   class Test::Rails::TestCase
+#   ...
+#
+# Finally, you need to add the extra rake tasks Test::Rails provides.
+# Add the following line to your Rakefile after you require
+# 'tasks/rails':
+#
+#   require 'test/rails/rake_tasks'
+#
+# *NOTE*:
+#
+# * get/post/etc. no longer have a session or flash argument.  Use the session
+#   and flash accessor instead.
+# * assert_tag will (eventually) not work in controller tests.
+#
+# == Writing View Tests
+#
+# View tests live in test/views.  They are named after the controller that is
+# being tested.  For exampe, RouteViewTest will live in the file
+# test/views/route_view_test.rb.
+#
+# === Example View Test Case
+#
+#   require 'test/test_helper'
+#   
+#   # We are testing RouteController's views
+#   class RouteViewTest < Test::Rails::ViewTestCase
+#     
+#     fixtures :users, :routes, :points, :photos
+#     
+#     # testing the view for the delete action of RouteController
+#     def test_delete
+#       # Instance variables necessary for this view
+#       assigns[:loggedin_user] = users(:herbert)
+#       assigns[:route] = routes(:work)
+#       
+#       # render this view
+#       render
+#       
+#       # assert everything is as it should be
+#       assert_links_to "/route/flickr_refresh/#{routes(:work).id}"
+#       
+#       form_url = '/route/destroy'
+#       assert_post_form form_url
+#       assert_input form_url, :hidden, :id
+#       assert_submit form_url, 'Delete!'
+#       assert_links_to "/route/show/#{routes(:work).id}", 'No, I do not!'
+#     end
+#     
+#     # ...
+#     
+#   end
+#
+# All view tests are a subclass of Test::Rails::ViewTestCase. The name of the
+# subclass must match the controller this view depends upon. ViewTestCase
+# takes care of all the setup necessary for running the tests.
+#
+# The +test_delete+ method is named after the delete method in
+# RouteController. The ViewTestCase#render method looks at the name of the
+# test and tries to figure out which view file to use, so naming tests after
+# actions will save you headaches and typing.
+#
+# Use +assigns+ to set up the variables the view will use when it renders.
+#
+# The call to render is the equivalent to a functional tests' get/post
+# methods. It makes several assumptions, so be sure to read
+# ViewTestCase#render carefully.
+#
+# ViewTestCase has a vastly expanded assertion library to help you out with
+# testing. See ViewTestCase for all the helpful assertions you can use in
+# your view tests.
+#
+# == Writing Controller Tests
+#
+# Controller tests are essentially functional tests without the view assertions.
+#
+# They live in test/controllers, subclass ControllerTestCase, and are
+# named after the controller they are testing. For example,
+# RouteControllerTest will live in the file
+# test/controllers/route_controller_test.rb.
+#
+# === Example Controller Test Case
+#
+#   require 'test/test_helper'
+#   
+#   # We are testing RouteController's actions
+#   class RouteControllerTest < Test::Rails::ControllerTestCase
+#     
+#     fixtures :users, :routes, :points, :photos
+#     
+#     # Testing the delete method
+#     def test_delete
+#       # A session accessor is provided instead of passing a hash to get.
+#       session[:username] = users(:herbert).username
+#       
+#       get :delete, :id => routes(:work).id
+#       
+#       # assert we got a 200
+#       assert_success
+#       
+#       # assert that instance variables are correctly assigned
+#       assert_assigned :action_title, "Deleting \"#{routes(:work).name}\""
+#       assert_assigned :route, routes(:work)
+#     end
+#     
+#     # ...
+#     
+#   end
+#
+# == Writing Abstract Test Cases
+#
+# Abstract test cases are a great way to refactor your tests and
+# ensure you do not violate the DRY principal and share code between
+# different test classes. If you have common setup code for your test
+# classes you can create your own subclass of ControllerTestCase or
+# ViewTestCase.
+#
+# === Example Abstract Test Case
+#
+#   class RobotControllerTestCase < Test::Rails::ControllerTestCase
+#     
+#     fixtures :markets, :people
+#     
+#     def setup
+#       super
+#       
+#       # We're running tests in this class so we don't need to do any more
+#       # setup
+#       return if self.class == RobotControllerTestCase
+#       
+#       # Set our current host
+#       @host = 'www.test.robotcoop.com'
+#       util_set_host @host
+#     end
+#     
+#     ##
+#     # Sets the hostname to +host+ for this request.
+#     
+#     def util_set_host(hoston)
+#       @request.host = host
+#     end
+#     
+#   end
+#
+# = How to Audit Your Tests
+#
+# <tt>bin/rails_test_audit</tt> ensures that your view tests'
+# +assign+s are compared against your controller tests'
+# assert_assigned, warning you when you've forgotten to test
+# something.
+#
+# Given:
+#
+#   class RouteControllerTest < Test::Rails::ControllerTestCase
+#     def test_flickr_refresh
+#       get :flickr_refresh, :id => routes(:work).id
+#       assert_success
+#       
+#       assert_assigned :tz_name, 'Pacific Time (US & Canada)'
+#     end
+#   end
+#
+# And:
+#
+#   class RouteViewTest < Test::Rails::ViewTestCase
+#     def test_flickr_refresh
+#       assigns[:route] = routes(:work)
+#       assigns[:tz_name] = 'Pacific Time (US & Canada)'
+#       
+#       render
+#       
+#       # ...
+#     end
+#   end
+#
+# +rails_test_audit+ will see that you don't have an +assert_assigned+
+# for +route+ and will output:
+#
+#   require 'test/test_helper'
+#   
+#   class RouteControllerTest < Test::Rails::ControllerTestCase
+#     
+#     def test_flickr_refresh
+#       assert_assigned :route, routes(:work)
+#     end
+#     
+#   end
+#
+# = How 'rake test' Changed
+#
+# test:views and test:controllers targets get added so you can run just the
+# view or controller tests.
+#
+# The "test" target runs tests in the following order: units, controllers,
+# views, functionals, integration.
+#
+# The test target no longer runs all tests, it stops on the first
+# failure. This way a failure in a unit test doesn't fill your screen
+# with less important errors because the underlying failure also
+# affected your controllers and views.
+#
+# The stats target is updated to account for controller and view tests.
+
+module Test::Rails
+
+  @rails_version = Gem::Version.new Rails::VERSION::STRING
+  @v1_2 = Gem::Version.new '1.2'
+
+  ##
+  # The currently loaded rails version.  Better than Rails::VERSION::STRING
+  # since this one is comparable.
+
+  def self.rails_version
+    @rails_version
+  end
+
+  def self.v1_2 # :nodoc:
+    @v1_2
+  end
+
+end
+
+class Object # :nodoc:
+  def self.path2class(klassname)
+    klassname.split('::').inject(Object) { |k,n| k.const_get n }
+  end
+end
+
+require 'test/zentest_assertions'
+require 'test/rails/test_case'
+require 'test/rails/functional_test_case'
+require 'test/rails/controller_test_case'
+require 'test/rails/helper_test_case'
+require 'test/rails/ivar_proxy'
+require 'test/rails/view_test_case'
+
+##
+# Use sensible defaults.
+
+class Test::Unit::TestCase # :nodoc:
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+end
+

data/lib/test/rails/controller_test_case.rb

@@ -0,0 +1,382 @@
+##
+# ControllerTestCase allows controllers to be tested independent of their
+# views.
+#
+# = Features
+#
+# * ActionMailer is already set up for you.
+# * The session and flash accessors work on both sides of get/post/etc.
+# * Optional automatic auditing for missing assert_assigns. See
+#   util_audit_assert_assigned
+#
+# = Naming
+#
+# The test class must be named after your controller class name, so if
+# you're testing actions for the +RouteController+ you would name your
+# test case +RouteControllerTest+.
+#
+# The test names should be in the form of +test_action_edgecase+ where
+# 'action' corresponds to the name of the controller action, and
+# 'edgecase' describes the scenario you are testing.
+#
+# If you are testing an action named 'show' your test should be named
+# +test_show+. If your action behaves differently depending upon its
+# arguments then you can make the test name descriptive like
+# +test_show_photos+ and +test_show_no_photos+.
+#
+# = Examples
+#
+# == Typical Controller Test
+#
+#   class RouteControllerTest < Test::Rails::ControllerTestCase
+#     
+#     fixtures :users, :routes, :points, :photos
+#     
+#     def test_delete
+#       # Store current count
+#       count = Route.count
+#       # Set up our environment
+#       session[:username] = users(:herbert).username
+#       
+#       # perform the delete action
+#       get :delete, :id => routes(:work).id
+#       
+#       # Assert we got a 200
+#       assert_response :success
+#       # Assert controller deleted route
+#       assert_equal count-1, Route.count
+#       # Ensure that @action_title is set properly
+#       assert_assigned :action_title, "Deleting \"#{routes(:work).name}\""
+#       # Ensure that @route is set properly
+#       assert_assigned :route, routes(:work)
+#     end
+#     
+#   end
+#
+# == ActionMailer Test
+#
+#   class ApplicationController < ActionController::Base
+#     
+#     ##
+#     # Send an email when we get an unhandled exception.
+#     
+#     def log_error(exception)
+#       case exception
+#       when ::ActionController::RoutingError,
+#            ::ActionController::UnknownAction,
+#            ::ActiveRecord::RecordNotFound then
+#         # ignore
+#       else
+#         unless RAILS_ENV == 'development' then
+#           Email.deliver_error exception, params, session, @request.env
+#         end
+#       end
+#     end
+#     
+#   end
+#   
+#   ##
+#   # Dummy Controller just for testing.
+#   
+#   class DummyController < ApplicationController
+#     
+#     def error
+#       # Simulate a bug in our application
+#       raise RuntimeError
+#     end
+#     
+#   end
+#   
+#   class DummyControllerTest < Test::Rails::ControllerTestCase
+#     
+#     def test_error_email
+#       # The rescue_action added by ControllerTestCase needs to be removed so
+#       # that exceptions fall through to the real error handler
+#       @controller.class.send :remove_method, :rescue_action
+#       
+#       # Fire off a request
+#       get :error
+#       
+#       # We should get a 500
+#       assert_response 500
+#       
+#       # And one delivered email
+#       assert_equal 1, @deliveries.length, 'error email sent'
+#     end
+#     
+#   end
+#
+#--
+# TODO: Ensure that assert_tag doesn't work
+# TODO: Cookie input.
+
+class Test::Rails::ControllerTestCase < Test::Rails::FunctionalTestCase
+
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures = false
+
+  NOTHING = Object.new # :nodoc:
+
+  DEFAULT_ASSIGNS = %w[
+    _cookies _flash _headers _params _request _response _session
+
+    cookies flash headers params request response session
+
+    action_name
+    before_filter_chain_aborted
+    db_rt_after_render
+    db_rt_before_render
+    ignore_missing_templates
+    loggedin_user
+    logger
+    rendering_runtime
+    request_origin
+    template
+    template_class
+    template_root
+    url
+    user
+    variables_added
+  ]
+
+  def setup
+    return if self.class == Test::Rails::ControllerTestCase
+
+    @controller_class_name ||= self.class.name.sub 'Test', ''
+
+    super
+
+    @controller_class.send(:define_method, :rescue_action) { |e| raise e }
+
+    @deliveries = []
+    ActionMailer::Base.deliveries = @deliveries
+
+    # used by util_audit_assert_assigns
+    @assigns_asserted = []
+    @assigns_ignored ||= [] # untested assigns to ignore
+  end
+
+  ##
+  # Excutes the request +action+ with +params+.
+  #
+  # See also: get, post, put, delete, head, xml_http_request
+
+  def process(action, parameters = nil)
+    parameters ||= {}
+
+    @request.recycle!
+    @request.env['REQUEST_METHOD'] ||= 'GET'
+    @request.action = action.to_s
+
+    @request.assign_parameters @controller_class.controller_path, action.to_s,
+                               parameters
+
+    build_request_uri action, parameters
+
+    @controller.process @request, @response
+  end
+
+  ##
+  # Performs a GET request on +action+ with +params+.
+
+  def get(action, parameters = nil)
+    @request.env['REQUEST_METHOD'] = 'GET'
+    process action, parameters
+  end
+
+  ##
+  # Performs a HEAD request on +action+ with +params+.
+
+  def head(action, parameters = nil)
+    @request.env['REQUEST_METHOD'] = 'HEAD'
+    process action, parameters
+  end
+
+  ##
+  # Performs a POST request on +action+ with +params+.
+
+  def post(action, parameters = nil)
+    @request.env['REQUEST_METHOD'] = 'POST'
+    process action, parameters
+  end
+
+  ##
+  # Performs a PUT request on +action+ with +params+.
+
+  def put(action, parameters = nil)
+    @request.env['REQUEST_METHOD'] = 'PUT'
+    process action, parameters
+  end
+
+  ##
+  # Performs a DELETE request on +action+ with +params+.
+
+  def delete(action, parameters = nil)
+    @request.env['REQUEST_METHOD'] = 'DELETE'
+    process action, parameters
+  end
+
+  ##
+  # Performs a XMLHttpRequest request using +request_method+ on +action+ with
+  # +params+.
+
+  def xml_http_request(request_method, action, parameters = nil)
+    @request.env['REQUEST_METHOD'] = request_method.to_s
+
+    @request.env['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
+    @request.env['HTTP_ACCEPT'] = 'text/javascript, text/html, application/xml, text/xml, */*'
+
+    result = process action, parameters
+
+    @request.env.delete 'HTTP_X_REQUESTED_WITH'
+    @request.env.delete 'HTTP_ACCEPT'
+
+    return result
+  end
+
+  ##
+  # Friendly alias for xml_http_request
+
+  alias xhr xml_http_request
+
+  ##
+  # Asserts that the assigns variable +ivar+ is assigned to +value+. If
+  # +value+ is omitted, asserts that assigns variable +ivar+ exists.
+
+  def assert_assigned(ivar, value = NOTHING)
+    ivar = ivar.to_s
+    @assigns_asserted << ivar
+    assert_includes assigns, ivar, "#{ivar.inspect} missing from assigns"
+    unless value.equal? NOTHING then
+      assert_equal value, assigns[ivar],
+                   "assert_assigned #{ivar.intern.inspect}"
+    end
+  end
+
+  ##
+  # Asserts the response content type matches +type+.
+
+  def assert_content_type(type, message = nil)
+    assert_equal type, @response.headers['Content-Type'], message
+  end
+
+  ##
+  # Asserts that +key+ of flash has +content+. If +content+ is a Regexp, then
+  # the assertion will fail if the Regexp does not match.
+  #
+  # controller:
+  #   flash[:notice] = 'Please log in'
+  #
+  # test:
+  #   assert_flash :notice, 'Please log in'
+
+  def assert_flash(key, content)
+    assert flash.include?(key),
+           "#{key.inspect} missing from flash, has #{flash.keys.inspect}"
+
+    case content
+    when Regexp then
+      assert_match content, flash[key],
+                   "Content of flash[#{key.inspect}] did not match"
+    else
+      assert_equal content, flash[key],
+                   "Incorrect content in flash[#{key.inspect}]"
+    end
+  end
+
+  ##
+  # Asserts that the assigns variable +ivar+ is not set.
+
+  def deny_assigned(ivar)
+    ivar = ivar.to_s
+    deny_includes assigns, ivar
+  end
+
+  ##
+  # Checks your assert_assigned tests against the instance variables in
+  # assigns. Fails if the two don't match.
+  #
+  # Add util_audit_assert_assigned to your teardown. If you have instance
+  # variables that you don't need to set (for example, were set in a
+  # before_filter in ApplicationController) then add them to the
+  # @assigns_ignored instance variable in your setup.
+  #
+  # = Example
+  #
+  # == Controller method
+  #
+  #   class UserController < ApplicationController
+  #     def new
+  #       # ...
+  #
+  #       @login_form = false
+  #     end
+  #   end
+  #
+  # == Test setup:
+  #
+  #   class UserControllerTest < Test::Rails::ControllerTestCase
+  #     
+  #     def teardown
+  #       super
+  #       util_audit_assert_assigned
+  #     end
+  #     
+  #     def test_new
+  #       get :new
+  #       
+  #       assert_response :success
+  #       # no assert_assigns for @login_form
+  #     end
+  #     
+  #   end
+  #
+  # == Output
+  #     1) Failure:
+  #   test_new(UserControllerTest)
+  #       [[...]/controller_test_case.rb:331:in `util_audit_assert_assigned'
+  #        [...]/user_controller_test.rb:14:in `teardown_without_fixtures'
+  #        [...]fixtures.rb:555:in `teardown']:
+  #   You are missing these assert_assigned assertions:
+  #       assert_assigned :login_form #, some_value
+  #   .
+
+  def util_audit_assert_assigned
+    return unless @test_passed
+    return unless @controller.send :performed?
+    all_assigns = assigns.keys.sort
+
+    assigns_ignored = DEFAULT_ASSIGNS | @assigns_ignored
+    assigns_ignored = assigns_ignored.map { |a| a.to_s }
+
+    assigns_created = all_assigns - assigns_ignored
+    assigns_asserted = @assigns_asserted - assigns_ignored
+
+    assigns_missing = assigns_created - assigns_asserted
+
+    return if assigns_missing.empty?
+
+    message = []
+    message << "You are missing these assert_assigned assertions:"
+    assigns_missing.sort.each do |ivar|
+      message << "    assert_assigned #{ivar.intern.inspect} #, :some_value"
+    end
+    message << nil # stupid '.'
+
+    flunk message.join("\n")
+  end
+
+  private
+
+  def build_request_uri(action, parameters)
+    return if @request.env['REQUEST_URI']
+
+    options = @controller.send :rewrite_options, parameters
+    options.update :only_path => true, :action => action
+
+    url = ActionController::UrlRewriter.new @request, parameters
+    @request.set_REQUEST_URI url.rewrite(options)
+  end 
+
+end
+