omghax-test_rails 1.0.0

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/zentest_assertions.rb

@@ -0,0 +1,134 @@
+require 'test/unit/assertions'
+
+##
+# Extra assertions for Test::Unit
+
+module Test::Unit::Assertions
+  has_miniunit = defined? ::Mini
+
+  if has_miniunit then
+    alias :assert_include  :assert_includes
+    alias :deny            :refute
+    alias :deny_empty      :refute_empty
+    alias :deny_equal      :refute_equal
+    alias :deny_include    :refute_includes
+    alias :deny_includes   :refute_includes
+    alias :deny_nil        :refute_nil
+    alias :util_capture    :capture_io
+  else
+
+    alias :refute_nil :assert_not_nil
+
+    ##
+    # Asserts that +obj+ responds to #empty? and #empty? returns true.
+
+    def assert_empty(obj)
+      assert_respond_to obj, :empty?
+      assert_block "#{obj.inspect} expected to be empty." do obj.empty? end
+    end
+
+    ##
+    # Like assert_in_delta but better dealing with errors proportional
+    # to the sizes of +a+ and +b+.
+
+    def assert_in_epsilon(a, b, epsilon, message = nil)
+      return assert(true) if a == b # count assertion
+
+      error = ((a - b).to_f / ((b.abs > a.abs) ? b : a)).abs
+      message ||= "#{a} expected to be within #{epsilon * 100}% of #{b}, was #{error}"
+
+      assert_block message do error <= epsilon end
+    end
+
+    ##
+    # Asserts that +collection+ includes +obj+.
+
+    def assert_include collection, obj, msg = nil
+      assert_respond_to collection, :include?
+
+      message ||= "#{collection.inspect}\ndoes not include\n#{obj.inspect}."
+      assert_block message do collection.include?(obj) end
+    end
+
+    alias assert_includes assert_include
+
+    ##
+    # Asserts that +boolean+ is not false or nil.
+
+    def deny(boolean, message = nil)
+      _wrap_assertion do
+        assert_block(build_message(message, "Failed refutation, no message given.")) { not boolean }
+      end
+    end
+
+    ##
+    # Asserts that +obj+ responds to #empty? and #empty? returns false.
+
+    def deny_empty(obj)
+      assert_respond_to obj, :empty?
+      assert_block "#{obj.inspect} expected to have stuff." do !obj.empty? end
+    end
+
+    ##
+    # Alias for assert_not_equal
+
+    alias deny_equal assert_not_equal # rescue nil # rescue for miniunit
+
+    ##
+    # Asserts that +obj+ responds to #include? and that obj does not include
+    # +item+.
+
+    def deny_include(collection, obj, message = nil)
+      assert_respond_to collection, :include?
+      message ||= "#{collection.inspect} includes #{obj.inspect}."
+      assert_block message do !collection.include? obj end
+    end
+
+    alias deny_includes deny_include
+
+    ##
+    # Asserts that +obj+ is not nil.
+
+    alias deny_nil assert_not_nil
+
+    ##
+    # Captures $stdout and $stderr to StringIO objects and returns them.
+    # Restores $stdout and $stderr when done.
+    #
+    # Usage:
+    #   def test_puts
+    #     out, err = capture do
+    #       puts 'hi'
+    #       STDERR.puts 'bye!'
+    #     end
+    #     assert_equal "hi\n", out.string
+    #     assert_equal "bye!\n", err.string
+    #   end
+
+    def util_capture
+      require 'stringio'
+      orig_stdout = $stdout.dup
+      orig_stderr = $stderr.dup
+      captured_stdout = StringIO.new
+      captured_stderr = StringIO.new
+      $stdout = captured_stdout
+      $stderr = captured_stderr
+      yield
+      captured_stdout.rewind
+      captured_stderr.rewind
+      return captured_stdout.string, captured_stderr.string
+    ensure
+      $stdout = orig_stdout
+      $stderr = orig_stderr
+    end
+  end
+end
+
+class Object # :nodoc:
+  unless respond_to? :path2class then
+    def path2class(path) # :nodoc:
+      path.split('::').inject(Object) { |k,n| k.const_get n }
+    end
+  end
+end
+

data/test/test_help.rb

@@ -0,0 +1,36 @@
+# ActionPack
+module ActionController; end
+module ActionController::Flash; end
+class ActionController::Flash::FlashHash < Hash; end
+class ActionController::TestSession < Hash; end
+
+class ActionController::TestRequest
+  attr_accessor :session
+end
+class ActionController::TestResponse; end
+
+class ApplicationController; end
+
+module ActionView; end
+module ActionView::Helpers; end
+module ActionView::Helpers::ActiveRecordHelper; end
+module ActionView::Helpers::TagHelper; end
+module ActionView::Helpers::TextHelper; end
+module ActionView::Helpers::FormTagHelper; end
+module ActionView::Helpers::FormOptionsHelper; end
+module ActionView::Helpers::FormHelper; end
+module ActionView::Helpers::UrlHelper; end
+module ActionView::Helpers::AssetTagHelper; end
+
+class << Test::Unit::TestCase
+  attr_accessor :use_transactional_fixtures
+  attr_accessor :use_instantiated_fixtures
+end
+
+# ActionMailer
+module ActionMailer; end
+class ActionMailer::Base
+  def self.deliveries=(arg); end unless defined? @@defined
+  @@defined = true
+end
+

data/test/test_rails_controller_test_case.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'test/zentest_assertions'
+
+unless defined? $TESTING_RTC then
+  $TESTING_RTC = true
+
+  begin
+    require 'test/rails'
+  rescue LoadError, NameError
+    $TESTING_RTC = false
+  end
+end
+
+class TRController < ApplicationController
+end if $TESTING_RTC
+
+class TestRailsControllerTestCase < Test::Rails::ControllerTestCase
+
+  def setup
+    @controller_class_name = 'TRController'
+    super
+  end
+
+  def assigns
+    { 'ivar' => 'value' }
+  end
+
+  def test_assert_assigned
+    assert_assigned :ivar
+    assert_assigned :ivar, 'value'
+
+    assert_raise Test::Unit::AssertionFailedError do
+      assert_assigned :no_ivar
+    end
+
+    e = assert_raise Test::Unit::AssertionFailedError do
+      assert_assigned :ivar, 'bad_value'
+    end
+
+    expected = <<-EOF.strip
+assert_assigned :ivar.
+<\"bad_value\"> expected but was
+<\"value\">.
+    EOF
+
+    assert_equal expected, e.message
+  end
+
+  def test_deny_assigned
+    deny_assigned :no_ivar
+
+    assert_raise Test::Unit::AssertionFailedError do
+      deny_assigned :ivar
+    end
+  end
+
+end if $TESTING_RTC
+

data/test/test_rails_helper_test_case.rb

@@ -0,0 +1,48 @@
+require 'test/unit'
+require 'test/zentest_assertions'
+
+unless defined? $TESTING_RTC then
+  $TESTING_RTC = true
+
+  begin
+    require 'test/rails'
+  rescue LoadError, NameError
+    $TESTING_RTC = false
+  end
+end
+
+begin
+  module TRHelper
+    def tr_helper; end
+  end
+  class TRHelperTest < Test::Rails::HelperTestCase; end
+rescue RuntimeError
+end if $TESTING_RTC
+
+begin
+  module Widgets; end
+  module Widgets::SomeHelper
+    def widgets_some_helper; end
+  end
+  class Widgets::SomeHelperTest < Test::Rails::HelperTestCase; end
+rescue RuntimeError
+end if $TESTING_RTC
+
+class TestRailsHelperTestCase < Test::Unit::TestCase
+
+  def test_self_inherited
+    assert defined? TRHelperTest
+
+    assert_includes TRHelperTest.instance_methods, 'tr_helper'
+  end
+
+  def test_self_inherited_namespaced
+    assert defined? Widgets
+    assert defined? Widgets::SomeHelperTest
+
+    assert_includes(Widgets::SomeHelperTest.instance_methods,
+                    'widgets_some_helper')
+  end
+
+end if $TESTING_RTC
+