omghax-test_rails 1.0.0

data/History.txt

@@ -0,0 +1,5 @@
+=== 1.0.0 / 2009-03-12
+
+* 1 major enhancement:
+
+  * Extracted test-rails from ZenTest 3.11.1 into a separate gem.

data/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/test/rails.rb
+lib/test/rails/controller_test_case.rb
+lib/test/rails/functional_test_case.rb
+lib/test/rails/helper_test_case.rb
+lib/test/rails/ivar_proxy.rb
+lib/test/rails/pp_html_document.rb
+lib/test/rails/rake_tasks.rb
+lib/test/rails/render_tree.rb
+lib/test/rails/test_case.rb
+lib/test/rails/version.rb
+lib/test/rails/view_test_case.rb
+lib/test/zentest_assertions.rb
+test/test_help.rb
+test/test_rails_controller_test_case.rb
+test/test_rails_helper_test_case.rb
+test/test_rails_view_test_case.rb
+test/test_zentest_assertions.rb

data/README.txt

@@ -0,0 +1,110 @@
+= ZenTest
+
+* http://www.zenspider.com/ZSS/Products/ZenTest/
+* http://rubyforge.org/projects/zentest/
+* mailto:ryand-ruby@zenspider.com
+
+== DESCRIPTION
+
+ZenTest provides 4 different tools and 1 library: zentest, unit_diff,
+autotest, multiruby, and Test::Rails.
+
+ZenTest scans your target and unit-test code and writes your missing
+code based on simple naming rules, enabling XP at a much quicker
+pace. ZenTest only works with Ruby and Test::Unit.
+
+unit_diff is a command-line filter to diff expected results from
+actual results and allow you to quickly see exactly what is wrong.
+
+autotest is a continous testing facility meant to be used during
+development. As soon as you save a file, autotest will run the
+corresponding dependent tests.
+
+multiruby runs anything you want on multiple versions of ruby. Great
+for compatibility checking! Use multiruby_setup to manage your
+installed versions.
+
+Test::Rails helps you build industrial-strength Rails code.
+
+== STRATEGERY
+
+There are two strategeries intended for ZenTest: test conformance
+auditing and rapid XP.
+
+For auditing, ZenTest provides an excellent means of finding methods
+that have slipped through the testing process. I've run it against my
+own software and found I missed a lot in a well tested
+package. Writing those tests found 4 bugs I had no idea existed.
+
+ZenTest can also be used to evaluate generated code and execute your
+tests, allowing for very rapid development of both tests and
+implementation.
+
+== FEATURES
+
+* Scans your ruby code and tests and generates missing methods for you.
+* Includes a very helpful filter for Test::Unit output called unit_diff.
+* Continually and intelligently test only those files you change with autotest.
+* Test against multiple versions with multiruby.
+* Enhance and automatically audit your rails tests using Test::Rails.
+* Includes a LinuxJournal article on testing with ZenTest written by Pat Eyler.
+* See also: http://blog.zenspider.com/archives/zentest/
+* See also: http://blog.segment7.net/articles/category/zentest
+
+== SYNOPSYS
+
+  ZenTest MyProject.rb TestMyProject.rb > missing.rb
+
+  ./TestMyProject.rb | unit_diff
+
+  autotest
+
+  multiruby_setup mri:svn:current
+  multiruby ./TestMyProject.rb
+
+  (and other stuff for Test::Rails)
+
+== REQUIREMENTS
+
+* Ruby 1.6+, JRuby 1.1.2+, or rubinius
+* Test::Unit or miniunit
+* Hoe
+* rubygems
+* diff.exe on windoze. Try http://gnuwin32.sourceforge.net/packages.html
+
+== INSTALL
+
+Using Rubygems:
+
+* sudo gem install ZenTest
+
+Using Rake:
+
+* rake test
+* sudo rake install
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2001-2006 Ryan Davis, Eric Hodel, Zen Spider Software
+
+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/Rakefile

@@ -0,0 +1,13 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/test/rails/version.rb'
+
+Hoe.new('test_rails', Test::Rails::VERSION::STRING) do |test_rails|
+  test_rails.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+  test_rails.developer('Eric Hodel', 'drbrain@segment7.net')
+  test_rails.developer('Dray Lacy', 'dray@izea.com')
+end
+
+# vim: syntax=Ruby

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
+

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
+