diff options
Diffstat (limited to 'actionpack/test')
78 files changed, 2042 insertions, 417 deletions
diff --git a/actionpack/test/abstract_controller/abstract_controller_test.rb b/actionpack/test/abstract_controller/abstract_controller_test.rb new file mode 100644 index 0000000000..6d33888821 --- /dev/null +++ b/actionpack/test/abstract_controller/abstract_controller_test.rb @@ -0,0 +1,226 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module AbstractController + module Testing + + # Test basic dispatching. + # ==== + # * Call process + # * Test that the response_body is set correctly + class SimpleController < AbstractController::Base + end + + class Me < SimpleController + def index + self.response_body = "Hello world" + "Something else" + end + end + + class TestBasic < ActiveSupport::TestCase + test "dispatching works" do + result = Me.process(:index) + assert_equal "Hello world", result.response_obj[:body] + end + end + + # Test Render mixin + # ==== + class RenderingController < AbstractController::Base + use Renderer + + def _prefix() end + + def render(options = {}) + if options.is_a?(String) + options = {:_template_name => options} + end + + options[:_prefix] = _prefix + super + end + + append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views")) + end + + class Me2 < RenderingController + def index + render "index.erb" + end + + def action_with_ivars + @my_ivar = "Hello" + render "action_with_ivars.erb" + end + + def naked_render + render + end + end + + class TestRenderer < ActiveSupport::TestCase + test "rendering templates works" do + result = Me2.process(:index) + assert_equal "Hello from index.erb", result.response_obj[:body] + end + + test "rendering passes ivars to the view" do + result = Me2.process(:action_with_ivars) + assert_equal "Hello from index_with_ivars.erb", result.response_obj[:body] + end + + test "rendering with no template name" do + result = Me2.process(:naked_render) + assert_equal "Hello from naked_render.erb", result.response_obj[:body] + end + end + + # Test rendering with prefixes + # ==== + # * self._prefix is used when defined + class PrefixedViews < RenderingController + private + def self.prefix + name.underscore + end + + def _prefix + self.class.prefix + end + end + + class Me3 < PrefixedViews + def index + render + end + + def formatted + self.formats = [:html] + render + end + end + + class TestPrefixedViews < ActiveSupport::TestCase + test "templates are located inside their 'prefix' folder" do + result = Me3.process(:index) + assert_equal "Hello from me3/index.erb", result.response_obj[:body] + end + + test "templates included their format" do + result = Me3.process(:formatted) + assert_equal "Hello from me3/formatted.html.erb", result.response_obj[:body] + end + end + + # Test rendering with layouts + # ==== + # self._layout is used when defined + class WithLayouts < PrefixedViews + use Layouts + + private + def self.layout(formats) + begin + view_paths.find_by_parts(name.underscore, formats, "layouts") + rescue ActionView::MissingTemplate + begin + view_paths.find_by_parts("application", formats, "layouts") + rescue ActionView::MissingTemplate + end + end + end + + def _layout + self.class.layout(formats) + end + + def render_to_string(options = {}) + options[:_layout] = options[:layout] || _layout + super + end + end + + class Me4 < WithLayouts + def index + render + end + end + + class Me5 < WithLayouts + def index + render + end + end + + class TestLayouts < ActiveSupport::TestCase + test "layouts are included" do + result = Me4.process(:index) + assert_equal "Me4 Enter : Hello from me4/index.erb : Exit", result.response_obj[:body] + end + + test "it can fall back to the application layout" do + result = Me5.process(:index) + assert_equal "Application Enter : Hello from me5/index.erb : Exit", result.response_obj[:body] + end + end + + # respond_to_action?(action_name) + # ==== + # * A method can be used as an action only if this method + # returns true when passed the method name as an argument + # * Defaults to true in AbstractController + class DefaultRespondToActionController < AbstractController::Base + def index() self.response_body = "success" end + end + + class ActionMissingRespondToActionController < AbstractController::Base + # No actions + private + def action_missing(action_name) + self.response_body = "success" + end + end + + class RespondToActionController < AbstractController::Base; + def index() self.response_body = "success" end + + def fail() self.response_body = "fail" end + + private + + def respond_to_action?(action_name) + action_name != :fail + end + + end + + class TestRespondToAction < ActiveSupport::TestCase + + def assert_dispatch(klass, body = "success", action = :index) + response = klass.process(action).response_obj[:body] + assert_equal body, response + end + + test "an arbitrary method is available as an action by default" do + assert_dispatch DefaultRespondToActionController, "success", :index + end + + test "raises ActionNotFound when method does not exist and action_missing is not defined" do + assert_raise(ActionNotFound) { DefaultRespondToActionController.process(:fail) } + end + + test "dispatches to action_missing when method does not exist and action_missing is defined" do + assert_dispatch ActionMissingRespondToActionController, "success", :ohai + end + + test "a method is available as an action if respond_to_action? returns true" do + assert_dispatch RespondToActionController, "success", :index + end + + test "raises ActionNotFound if method is defined but respond_to_action? returns false" do + assert_raise(ActionNotFound) { RespondToActionController.process(:fail) } + end + end + + end +end
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/callbacks_test.rb b/actionpack/test/abstract_controller/callbacks_test.rb new file mode 100644 index 0000000000..5fce30f478 --- /dev/null +++ b/actionpack/test/abstract_controller/callbacks_test.rb @@ -0,0 +1,197 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module AbstractController + module Testing + + class ControllerWithCallbacks < AbstractController::Base + use AbstractController::Callbacks + end + + class Callback1 < ControllerWithCallbacks + process_action_callback :before, :first + + def first + @text = "Hello world" + end + + def index + self.response_body = @text + end + end + + class TestCallbacks < ActiveSupport::TestCase + test "basic callbacks work" do + result = Callback1.process(:index) + assert_equal "Hello world", result.response_obj[:body] + end + end + + class Callback2 < ControllerWithCallbacks + before_filter :first + after_filter :second + around_filter :aroundz + + def first + @text = "Hello world" + end + + def second + @second = "Goodbye" + end + + def aroundz + @aroundz = "FIRST" + yield + @aroundz << "SECOND" + end + + def index + self.response_body = @text + end + end + + class TestCallbacks < ActiveSupport::TestCase + test "before_filter works" do + result = Callback2.process(:index) + assert_equal "Hello world", result.response_obj[:body] + end + + test "after_filter works" do + result = Callback2.process(:index) + assert_equal "Goodbye", result.instance_variable_get("@second") + end + + test "around_filter works" do + result = Callback2.process(:index) + assert_equal "FIRSTSECOND", result.instance_variable_get("@aroundz") + end + end + + class Callback3 < ControllerWithCallbacks + before_filter do |c| + c.instance_variable_set("@text", "Hello world") + end + + after_filter do |c| + c.instance_variable_set("@second", "Goodbye") + end + + def index + self.response_body = @text + end + end + + class TestCallbacks < ActiveSupport::TestCase + test "before_filter works with procs" do + result = Callback3.process(:index) + assert_equal "Hello world", result.response_obj[:body] + end + + test "after_filter works with procs" do + result = Callback3.process(:index) + assert_equal "Goodbye", result.instance_variable_get("@second") + end + end + + class CallbacksWithConditions < ControllerWithCallbacks + before_filter :list, :only => :index + before_filter :authenticate, :except => :index + + def index + self.response_body = @list.join(", ") + end + + def sekrit_data + self.response_body = (@list + [@authenticated]).join(", ") + end + + private + def list + @list = ["Hello", "World"] + end + + def authenticate + @list = [] + @authenticated = "true" + end + end + + class TestCallbacks < ActiveSupport::TestCase + test "when :only is specified, a before filter is triggered on that action" do + result = CallbacksWithConditions.process(:index) + assert_equal "Hello, World", result.response_obj[:body] + end + + test "when :only is specified, a before filter is not triggered on other actions" do + result = CallbacksWithConditions.process(:sekrit_data) + assert_equal "true", result.response_obj[:body] + end + + test "when :except is specified, an after filter is not triggered on that action" do + result = CallbacksWithConditions.process(:index) + assert_nil result.instance_variable_get("@authenticated") + end + end + + class CallbacksWithArrayConditions < ControllerWithCallbacks + before_filter :list, :only => [:index, :listy] + before_filter :authenticate, :except => [:index, :listy] + + def index + self.response_body = @list.join(", ") + end + + def sekrit_data + self.response_body = (@list + [@authenticated]).join(", ") + end + + private + def list + @list = ["Hello", "World"] + end + + def authenticate + @list = [] + @authenticated = "true" + end + end + + class TestCallbacks < ActiveSupport::TestCase + test "when :only is specified with an array, a before filter is triggered on that action" do + result = CallbacksWithArrayConditions.process(:index) + assert_equal "Hello, World", result.response_obj[:body] + end + + test "when :only is specified with an array, a before filter is not triggered on other actions" do + result = CallbacksWithArrayConditions.process(:sekrit_data) + assert_equal "true", result.response_obj[:body] + end + + test "when :except is specified with an array, an after filter is not triggered on that action" do + result = CallbacksWithArrayConditions.process(:index) + assert_nil result.instance_variable_get("@authenticated") + end + end + + class ChangedConditions < Callback2 + before_filter :first, :only => :index + + def not_index + self.response_body = @text.to_s + end + end + + class TestCallbacks < ActiveSupport::TestCase + test "when a callback is modified in a child with :only, it works for the :only action" do + result = ChangedConditions.process(:index) + assert_equal "Hello world", result.response_obj[:body] + end + + test "when a callback is modified in a child with :only, it does not work for other actions" do + result = ChangedConditions.process(:not_index) + assert_equal "", result.response_obj[:body] + end + end + + end +end
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/helper_test.rb b/actionpack/test/abstract_controller/helper_test.rb new file mode 100644 index 0000000000..6284fa4f70 --- /dev/null +++ b/actionpack/test/abstract_controller/helper_test.rb @@ -0,0 +1,43 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module AbstractController + module Testing + + class ControllerWithHelpers < AbstractController::Base + use Renderer + use Helpers + + def render(string) + super(:_template_name => string) + end + + append_view_path File.expand_path(File.join(File.dirname(__FILE__), "views")) + end + + module HelperyTest + def included_method + "Included" + end + end + + class MyHelpers1 < ControllerWithHelpers + helper(HelperyTest) do + def helpery_test + "World" + end + end + + def index + render "helper_test.erb" + end + end + + class TestHelpers < ActiveSupport::TestCase + def test_helpers + result = MyHelpers1.process(:index) + assert_equal "Hello World : Included", result.response_obj[:body] + end + end + + end +end
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/layouts_test.rb b/actionpack/test/abstract_controller/layouts_test.rb new file mode 100644 index 0000000000..5dd68ec28e --- /dev/null +++ b/actionpack/test/abstract_controller/layouts_test.rb @@ -0,0 +1,232 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module AbstractControllerTests + module Layouts + + # Base controller for these tests + class Base < AbstractController::Base + use AbstractController::Renderer + use AbstractController::Layouts + + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "layouts/hello.erb" => "With String <%= yield %>", + "layouts/hello_override.erb" => "With Override <%= yield %>", + "layouts/abstract_controller_tests/layouts/with_string_implied_child.erb" => + "With Implied <%= yield %>", + "layouts/omg.erb" => "OMGHI2U <%= yield %>", + "layouts/with_false_layout.erb" => "False Layout <%= yield %>" + )] + + def self.controller_path + @controller_path ||= self.name.sub(/Controller$/, '').underscore + end + + def controller_path() self.class.controller_path end + + def render_to_string(options) + options[:_layout] = _default_layout + super + end + end + + class Blank < Base + self.view_paths = [] + + def index + render :_template => ActionView::TextTemplate.new("Hello blank!") + end + end + + class WithString < Base + layout "hello" + + def index + render :_template => ActionView::TextTemplate.new("Hello string!") + end + end + + class WithStringChild < WithString + end + + class WithStringOverriddenChild < WithString + layout "hello_override" + end + + class WithNilChild < WithString + layout nil + end + + class WithStringImpliedChild < WithString + end + + class WithChildOfImplied < WithStringImpliedChild + end + + class WithSymbol < Base + layout :hello + + def index + render :_template => ActionView::TextTemplate.new("Hello symbol!") + end + private + def hello + "omg" + end + end + + class WithSymbolReturningString < Base + layout :no_hello + + def index + render :_template => ActionView::TextTemplate.new("Hello missing symbol!") + end + private + def no_hello + nil + end + end + + class WithSymbolReturningNil < Base + layout :nilz + + def index + render :_template => ActionView::TextTemplate.new("Hello nilz!") + end + + def nilz() end + end + + class WithSymbolReturningObj < Base + layout :objekt + + def index + render :_template => ActionView::TextTemplate.new("Hello nilz!") + end + + def objekt + Object.new + end + end + + class WithSymbolAndNoMethod < Base + layout :omg_no_method + + def index + render :_template => ActionView::TextTemplate.new("Hello boom!") + end + end + + class WithMissingLayout < Base + layout "missing" + + def index + render :_template => ActionView::TextTemplate.new("Hello missing!") + end + end + + class WithFalseLayout < Base + layout false + + def index + render :_template => ActionView::TextTemplate.new("Hello false!") + end + end + + class WithNilLayout < Base + layout nil + + def index + render :_template => ActionView::TextTemplate.new("Hello nil!") + end + end + + # TODO Move to bootloader + AbstractController::Base.subclasses.each do |klass| + klass = klass.constantize + next unless klass < AbstractController::Layouts + klass.class_eval do + _write_layout_method + end + end + + class TestBase < ActiveSupport::TestCase + test "when no layout is specified, and no default is available, render without a layout" do + result = Blank.process(:index) + assert_equal "Hello blank!", result.response_obj[:body] + end + + test "when layout is specified as a string, render with that layout" do + result = WithString.process(:index) + assert_equal "With String Hello string!", result.response_obj[:body] + end + + test "when layout is specified as a string, but the layout is missing, raise an exception" do + assert_raises(ActionView::MissingTemplate) { WithMissingLayout.process(:index) } + end + + test "when layout is specified as false, do not use a layout" do + result = WithFalseLayout.process(:index) + assert_equal "Hello false!", result.response_obj[:body] + end + + test "when layout is specified as nil, do not use a layout" do + result = WithNilLayout.process(:index) + assert_equal "Hello nil!", result.response_obj[:body] + end + + test "when layout is specified as a symbol, call the requested method and use the layout returned" do + result = WithSymbol.process(:index) + assert_equal "OMGHI2U Hello symbol!", result.response_obj[:body] + end + + test "when layout is specified as a symbol and the method returns nil, don't use a layout" do + result = WithSymbolReturningNil.process(:index) + assert_equal "Hello nilz!", result.response_obj[:body] + end + + test "when the layout is specified as a symbol and the method doesn't exist, raise an exception" do + assert_raises(NoMethodError, /:nilz/) { WithSymbolAndNoMethod.process(:index) } + end + + test "when the layout is specified as a symbol and the method returns something besides a string/false/nil, raise an exception" do + assert_raises(ArgumentError) { WithSymbolReturningObj.process(:index) } + end + + test "when a child controller does not have a layout, use the parent controller layout" do + result = WithStringChild.process(:index) + assert_equal "With String Hello string!", result.response_obj[:body] + end + + test "when a child controller has specified a layout, use that layout and not the parent controller layout" do + result = WithStringOverriddenChild.process(:index) + assert_equal "With Override Hello string!", result.response_obj[:body] + end + + test "when a child controller has an implied layout, use that layout and not the parent controller layout" do + result = WithStringImpliedChild.process(:index) + assert_equal "With Implied Hello string!", result.response_obj[:body] + end + + test "when a child controller specifies layout nil, do not use the parent layout" do + result = WithNilChild.process(:index) + assert_equal "Hello string!", result.response_obj[:body] + end + + test "when a grandchild has no layout specified, the child has an implied layout, and the " \ + "parent has specified a layout, use the child controller layout" do + result = WithChildOfImplied.process(:index) + assert_equal "With Implied Hello string!", result.response_obj[:body] + end + + test "raises an exception when specifying layout true" do + assert_raises ArgumentError do + Object.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 + class ::BadOmgFailLolLayout < AbstractControllerTests::Layouts::Base + layout true + end + RUBY_EVAL + end + end + end + end +end
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/test_helper.rb b/actionpack/test/abstract_controller/test_helper.rb new file mode 100644 index 0000000000..b9248c6bbd --- /dev/null +++ b/actionpack/test/abstract_controller/test_helper.rb @@ -0,0 +1,25 @@ +$:.unshift(File.dirname(__FILE__) + '/../../lib') +$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib') +$:.unshift(File.dirname(__FILE__) + '/../lib') + +require 'test/unit' +require 'active_support' +require 'active_support/test_case' +require 'action_controller' +require 'action_view/base' +require 'fixture_template' + +begin + require 'ruby-debug' + Debugger.settings[:autoeval] = true + Debugger.start +rescue LoadError + # Debugging disabled. `gem install ruby-debug` to enable. +end + +require 'action_controller/abstract' +# require 'action_controller/abstract/base' +# require 'action_controller/abstract/renderer' +# require 'action_controller/abstract/layouts' +# require 'action_controller/abstract/callbacks' +# require 'action_controller/abstract/helpers'
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/formatted.html.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/formatted.html.erb new file mode 100644 index 0000000000..785bf69191 --- /dev/null +++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/formatted.html.erb @@ -0,0 +1 @@ +Hello from me3/formatted.html.erb
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/index.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/index.erb new file mode 100644 index 0000000000..f079ad8204 --- /dev/null +++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me3/index.erb @@ -0,0 +1 @@ +Hello from me3/index.erb
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me4/index.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me4/index.erb new file mode 100644 index 0000000000..89dce12bdc --- /dev/null +++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me4/index.erb @@ -0,0 +1 @@ +Hello from me4/index.erb
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/abstract_controller/testing/me5/index.erb b/actionpack/test/abstract_controller/views/abstract_controller/testing/me5/index.erb new file mode 100644 index 0000000000..84d0b7417e --- /dev/null +++ b/actionpack/test/abstract_controller/views/abstract_controller/testing/me5/index.erb @@ -0,0 +1 @@ +Hello from me5/index.erb
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/action_with_ivars.erb b/actionpack/test/abstract_controller/views/action_with_ivars.erb new file mode 100644 index 0000000000..8d8ae22fd7 --- /dev/null +++ b/actionpack/test/abstract_controller/views/action_with_ivars.erb @@ -0,0 +1 @@ +<%= @my_ivar %> from index_with_ivars.erb
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/helper_test.erb b/actionpack/test/abstract_controller/views/helper_test.erb new file mode 100644 index 0000000000..8ae45cc195 --- /dev/null +++ b/actionpack/test/abstract_controller/views/helper_test.erb @@ -0,0 +1 @@ +Hello <%= helpery_test %> : <%= included_method %>
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/index.erb b/actionpack/test/abstract_controller/views/index.erb new file mode 100644 index 0000000000..cc1a8b8c85 --- /dev/null +++ b/actionpack/test/abstract_controller/views/index.erb @@ -0,0 +1 @@ +Hello from index.erb
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/layouts/abstract_controller/testing/me4.erb b/actionpack/test/abstract_controller/views/layouts/abstract_controller/testing/me4.erb new file mode 100644 index 0000000000..172dd56569 --- /dev/null +++ b/actionpack/test/abstract_controller/views/layouts/abstract_controller/testing/me4.erb @@ -0,0 +1 @@ +Me4 Enter : <%= yield %> : Exit
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/layouts/application.erb b/actionpack/test/abstract_controller/views/layouts/application.erb new file mode 100644 index 0000000000..27317140ad --- /dev/null +++ b/actionpack/test/abstract_controller/views/layouts/application.erb @@ -0,0 +1 @@ +Application Enter : <%= yield %> : Exit
\ No newline at end of file diff --git a/actionpack/test/abstract_controller/views/naked_render.erb b/actionpack/test/abstract_controller/views/naked_render.erb new file mode 100644 index 0000000000..1b3d03878b --- /dev/null +++ b/actionpack/test/abstract_controller/views/naked_render.erb @@ -0,0 +1 @@ +Hello from naked_render.erb
\ No newline at end of file diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb index cdeee934d0..b07e6e5f3a 100644 --- a/actionpack/test/abstract_unit.rb +++ b/actionpack/test/abstract_unit.rb @@ -20,8 +20,7 @@ rescue LoadError end require 'action_controller' -require 'action_controller/cgi_ext' -require 'action_controller/test_process' +require 'action_controller/testing/process' require 'action_view/test_case' # Show backtraces for deprecated behavior for quicker cleanup. @@ -38,8 +37,4 @@ I18n.backend.store_translations 'pt-BR', {} ORIGINAL_LOCALES = I18n.available_locales.map(&:to_s).sort FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures') -ActionView::Base.cache_template_loading = true ActionController::Base.view_paths = FIXTURE_LOAD_PATH -CACHED_VIEW_PATHS = ActionView::Base.cache_template_loading? ? - ActionController::Base.view_paths : - ActionController::Base.view_paths.map {|path| ActionView::Template::EagerPath.new(path.to_s)} diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb index cb7922efd2..96f7a42c9b 100644 --- a/actionpack/test/controller/action_pack_assertions_test.rb +++ b/actionpack/test/controller/action_pack_assertions_test.rb @@ -168,11 +168,13 @@ end class ActionPackAssertionsControllerTest < ActionController::TestCase # let's get this party started def setup + super ActionController::Routing::Routes.reload ActionController::Routing.use_controllers!(%w(action_pack_assertions admin/inner_module user content admin/user)) end def teardown + super ActionController::Routing::Routes.reload end diff --git a/actionpack/test/controller/addresses_render_test.rb b/actionpack/test/controller/addresses_render_test.rb index 556b0593ea..2f092b6731 100644 --- a/actionpack/test/controller/addresses_render_test.rb +++ b/actionpack/test/controller/addresses_render_test.rb @@ -23,6 +23,7 @@ class AddressesTest < ActionController::TestCase tests AddressesTestController def setup + super # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get # a more accurate simulation of what happens in "real life". @controller.logger = Logger.new(nil) diff --git a/actionpack/test/controller/assert_select_test.rb b/actionpack/test/controller/assert_select_test.rb index 298c7e4db3..ad17d1288b 100644 --- a/actionpack/test/controller/assert_select_test.rb +++ b/actionpack/test/controller/assert_select_test.rb @@ -66,12 +66,14 @@ class AssertSelectTest < ActionController::TestCase tests AssertSelectController def setup + super ActionMailer::Base.delivery_method = :test ActionMailer::Base.perform_deliveries = true ActionMailer::Base.deliveries = [] end def teardown + super ActionMailer::Base.deliveries.clear end diff --git a/actionpack/test/controller/base_test.rb b/actionpack/test/controller/base_test.rb index 9523189f41..f4517d06c4 100644 --- a/actionpack/test/controller/base_test.rb +++ b/actionpack/test/controller/base_test.rb @@ -170,6 +170,7 @@ class DefaultUrlOptionsTest < ActionController::TestCase tests DefaultUrlOptionsController def setup + super @request.host = 'www.example.com' rescue_action_in_public! end @@ -193,6 +194,7 @@ class EmptyUrlOptionsTest < ActionController::TestCase tests NonEmptyController def setup + super @request.host = 'www.example.com' rescue_action_in_public! end diff --git a/actionpack/test/controller/benchmark_test.rb b/actionpack/test/controller/benchmark_test.rb index f9100a2313..66ebfcf20a 100644 --- a/actionpack/test/controller/benchmark_test.rb +++ b/actionpack/test/controller/benchmark_test.rb @@ -20,6 +20,7 @@ class BenchmarkTest < ActionController::TestCase end def setup + super # benchmark doesn't do anything unless a logger is set @controller.logger = MockLogger.new @request.host = "test.actioncontroller.i" diff --git a/actionpack/test/controller/caching_test.rb b/actionpack/test/controller/caching_test.rb index 86dafd9221..b61a58dd09 100644 --- a/actionpack/test/controller/caching_test.rb +++ b/actionpack/test/controller/caching_test.rb @@ -44,6 +44,7 @@ end class PageCachingTest < ActionController::TestCase def setup + super ActionController::Base.perform_caching = true ActionController::Routing::Routes.draw do |map| @@ -222,6 +223,7 @@ end class ActionCacheTest < ActionController::TestCase def setup + super reset! FileUtils.mkdir_p(FILE_STORE_PATH) @path_class = ActionController::Caching::Actions::ActionCachePath @@ -483,6 +485,7 @@ end class FragmentCachingTest < ActionController::TestCase def setup + super ActionController::Base.perform_caching = true @store = ActiveSupport::Cache::MemoryStore.new ActionController::Base.cache_store = @store @@ -615,6 +618,7 @@ end class FunctionalFragmentCachingTest < ActionController::TestCase def setup + super ActionController::Base.perform_caching = true @store = ActiveSupport::Cache::MemoryStore.new ActionController::Base.cache_store = @store diff --git a/actionpack/test/controller/capture_test.rb b/actionpack/test/controller/capture_test.rb index 6dfa0995eb..9a0976ca9f 100644 --- a/actionpack/test/controller/capture_test.rb +++ b/actionpack/test/controller/capture_test.rb @@ -27,6 +27,7 @@ class CaptureTest < ActionController::TestCase tests CaptureController def setup + super # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get # a more accurate simulation of what happens in "real life". @controller.logger = Logger.new(nil) diff --git a/actionpack/test/controller/content_type_test.rb b/actionpack/test/controller/content_type_test.rb index 32c1757ef9..7377546631 100644 --- a/actionpack/test/controller/content_type_test.rb +++ b/actionpack/test/controller/content_type_test.rb @@ -54,6 +54,7 @@ class ContentTypeTest < ActionController::TestCase tests ContentTypeController def setup + super # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get # a more accurate simulation of what happens in "real life". @controller.logger = Logger.new(nil) @@ -136,10 +137,12 @@ class AcceptBasedContentTypeTest < ActionController::TestCase tests ContentTypeController def setup + super ActionController::Base.use_accept_header = true end def teardown + super ActionController::Base.use_accept_header = false end diff --git a/actionpack/test/controller/cookie_test.rb b/actionpack/test/controller/cookie_test.rb index f7d97e160a..c861982698 100644 --- a/actionpack/test/controller/cookie_test.rb +++ b/actionpack/test/controller/cookie_test.rb @@ -48,6 +48,7 @@ class CookieTest < ActionController::TestCase tests TestController def setup + super @request.host = "www.nextangle.com" end diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb index 7887b7110c..031a10975d 100644 --- a/actionpack/test/controller/dispatcher_test.rb +++ b/actionpack/test/controller/dispatcher_test.rb @@ -6,8 +6,8 @@ class DispatcherTest < Test::Unit::TestCase def setup ENV['REQUEST_METHOD'] = 'GET' - Dispatcher.middleware = ActionController::MiddlewareStack.new do |middleware| - middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/middlewares.rb")) + Dispatcher.middleware = ActionDispatch::MiddlewareStack.new do |middleware| + middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/dispatch/middlewares.rb")) middleware.instance_eval(File.read(middlewares)) end @@ -47,7 +47,7 @@ class DispatcherTest < Test::Unit::TestCase def test_failsafe_response Dispatcher.any_instance.expects(:dispatch).raises('b00m') - ActionController::Failsafe.any_instance.expects(:log_failsafe_exception) + ActionDispatch::Failsafe.any_instance.expects(:log_failsafe_exception) assert_nothing_raised do assert_equal [ diff --git a/actionpack/test/controller/header_test.rb b/actionpack/test/controller/header_test.rb deleted file mode 100644 index 33c14a187c..0000000000 --- a/actionpack/test/controller/header_test.rb +++ /dev/null @@ -1,14 +0,0 @@ -require 'abstract_unit' - -class HeaderTest < Test::Unit::TestCase - def setup - @headers = ActionController::Http::Headers.new("HTTP_CONTENT_TYPE"=>"text/plain") - end - - def test_content_type_works - assert_equal "text/plain", @headers["Content-Type"] - assert_equal "text/plain", @headers["content-type"] - assert_equal "text/plain", @headers["CONTENT_TYPE"] - assert_equal "text/plain", @headers["HTTP_CONTENT_TYPE"] - end -end diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb index 1575674e18..f2721e274d 100644 --- a/actionpack/test/controller/layout_test.rb +++ b/actionpack/test/controller/layout_test.rb @@ -37,6 +37,7 @@ end class LayoutAutoDiscoveryTest < ActionController::TestCase def setup + super @request.host = "www.nextangle.com" end @@ -55,7 +56,7 @@ class LayoutAutoDiscoveryTest < ActionController::TestCase def test_third_party_template_library_auto_discovers_layout @controller = ThirdPartyTemplateLibraryController.new get :hello - assert_equal 'layouts/third_party_template_library.mab', @controller.active_layout.to_s + assert_equal 'layouts/third_party_template_library.mab', @controller.active_layout(true).to_s assert_equal 'layouts/third_party_template_library', @response.layout assert_response :success assert_equal 'Mab', @response.body @@ -64,14 +65,14 @@ class LayoutAutoDiscoveryTest < ActionController::TestCase def test_namespaced_controllers_auto_detect_layouts @controller = ControllerNameSpace::NestedController.new get :hello - assert_equal 'layouts/controller_name_space/nested', @controller.active_layout.to_s + assert_equal 'layouts/controller_name_space/nested', @controller.active_layout(true).to_s assert_equal 'controller_name_space/nested.rhtml hello.rhtml', @response.body end def test_namespaced_controllers_auto_detect_layouts @controller = MultipleExtensions.new get :hello - assert_equal 'layouts/multiple_extensions.html.erb', @controller.active_layout.to_s + assert_equal 'layouts/multiple_extensions.html.erb', @controller.active_layout(true).to_s assert_equal 'multiple_extensions.html.erb hello.rhtml', @response.body.strip end end @@ -94,6 +95,14 @@ class PrependsViewPathController < LayoutTest end end +class OnlyLayoutController < LayoutTest + layout 'item', :only => "hello" +end + +class ExceptLayoutController < LayoutTest + layout 'item', :except => "goodbye" +end + class SetsLayoutInRenderController < LayoutTest def hello render :layout => 'third_party_template_library' @@ -118,6 +127,30 @@ class LayoutSetInResponseTest < ActionController::TestCase get :hello assert_equal 'layouts/item', @response.layout end + + def test_layout_only_exception_when_included + @controller = OnlyLayoutController.new + get :hello + assert_equal 'layouts/item', @response.layout + end + + def test_layout_only_exception_when_excepted + @controller = OnlyLayoutController.new + get :goodbye + assert_equal nil, @response.layout + end + + def test_layout_except_exception_when_included + @controller = ExceptLayoutController.new + get :hello + assert_equal 'layouts/item', @response.layout + end + + def test_layout_except_exception_when_excepted + @controller = ExceptLayoutController.new + get :goodbye + assert_equal nil, @response.layout + end def test_layout_set_when_using_render @controller = SetsLayoutInRenderController.new @@ -143,9 +176,11 @@ class LayoutSetInResponseTest < ActionController::TestCase end def test_layout_is_picked_from_the_controller_instances_view_path - @controller = PrependsViewPathController.new - get :hello - assert_equal 'layouts/alt', @response.layout + pending do + @controller = PrependsViewPathController.new + get :hello + assert_equal 'layouts/alt', @response.layout + end end def test_absolute_pathed_layout @@ -201,4 +236,3 @@ unless RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/ end end end - diff --git a/actionpack/test/controller/logging_test.rb b/actionpack/test/controller/logging_test.rb index 3c936854dd..1f3ff4ef52 100644 --- a/actionpack/test/controller/logging_test.rb +++ b/actionpack/test/controller/logging_test.rb @@ -18,7 +18,10 @@ class LoggingTest < ActionController::TestCase end end - setup :set_logger + def setup + super + set_logger + end def test_logging_without_parameters get :show diff --git a/actionpack/test/controller/mime_responds_test.rb b/actionpack/test/controller/mime_responds_test.rb index edd7162325..1c81989d9b 100644 --- a/actionpack/test/controller/mime_responds_test.rb +++ b/actionpack/test/controller/mime_responds_test.rb @@ -166,11 +166,13 @@ class MimeControllerTest < ActionController::TestCase tests RespondToController def setup + super ActionController::Base.use_accept_header = true @request.host = "www.example.com" end def teardown + super ActionController::Base.use_accept_header = false end @@ -437,7 +439,7 @@ class MimeControllerTest < ActionController::TestCase unless args.empty? @action = args.first[:action] end - response.body = "#{@action} - #{@template.template_format}" + response.body = "#{@action} - #{@template.formats}" end end @@ -511,6 +513,7 @@ class MimeControllerLayoutsTest < ActionController::TestCase tests PostController def setup + super @request.host = "www.example.com" end diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb index a52931565d..9a34bcebe6 100644 --- a/actionpack/test/controller/render_test.rb +++ b/actionpack/test/controller/render_test.rb @@ -315,13 +315,6 @@ class TestController < ActionController::Base def render_implicit_html_template_from_xhr_request end - def render_implicit_js_template_without_layout - end - - def render_html_explicit_template_and_layout - render :template => 'test/render_implicit_html_template_from_xhr_request', :layout => 'layouts/default_html' - end - def formatted_html_erb end @@ -390,7 +383,7 @@ class TestController < ActionController::Base end def accessing_params_in_template_with_layout - render :layout => nil, :inline => "Hello: <%= params[:name] %>" + render :layout => true, :inline => "Hello: <%= params[:name] %>" end def render_with_explicit_template @@ -737,8 +730,6 @@ class TestController < ActionController::Base "delete_with_js", "update_page", "update_page_with_instance_variables" "layouts/standard" - when "render_implicit_js_template_without_layout" - "layouts/default_html" when "action_talk_to_layout", "layout_overriding_layout" "layouts/talk_from_action" when "render_implicit_html_template_from_xhr_request" @@ -753,6 +744,7 @@ class RenderTest < ActionController::TestCase def setup # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get # a more accurate simulation of what happens in "real life". + super @controller.logger = Logger.new(nil) @request.host = "www.nextangle.com" @@ -836,11 +828,6 @@ class RenderTest < ActionController::TestCase assert_equal "<html>hello world, I'm here!</html>", @response.body end - def test_xhr_with_render_text_and_layout - xhr :get, :render_text_hello_world_with_layout - assert_equal "<html>hello world, I'm here!</html>", @response.body - end - def test_do_with_render_action_and_layout_false get :hello_world_with_layout_false assert_equal 'Hello world!', @response.body @@ -1081,18 +1068,17 @@ class RenderTest < ActionController::TestCase end def test_should_implicitly_render_html_template_from_xhr_request - xhr :get, :render_implicit_html_template_from_xhr_request - assert_equal "XHR!\nHello HTML!", @response.body - end - - def test_should_render_explicit_html_template_with_html_layout - xhr :get, :render_html_explicit_template_and_layout - assert_equal "<html>Hello HTML!</html>\n", @response.body + pending do + xhr :get, :render_implicit_html_template_from_xhr_request + assert_equal "XHR!\nHello HTML!", @response.body + end end def test_should_implicitly_render_js_template_without_layout - get :render_implicit_js_template_without_layout, :format => :js - assert_no_match /<html>/, @response.body + pending do + get :render_implicit_js_template_without_layout, :format => :js + assert_no_match %r{<html>}, @response.body + end end def test_should_render_formatted_template @@ -1308,7 +1294,7 @@ class RenderTest < ActionController::TestCase assert !@response.headers.include?('Content-Length') assert_response :no_content - ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE.each do |status, code| + ActionDispatch::StatusCodes::SYMBOL_TO_STATUS_CODE.each do |status, code| get :head_with_symbolic_status, :status => status.to_s assert_equal code, @response.response_code assert_response status @@ -1316,7 +1302,7 @@ class RenderTest < ActionController::TestCase end def test_head_with_integer_status - ActionController::StatusCodes::STATUS_CODES.each do |code, message| + ActionDispatch::StatusCodes::STATUS_CODES.each do |code, message| get :head_with_integer_status, :status => code.to_s assert_equal message, @response.message end @@ -1574,6 +1560,7 @@ class EtagRenderTest < ActionController::TestCase tests TestController def setup + super @request.host = "www.nextangle.com" @expected_bang_etag = etag_for(expand_key([:foo, 123])) end @@ -1684,6 +1671,7 @@ class LastModifiedRenderTest < ActionController::TestCase tests TestController def setup + super @request.host = "www.nextangle.com" @last_modified = Time.now.utc.beginning_of_day.httpdate end @@ -1739,6 +1727,7 @@ class RenderingLoggingTest < ActionController::TestCase tests TestController def setup + super @request.host = "www.nextangle.com" end @@ -1746,7 +1735,7 @@ class RenderingLoggingTest < ActionController::TestCase @controller.logger = MockLogger.new get :layout_test logged = @controller.logger.logged.find_all {|l| l =~ /render/i } - assert_equal "Rendering template within layouts/standard", logged[0] - assert_equal "Rendering test/hello_world", logged[1] + assert_equal "Rendering test/hello_world", logged[0] + assert_equal "Rendering template within layouts/standard", logged[1] end end diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb index 5709f37e05..741b01caa8 100644 --- a/actionpack/test/controller/rescue_test.rb +++ b/actionpack/test/controller/rescue_test.rb @@ -141,8 +141,11 @@ end class RescueControllerTest < ActionController::TestCase FIXTURE_PUBLIC = "#{File.dirname(__FILE__)}/../fixtures".freeze - setup :set_all_requests_local - setup :populate_exception_object + def setup + super + set_all_requests_local + populate_exception_object + end def set_all_requests_local RescueController.consider_all_requests_local = true @@ -409,7 +412,7 @@ class RescueControllerTest < ActionController::TestCase def test_rescue_dispatcher_exceptions_without_request_set @request.env['REQUEST_URI'] = '/no_way' response = RescueController.call_with_exception(@request.env, ActionController::RoutingError.new("Route not found")) - assert_kind_of ActionController::Response, response + assert_kind_of ActionDispatch::Response, response assert_equal "no way", response.body end diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb index 3d1904fee9..2e14a0a32c 100644 --- a/actionpack/test/controller/send_file_test.rb +++ b/actionpack/test/controller/send_file_test.rb @@ -155,7 +155,7 @@ class SendFileTest < ActionController::TestCase define_method "test_default_send_#{method}_status" do @controller.options = { :stream => false } assert_nothing_raised { assert_not_nil process(method) } - assert_equal ActionController::Base::DEFAULT_RENDER_STATUS_CODE, @response.status + assert_equal ActionController::DEFAULT_RENDER_STATUS_CODE, @response.status end end end diff --git a/actionpack/test/controller/session/cookie_store_test.rb b/actionpack/test/controller/session/cookie_store_test.rb index 40fcd56846..9b3f9afb0d 100644 --- a/actionpack/test/controller/session/cookie_store_test.rb +++ b/actionpack/test/controller/session/cookie_store_test.rb @@ -6,7 +6,8 @@ class CookieStoreTest < ActionController::IntegrationTest SessionSecret = 'b3c631c314c0bbca50c1b2843150fe33' DispatcherApp = ActionController::Dispatcher.new - CookieStoreApp = ActionController::Session::CookieStore.new(DispatcherApp, :key => SessionKey, :secret => SessionSecret) + CookieStoreApp = ActionDispatch::Session::CookieStore.new(DispatcherApp, + :key => SessionKey, :secret => SessionSecret) Verifier = ActiveSupport::MessageVerifier.new(SessionSecret, 'SHA1') @@ -53,41 +54,41 @@ class CookieStoreTest < ActionController::IntegrationTest def test_raises_argument_error_if_missing_session_key assert_raise(ArgumentError, nil.inspect) { - ActionController::Session::CookieStore.new(nil, + ActionDispatch::Session::CookieStore.new(nil, :key => nil, :secret => SessionSecret) } assert_raise(ArgumentError, ''.inspect) { - ActionController::Session::CookieStore.new(nil, + ActionDispatch::Session::CookieStore.new(nil, :key => '', :secret => SessionSecret) } end def test_raises_argument_error_if_missing_secret assert_raise(ArgumentError, nil.inspect) { - ActionController::Session::CookieStore.new(nil, + ActionDispatch::Session::CookieStore.new(nil, :key => SessionKey, :secret => nil) } assert_raise(ArgumentError, ''.inspect) { - ActionController::Session::CookieStore.new(nil, + ActionDispatch::Session::CookieStore.new(nil, :key => SessionKey, :secret => '') } end def test_raises_argument_error_if_secret_is_probably_insecure assert_raise(ArgumentError, "password".inspect) { - ActionController::Session::CookieStore.new(nil, + ActionDispatch::Session::CookieStore.new(nil, :key => SessionKey, :secret => "password") } assert_raise(ArgumentError, "secret".inspect) { - ActionController::Session::CookieStore.new(nil, + ActionDispatch::Session::CookieStore.new(nil, :key => SessionKey, :secret => "secret") } assert_raise(ArgumentError, "12345678901234567890123456789".inspect) { - ActionController::Session::CookieStore.new(nil, + ActionDispatch::Session::CookieStore.new(nil, :key => SessionKey, :secret => "12345678901234567890123456789") } end @@ -135,7 +136,7 @@ class CookieStoreTest < ActionController::IntegrationTest def test_close_raises_when_data_overflows with_test_route_set do - assert_raise(ActionController::Session::CookieStore::CookieOverflow) { + assert_raise(ActionDispatch::Session::CookieStore::CookieOverflow) { get '/raise_data_overflow' } end @@ -193,6 +194,38 @@ class CookieStoreTest < ActionController::IntegrationTest end end + def test_session_store_with_expire_after + app = ActionDispatch::Session::CookieStore.new(DispatcherApp, :key => SessionKey, :secret => SessionSecret, :expire_after => 5.hours) + @integration_session = open_session(app) + + with_test_route_set do + # First request accesses the session + time = Time.local(2008, 4, 24) + Time.stubs(:now).returns(time) + expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d-%b-%Y %H:%M:%S GMT") + + cookies[SessionKey] = SignedBar + + get '/set_session_value' + assert_response :success + + cookie_body = response.body + assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly", + headers['Set-Cookie'] + + # Second request does not access the session + time = Time.local(2008, 4, 25) + Time.stubs(:now).returns(time) + expected_expiry = (time + 5.hours).gmtime.strftime("%a, %d-%b-%Y %H:%M:%S GMT") + + get '/no_session_access' + assert_response :success + + assert_equal "_myapp_session=#{cookie_body}; path=/; expires=#{expected_expiry}; HttpOnly", + headers['Set-Cookie'] + end + end + private def with_test_route_set with_routing do |set| diff --git a/actionpack/test/controller/session/mem_cache_store_test.rb b/actionpack/test/controller/session/mem_cache_store_test.rb index 2f80a3c7c2..7561c93e4a 100644 --- a/actionpack/test/controller/session/mem_cache_store_test.rb +++ b/actionpack/test/controller/session/mem_cache_store_test.rb @@ -33,7 +33,7 @@ class MemCacheStoreTest < ActionController::IntegrationTest begin DispatcherApp = ActionController::Dispatcher.new - MemCacheStoreApp = ActionController::Session::MemCacheStore.new( + MemCacheStoreApp = ActionDispatch::Session::MemCacheStore.new( DispatcherApp, :key => '_session_id') diff --git a/actionpack/test/controller/test_test.rb b/actionpack/test/controller/test_test.rb index 3924b282d4..124e259ef6 100644 --- a/actionpack/test/controller/test_test.rb +++ b/actionpack/test/controller/test_test.rb @@ -119,6 +119,7 @@ XML end def setup + super @controller = TestController.new @request = ActionController::TestRequest.new @response = ActionController::TestResponse.new @@ -127,6 +128,7 @@ XML end def teardown + super ActionController::Routing::Routes.reload end @@ -643,7 +645,7 @@ class CleanBacktraceTest < ActionController::TestCase end def test_should_clean_assertion_lines_from_backtrace - path = File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller") + path = File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller/testing") exception = ActiveSupport::TestCase::Assertion.new('message') exception.set_backtrace ["#{path}/abc", "#{path}/assertions/def"] clean_backtrace { raise exception } diff --git a/actionpack/test/controller/view_paths_test.rb b/actionpack/test/controller/view_paths_test.rb index 8ea13fbe98..1539f8f506 100644 --- a/actionpack/test/controller/view_paths_test.rb +++ b/actionpack/test/controller/view_paths_test.rb @@ -29,8 +29,8 @@ class ViewLoadPathsTest < ActionController::TestCase @controller = TestController.new # Following is needed in order to setup @controller.template object properly - @controller.send :initialize_template_class, @response @controller.send :assign_shortcuts, @request, @response + @controller.send :initialize_template_class, @response # Track the last warning. @old_behavior = ActiveSupport::Deprecation.behavior @@ -41,7 +41,7 @@ class ViewLoadPathsTest < ActionController::TestCase def teardown ActiveSupport::Deprecation.behavior = @old_behavior end - + def test_template_load_path_was_set_correctly assert_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s) end diff --git a/actionpack/test/dispatch/header_test.rb b/actionpack/test/dispatch/header_test.rb new file mode 100644 index 0000000000..ec6ba494dc --- /dev/null +++ b/actionpack/test/dispatch/header_test.rb @@ -0,0 +1,16 @@ +require 'abstract_unit' + +class HeaderTest < ActiveSupport::TestCase + def setup + @headers = ActionDispatch::Http::Headers.new( + "HTTP_CONTENT_TYPE" => "text/plain" + ) + end + + test "content type" do + assert_equal "text/plain", @headers["Content-Type"] + assert_equal "text/plain", @headers["content-type"] + assert_equal "text/plain", @headers["CONTENT_TYPE"] + assert_equal "text/plain", @headers["HTTP_CONTENT_TYPE"] + end +end diff --git a/actionpack/test/controller/middleware_stack_test.rb b/actionpack/test/dispatch/middleware_stack_test.rb index 918231013a..f4e18308ae 100644 --- a/actionpack/test/controller/middleware_stack_test.rb +++ b/actionpack/test/dispatch/middleware_stack_test.rb @@ -6,7 +6,7 @@ class MiddlewareStackTest < ActiveSupport::TestCase class BazMiddleware; end def setup - @stack = ActionController::MiddlewareStack.new + @stack = ActionDispatch::MiddlewareStack.new @stack.use FooMiddleware @stack.use BarMiddleware end diff --git a/actionpack/test/controller/mime_type_test.rb b/actionpack/test/dispatch/mime_type_test.rb index c7faa621d9..2fdf4819bb 100644 --- a/actionpack/test/controller/mime_type_test.rb +++ b/actionpack/test/dispatch/mime_type_test.rb @@ -1,57 +1,60 @@ require 'abstract_unit' -class MimeTypeTest < Test::Unit::TestCase - Mime::Type.register "image/png", :png - Mime::Type.register "application/pdf", :pdf +class MimeTypeTest < ActiveSupport::TestCase + Mime::Type.register "image/png", :png unless defined? Mime::PNG + Mime::Type.register "application/pdf", :pdf unless defined? Mime::PDF - def test_parse_single + test "parse single" do Mime::LOOKUP.keys.each do |mime_type| assert_equal [Mime::Type.lookup(mime_type)], Mime::Type.parse(mime_type) end end - def test_parse_without_q + test "parse without q" do accept = "text/xml,application/xhtml+xml,text/yaml,application/xml,text/html,image/png,text/plain,application/pdf,*/*" expect = [Mime::HTML, Mime::XML, Mime::YAML, Mime::PNG, Mime::TEXT, Mime::PDF, Mime::ALL] assert_equal expect, Mime::Type.parse(accept) end - def test_parse_with_q + test "parse with q" do accept = "text/xml,application/xhtml+xml,text/yaml; q=0.3,application/xml,text/html; q=0.8,image/png,text/plain; q=0.5,application/pdf,*/*; q=0.2" expect = [Mime::HTML, Mime::XML, Mime::PNG, Mime::PDF, Mime::TEXT, Mime::YAML, Mime::ALL] assert_equal expect, Mime::Type.parse(accept) end - + # Accept header send with user HTTP_USER_AGENT: Sunrise/0.42j (Windows XP) - def test_parse_crappy_broken_acceptlines + test "parse crappy broken acceptlines" do accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/*,,*/*;q=0.5" expect = [Mime::HTML, Mime::XML, "image/*", Mime::TEXT, Mime::ALL] assert_equal expect, Mime::Type.parse(accept).collect { |c| c.to_s } end - # Accept header send with user HTTP_USER_AGENT: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; InfoPath.1) - def test_parse_crappy_broken_acceptlines2 + # Accept header send with user HTTP_USER_AGENT: Mozilla/4.0 + # (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; InfoPath.1) + test "parse crappy broken acceptlines2" do accept = "image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, , pronto/1.00.00, sslvpn/1.00.00.00, */*" expect = ['image/gif', 'image/x-xbitmap', 'image/jpeg','image/pjpeg', 'application/x-shockwave-flash', 'application/vnd.ms-excel', 'application/vnd.ms-powerpoint', 'application/msword', 'pronto/1.00.00', 'sslvpn/1.00.00.00', Mime::ALL ] assert_equal expect, Mime::Type.parse(accept).collect { |c| c.to_s } end - - def test_custom_type - Mime::Type.register("image/gif", :gif) - assert_nothing_raised do - Mime::GIF - assert_equal Mime::GIF, Mime::SET.last + + test "custom type" do + begin + Mime::Type.register("image/gif", :gif) + assert_nothing_raised do + Mime::GIF + assert_equal Mime::GIF, Mime::SET.last + end + ensure + Mime.module_eval { remove_const :GIF if const_defined?(:GIF) } end - ensure - Mime.module_eval { remove_const :GIF if const_defined?(:GIF) } end - - def test_type_should_be_equal_to_symbol + + test "type should be equal to symbol" do assert_equal Mime::HTML, 'application/xhtml+xml' assert_equal Mime::HTML, :html end - def test_type_convenience_methods + test "type convenience methods" do # Don't test Mime::ALL, since it Mime::ALL#html? == true types = Mime::SET.to_a.map(&:to_sym).uniq - [:all] @@ -67,12 +70,12 @@ class MimeTypeTest < Test::Unit::TestCase end end - def test_mime_all_is_html + test "mime all is html" do assert Mime::ALL.all?, "Mime::ALL is not all?" assert Mime::ALL.html?, "Mime::ALL is not html?" end - def test_verifiable_mime_types + test "verifiable mime types" do all_types = Mime::SET.to_a.map(&:to_sym) all_types.uniq! # Remove custom Mime::Type instances set in other tests, like Mime::GIF and Mime::IPHONE @@ -82,7 +85,7 @@ class MimeTypeTest < Test::Unit::TestCase assert unverified.each { |type| assert !Mime.const_get(type.to_s.upcase).verify_request?, "Nonverifiable Mime Type is verified: #{type.inspect}" } end - def test_regexp_matcher + test "regexp matcher" do assert Mime::JS =~ "text/javascript" assert Mime::JS =~ "application/javascript" assert Mime::JS !~ "text/html" diff --git a/actionpack/test/controller/rack_test.rb b/actionpack/test/dispatch/rack_test.rb index 89bf4fdacc..9fad4b22ee 100644 --- a/actionpack/test/controller/rack_test.rb +++ b/actionpack/test/dispatch/rack_test.rb @@ -1,6 +1,8 @@ require 'abstract_unit' -class BaseRackTest < Test::Unit::TestCase +# TODO: Merge these tests into RequestTest + +class BaseRackTest < ActiveSupport::TestCase def setup @env = { "HTTP_MAX_FORWARDS" => "10", @@ -43,30 +45,27 @@ class BaseRackTest < Test::Unit::TestCase "REDIRECT_STATUS" => "200", "REQUEST_METHOD" => "GET" } - @request = ActionController::Request.new(@env) + @request = ActionDispatch::Request.new(@env) # some Nokia phone browsers omit the space after the semicolon separator. # some developers have grown accustomed to using comma in cookie values. - @alt_cookie_fmt_request = ActionController::Request.new(@env.merge({"HTTP_COOKIE"=>"_session_id=c84ace847,96670c052c6ceb2451fb0f2;is_admin=yes"})) + @alt_cookie_fmt_request = ActionDispatch::Request.new(@env.merge({"HTTP_COOKIE"=>"_session_id=c84ace847,96670c052c6ceb2451fb0f2;is_admin=yes"})) end - def default_test; end - private - - def set_content_data(data) - @request.env['REQUEST_METHOD'] = 'POST' - @request.env['CONTENT_LENGTH'] = data.length - @request.env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8' - @request.env['rack.input'] = StringIO.new(data) - end + def set_content_data(data) + @request.env['REQUEST_METHOD'] = 'POST' + @request.env['CONTENT_LENGTH'] = data.length + @request.env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8' + @request.env['rack.input'] = StringIO.new(data) + end end class RackRequestTest < BaseRackTest - def test_proxy_request + test "proxy request" do assert_equal 'glu.ttono.us', @request.host_with_port end - def test_http_host + test "http host" do @env.delete "HTTP_X_FORWARDED_HOST" @env['HTTP_HOST'] = "rubyonrails.org:8080" assert_equal "rubyonrails.org", @request.host @@ -76,19 +75,19 @@ class RackRequestTest < BaseRackTest assert_equal "www.secondhost.org", @request.host end - def test_http_host_with_default_port_overrides_server_port + test "http host with default port overrides server port" do @env.delete "HTTP_X_FORWARDED_HOST" @env['HTTP_HOST'] = "rubyonrails.org" assert_equal "rubyonrails.org", @request.host_with_port end - def test_host_with_port_defaults_to_server_name_if_no_host_headers + test "host with port defaults to server name if no host headers" do @env.delete "HTTP_X_FORWARDED_HOST" @env.delete "HTTP_HOST" assert_equal "glu.ttono.us:8007", @request.host_with_port end - def test_host_with_port_falls_back_to_server_addr_if_necessary + test "host with port falls back to server addr if necessary" do @env.delete "HTTP_X_FORWARDED_HOST" @env.delete "HTTP_HOST" @env.delete "SERVER_NAME" @@ -97,30 +96,30 @@ class RackRequestTest < BaseRackTest assert_equal "207.7.108.53:8007", @request.host_with_port end - def test_host_with_port_if_http_standard_port_is_specified + test "host with port if http standard port is specified" do @env['HTTP_X_FORWARDED_HOST'] = "glu.ttono.us:80" assert_equal "glu.ttono.us", @request.host_with_port end - def test_host_with_port_if_https_standard_port_is_specified + test "host with port if https standard port is specified" do @env['HTTP_X_FORWARDED_PROTO'] = "https" @env['HTTP_X_FORWARDED_HOST'] = "glu.ttono.us:443" assert_equal "glu.ttono.us", @request.host_with_port end - def test_host_if_ipv6_reference + test "host if ipv6 reference" do @env.delete "HTTP_X_FORWARDED_HOST" @env['HTTP_HOST'] = "[2001:1234:5678:9abc:def0::dead:beef]" assert_equal "[2001:1234:5678:9abc:def0::dead:beef]", @request.host end - def test_host_if_ipv6_reference_with_port + test "host if ipv6 reference with port" do @env.delete "HTTP_X_FORWARDED_HOST" @env['HTTP_HOST'] = "[2001:1234:5678:9abc:def0::dead:beef]:8008" assert_equal "[2001:1234:5678:9abc:def0::dead:beef]", @request.host end - def test_cgi_environment_variables + test "cgi environment variables" do assert_equal "Basic", @request.auth_type assert_equal 0, @request.content_length assert_equal nil, @request.content_type @@ -151,7 +150,7 @@ class RackRequestTest < BaseRackTest assert_equal "lighttpd", @request.server_software end - def test_cookie_syntax_resilience + test "cookie syntax resilience" do cookies = @request.cookies assert_equal "c84ace84796670c052c6ceb2451fb0f2", cookies["_session_id"], cookies.inspect assert_equal "yes", cookies["is_admin"], cookies.inspect @@ -163,39 +162,39 @@ class RackRequestTest < BaseRackTest end class RackRequestParamsParsingTest < BaseRackTest - def test_doesnt_break_when_content_type_has_charset + test "doesnt break when content type has charset" do set_content_data 'flamenco=love' assert_equal({"flamenco"=> "love"}, @request.request_parameters) end - def test_doesnt_interpret_request_uri_as_query_string_when_missing + test "doesnt interpret request uri as query string when missing" do @request.env['REQUEST_URI'] = 'foo' assert_equal({}, @request.query_parameters) end end class RackRequestContentTypeTest < BaseRackTest - def test_html_content_type_verification + test "html content type verification" do @request.env['CONTENT_TYPE'] = Mime::HTML.to_s assert @request.content_type.verify_request? end - def test_xml_content_type_verification + test "xml content type verification" do @request.env['CONTENT_TYPE'] = Mime::XML.to_s assert !@request.content_type.verify_request? end end class RackRequestNeedsRewoundTest < BaseRackTest - def test_body_should_be_rewound + test "body should be rewound" do data = 'foo' @env['rack.input'] = StringIO.new(data) @env['CONTENT_LENGTH'] = data.length @env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded; charset=utf-8' # Read the request body by parsing params. - request = ActionController::Request.new(@env) + request = ActionDispatch::Request.new(@env) request.request_parameters # Should have rewound the body. @@ -206,10 +205,10 @@ end class RackResponseTest < BaseRackTest def setup super - @response = ActionController::Response.new + @response = ActionDispatch::Response.new end - def test_simple_output + test "simple output" do @response.body = "Hello, World!" @response.prepare! @@ -266,11 +265,11 @@ end class RackResponseHeadersTest < BaseRackTest def setup super - @response = ActionController::Response.new + @response = ActionDispatch::Response.new @response.status = "200 OK" end - def test_content_type + test "content type" do [204, 304].each do |c| @response.status = c.to_s assert !response_headers.has_key?("Content-Type"), "#{c} should not have Content-Type header" @@ -282,7 +281,7 @@ class RackResponseHeadersTest < BaseRackTest end end - def test_status + test "status" do assert !response_headers.has_key?('Status') end diff --git a/actionpack/test/controller/request/json_params_parsing_test.rb b/actionpack/test/dispatch/request/json_params_parsing_test.rb index a3dde72c4e..a3dde72c4e 100644 --- a/actionpack/test/controller/request/json_params_parsing_test.rb +++ b/actionpack/test/dispatch/request/json_params_parsing_test.rb diff --git a/actionpack/test/controller/request/multipart_params_parsing_test.rb b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb index b812072ef4..2f409f020d 100644 --- a/actionpack/test/controller/request/multipart_params_parsing_test.rb +++ b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb @@ -215,7 +215,7 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest def with_muck_middleware original_middleware = ActionController::Dispatcher.middleware middleware = original_middleware.dup - middleware.insert_after ActionController::RewindableInput, MuckMiddleware + middleware.insert_after ActionDispatch::RewindableInput, MuckMiddleware ActionController::Dispatcher.middleware = middleware yield ActionController::Dispatcher.middleware = original_middleware diff --git a/actionpack/test/controller/request/query_string_parsing_test.rb b/actionpack/test/dispatch/request/query_string_parsing_test.rb index a31e326ddf..a31e326ddf 100644 --- a/actionpack/test/controller/request/query_string_parsing_test.rb +++ b/actionpack/test/dispatch/request/query_string_parsing_test.rb diff --git a/actionpack/test/controller/request/url_encoded_params_parsing_test.rb b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb index 7e6099a041..51a660f614 100644 --- a/actionpack/test/controller/request/url_encoded_params_parsing_test.rb +++ b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb @@ -159,7 +159,7 @@ class UrlEncodedParamsParsingTest < ActionController::IntegrationTest def with_muck_middleware original_middleware = ActionController::Dispatcher.middleware middleware = original_middleware.dup - middleware.insert_after ActionController::RewindableInput, MuckMiddleware + middleware.insert_after ActionDispatch::RewindableInput, MuckMiddleware ActionController::Dispatcher.middleware = middleware yield ActionController::Dispatcher.middleware = original_middleware diff --git a/actionpack/test/controller/request/xml_params_parsing_test.rb b/actionpack/test/dispatch/request/xml_params_parsing_test.rb index ee764e726e..ee764e726e 100644 --- a/actionpack/test/controller/request/xml_params_parsing_test.rb +++ b/actionpack/test/dispatch/request/xml_params_parsing_test.rb diff --git a/actionpack/test/controller/request_test.rb b/actionpack/test/dispatch/request_test.rb index c4cc63e628..d57a2a611f 100644 --- a/actionpack/test/controller/request_test.rb +++ b/actionpack/test/dispatch/request_test.rb @@ -9,7 +9,7 @@ class RequestTest < ActiveSupport::TestCase ActionController::Base.relative_url_root = nil end - def test_remote_ip + test "remote ip" do request = stub_request 'REMOTE_ADDR' => '1.2.3.4' assert_equal '1.2.3.4', request.remote_ip @@ -72,7 +72,7 @@ class RequestTest < ActiveSupport::TestCase assert_equal '9.9.9.9', request.remote_ip end - def test_domains + test "domains" do request = stub_request 'HTTP_HOST' => 'www.rubyonrails.org' assert_equal "rubyonrails.org", request.domain @@ -89,7 +89,7 @@ class RequestTest < ActiveSupport::TestCase assert_equal "200.com", request.domain end - def test_subdomains + test "subdomains" do request = stub_request 'HTTP_HOST' => "www.rubyonrails.org" assert_equal %w( www ), request.subdomains @@ -115,7 +115,7 @@ class RequestTest < ActiveSupport::TestCase assert_equal [], request.subdomains end - def test_port_string + test "port string" do request = stub_request 'HTTP_HOST' => 'www.example.org:80' assert_equal "", request.port_string @@ -123,7 +123,7 @@ class RequestTest < ActiveSupport::TestCase assert_equal ":8080", request.port_string end - def test_request_uri + test "request uri" do request = stub_request 'REQUEST_URI' => "http://www.rubyonrails.org/path/of/some/uri?mapped=1" assert_equal "/path/of/some/uri?mapped=1", request.request_uri assert_equal "/path/of/some/uri", request.path @@ -223,17 +223,18 @@ class RequestTest < ActiveSupport::TestCase assert_equal "/some/path", request.path end - def test_host_with_default_port + + test "host with default port" do request = stub_request 'HTTP_HOST' => 'rubyonrails.org:80' assert_equal "rubyonrails.org", request.host_with_port end - def test_host_with_non_default_port + test "host with non default port" do request = stub_request 'HTTP_HOST' => 'rubyonrails.org:81' assert_equal "rubyonrails.org:81", request.host_with_port end - def test_server_software + test "server software" do request = stub_request assert_equal nil, request.server_software @@ -244,7 +245,7 @@ class RequestTest < ActiveSupport::TestCase assert_equal 'lighttpd', request.server_software end - def test_xml_http_request + test "xml http request" do request = stub_request assert !request.xml_http_request? @@ -259,7 +260,7 @@ class RequestTest < ActiveSupport::TestCase assert request.xhr? end - def test_reports_ssl + test "reports ssl" do request = stub_request assert !request.ssl? @@ -267,7 +268,7 @@ class RequestTest < ActiveSupport::TestCase assert request.ssl? end - def test_reports_ssl_when_proxied_via_lighttpd + test "reports ssl when proxied via lighttpd" do request = stub_request assert !request.ssl? @@ -275,28 +276,35 @@ class RequestTest < ActiveSupport::TestCase assert request.ssl? end - def test_symbolized_request_methods + test "symbolized request methods" do [:get, :post, :put, :delete].each do |method| request = stub_request 'REQUEST_METHOD' => method.to_s.upcase assert_equal method, request.method end end - def test_invalid_http_method_raises_exception + test "invalid http method raises exception" do assert_raise(ActionController::UnknownHttpMethod) do request = stub_request 'REQUEST_METHOD' => 'RANDOM_METHOD' request.request_method end end - def test_allow_method_hacking_on_post + test "allow method hacking on post" do [:get, :head, :options, :put, :post, :delete].each do |method| - request = stub_request 'REQUEST_METHOD' => method.to_s.upcase + request = stub_request "REQUEST_METHOD" => method.to_s.upcase assert_equal(method == :head ? :get : method, request.method) end end - def test_restrict_method_hacking + test "invalid method hacking on post raises exception" do + assert_raise(ActionController::UnknownHttpMethod) do + request = stub_request "REQUEST_METHOD" => "_RANDOM_METHOD" + request.request_method + end + end + + test "restrict method hacking" do [:get, :put, :delete].each do |method| request = stub_request 'REQUEST_METHOD' => method.to_s.upcase, 'action_controller.request.request_parameters' => { :_method => 'put' } @@ -304,49 +312,51 @@ class RequestTest < ActiveSupport::TestCase end end - def test_head_masquerading_as_get + test "head masquerading as get" do request = stub_request 'REQUEST_METHOD' => 'HEAD' assert_equal :get, request.method assert request.get? assert request.head? end - def test_xml_format + test "xml format" do request = stub_request request.expects(:parameters).at_least_once.returns({ :format => 'xml' }) assert_equal Mime::XML, request.format end - def test_xhtml_format + test "xhtml format" do request = stub_request request.expects(:parameters).at_least_once.returns({ :format => 'xhtml' }) assert_equal Mime::HTML, request.format end - def test_txt_format + test "txt format" do request = stub_request request.expects(:parameters).at_least_once.returns({ :format => 'txt' }) assert_equal Mime::TEXT, request.format end - def test_xml_http_request - ActionController::Base.use_accept_header, old = - false, ActionController::Base.use_accept_header - - request = stub_request 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest' - request.expects(:parameters).at_least_once.returns({}) - assert request.xhr? - assert_equal Mime::JS, request.format - ensure - ActionController::Base.use_accept_header = old + test "XMLHttpRequest" do + begin + ActionController::Base.use_accept_header, old = + false, ActionController::Base.use_accept_header + + request = stub_request 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest' + request.expects(:parameters).at_least_once.returns({}) + assert request.xhr? + assert_equal Mime::JS, request.format + ensure + ActionController::Base.use_accept_header = old + end end - def test_content_type + test "content type" do request = stub_request 'CONTENT_TYPE' => 'text/html' assert_equal Mime::HTML, request.content_type end - def test_can_override_format_with_parameter + test "can override format with parameter" do request = stub_request request.expects(:parameters).at_least_once.returns({ :format => :txt }) assert !request.format.xml? @@ -356,27 +366,27 @@ class RequestTest < ActiveSupport::TestCase assert request.format.xml? end - def test_content_no_type + test "no content type" do request = stub_request assert_equal nil, request.content_type end - def test_content_type_xml + test "content type is XML" do request = stub_request 'CONTENT_TYPE' => 'application/xml' assert_equal Mime::XML, request.content_type end - def test_content_type_with_charset + test "content type with charset" do request = stub_request 'CONTENT_TYPE' => 'application/xml; charset=UTF-8' assert_equal Mime::XML, request.content_type end - def test_user_agent + test "user agent" do request = stub_request 'HTTP_USER_AGENT' => 'TestAgent' assert_equal 'TestAgent', request.user_agent end - def test_parameters + test "parameters" do request = stub_request request.stubs(:request_parameters).returns({ "foo" => 1 }) request.stubs(:query_parameters).returns({ "bar" => 2 }) @@ -389,7 +399,7 @@ class RequestTest < ActiveSupport::TestCase protected def stub_request(env={}) - ActionController::Request.new(env) + ActionDispatch::Request.new(env) end end diff --git a/actionpack/test/fixtures/happy_path/render_action/hello_world.erb b/actionpack/test/fixtures/happy_path/render_action/hello_world.erb new file mode 100644 index 0000000000..6769dd60bd --- /dev/null +++ b/actionpack/test/fixtures/happy_path/render_action/hello_world.erb @@ -0,0 +1 @@ +Hello world!
\ No newline at end of file diff --git a/actionpack/test/fixtures/layout_tests/views/goodbye.rhtml b/actionpack/test/fixtures/layout_tests/views/goodbye.rhtml new file mode 100644 index 0000000000..bbccf0913e --- /dev/null +++ b/actionpack/test/fixtures/layout_tests/views/goodbye.rhtml @@ -0,0 +1 @@ +hello.rhtml
\ No newline at end of file diff --git a/actionpack/test/fixtures/layouts/default_html.html.erb b/actionpack/test/fixtures/layouts/default_html.html.erb deleted file mode 100644 index edd719111c..0000000000 --- a/actionpack/test/fixtures/layouts/default_html.html.erb +++ /dev/null @@ -1 +0,0 @@ -<html><%= @content_for_layout %></html> diff --git a/actionpack/test/fixtures/test/backup_files/item.html.erb b/actionpack/test/fixtures/test/backup_files/item.html.erb deleted file mode 100644 index aaac0a2160..0000000000 --- a/actionpack/test/fixtures/test/backup_files/item.html.erb +++ /dev/null @@ -1 +0,0 @@ -The correct item.erb was loaded. diff --git a/actionpack/test/fixtures/test/backup_files/item.html.erb.orig b/actionpack/test/fixtures/test/backup_files/item.html.erb.orig deleted file mode 100644 index a2b153e5a2..0000000000 --- a/actionpack/test/fixtures/test/backup_files/item.html.erb.orig +++ /dev/null @@ -1 +0,0 @@ -This is an editor backup file and should never be loaded! diff --git a/actionpack/test/fixtures/test/basic.html.erb b/actionpack/test/fixtures/test/basic.html.erb new file mode 100644 index 0000000000..ea696d7e01 --- /dev/null +++ b/actionpack/test/fixtures/test/basic.html.erb @@ -0,0 +1 @@ +Hello from basic.html.erb
\ No newline at end of file diff --git a/actionpack/test/fixtures/test/render_implicit_js_template_without_layout.js.erb b/actionpack/test/fixtures/test/render_implicit_js_template_without_layout.js.erb deleted file mode 100644 index d5b94af505..0000000000 --- a/actionpack/test/fixtures/test/render_implicit_js_template_without_layout.js.erb +++ /dev/null @@ -1 +0,0 @@ -alert('hello'); diff --git a/actionpack/test/lib/fixture_template.rb b/actionpack/test/lib/fixture_template.rb new file mode 100644 index 0000000000..26f6ec2d0c --- /dev/null +++ b/actionpack/test/lib/fixture_template.rb @@ -0,0 +1,35 @@ +module ActionView #:nodoc: + class FixtureTemplate < Template + class FixturePath < Template::Path + def initialize(hash = {}) + @hash = {} + + hash.each do |k, v| + @hash[k.sub(/\.\w+$/, '')] = FixtureTemplate.new(v, k.split("/").last, self) + end + + super("fixtures://root") + end + + def find_template(path) + @hash[path] + end + end + + def initialize(body, *args) + @body = body + super(*args) + end + + def source + @body + end + + private + + def find_full_path(path, load_paths) + return '/', path + end + + end +end
\ No newline at end of file diff --git a/actionpack/test/new_base/base_test.rb b/actionpack/test/new_base/base_test.rb new file mode 100644 index 0000000000..4f46cb6492 --- /dev/null +++ b/actionpack/test/new_base/base_test.rb @@ -0,0 +1,90 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +# Tests the controller dispatching happy path +module HappyPath + class SimpleDispatchController < ActionController::Base2 + def index + render :text => "success" + end + + def modify_response_body + self.response_body = "success" + end + + def modify_response_body_twice + ret = (self.response_body = "success") + self.response_body = "#{ret}!" + end + + def modify_response_headers + + end + end + + class TestSimpleDispatch < SimpleRouteCase + + get "/happy_path/simple_dispatch/index" + + test "sets the body" do + assert_body "success" + end + + test "sets the status code" do + assert_status 200 + end + + test "sets the content type" do + assert_content_type Mime::HTML + end + + test "sets the content length" do + assert_header "Content-Length", 7 + end + + end + + # :api: plugin + class TestDirectResponseMod < SimpleRouteCase + get "/happy_path/simple_dispatch/modify_response_body" + + test "sets the body" do + assert_body "success" + end + + test "setting the body manually sets the content length" do + assert_header "Content-Length", 7 + end + end + + # :api: plugin + class TestDirectResponseModTwice < SimpleRouteCase + get "/happy_path/simple_dispatch/modify_response_body_twice" + + test "self.response_body= returns the body being set" do + assert_body "success!" + end + + test "updating the response body updates the content length" do + assert_header "Content-Length", 8 + end + end +end + + +class EmptyController < ActionController::Base2 ; end +module Submodule + class ContainedEmptyController < ActionController::Base2 ; end +end + +class ControllerClassTests < Test::Unit::TestCase + def test_controller_path + assert_equal 'empty', EmptyController.controller_path + assert_equal EmptyController.controller_path, EmptyController.new.controller_path + assert_equal 'submodule/contained_empty', Submodule::ContainedEmptyController.controller_path + assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path + end + def test_controller_name + assert_equal 'empty', EmptyController.controller_name + assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name + end +end
\ No newline at end of file diff --git a/actionpack/test/new_base/render_action_test.rb b/actionpack/test/new_base/render_action_test.rb new file mode 100644 index 0000000000..2bfb374a31 --- /dev/null +++ b/actionpack/test/new_base/render_action_test.rb @@ -0,0 +1,325 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module RenderAction + + # This has no layout and it works + class BasicController < ActionController::Base2 + + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "render_action/basic/hello_world.html.erb" => "Hello world!" + )] + + def hello_world + render :action => "hello_world" + end + + def hello_world_as_string + render "hello_world" + end + + def hello_world_as_string_with_options + render "hello_world", :status => 404 + end + + def hello_world_as_symbol + render :hello_world + end + + def hello_world_with_symbol + render :action => :hello_world + end + + def hello_world_with_layout + render :action => "hello_world", :layout => true + end + + def hello_world_with_layout_false + render :action => "hello_world", :layout => false + end + + def hello_world_with_layout_nil + render :action => "hello_world", :layout => nil + end + + def hello_world_with_custom_layout + render :action => "hello_world", :layout => "greetings" + end + + end + + class TestBasic < SimpleRouteCase + describe "Rendering an action using :action => <String>" + + get "/render_action/basic/hello_world" + assert_body "Hello world!" + assert_status 200 + end + + class TestWithString < SimpleRouteCase + describe "Render an action using 'hello_world'" + + get "/render_action/basic/hello_world_as_string" + assert_body "Hello world!" + assert_status 200 + end + + class TestWithStringAndOptions < SimpleRouteCase + describe "Render an action using 'hello_world'" + + get "/render_action/basic/hello_world_as_string_with_options" + assert_body "Hello world!" + assert_status 404 + end + + class TestAsSymbol < SimpleRouteCase + describe "Render an action using :hello_world" + + get "/render_action/basic/hello_world_as_symbol" + assert_body "Hello world!" + assert_status 200 + end + + class TestWithSymbol < SimpleRouteCase + describe "Render an action using :action => :hello_world" + + get "/render_action/basic/hello_world_with_symbol" + assert_body "Hello world!" + assert_status 200 + end + + class TestLayoutTrue < SimpleRouteCase + describe "rendering a normal template with full path with layout => true" + + test "raises an exception when requesting a layout and none exist" do + assert_raise(ArgumentError, /no default layout for RenderAction::BasicController in/) do + get "/render_action/basic/hello_world_with_layout" + end + end + end + + class TestLayoutFalse < SimpleRouteCase + describe "rendering a normal template with full path with layout => false" + + get "/render_action/basic/hello_world_with_layout_false" + assert_body "Hello world!" + assert_status 200 + end + + class TestLayoutNil < SimpleRouteCase + describe "rendering a normal template with full path with layout => :nil" + + get "/render_action/basic/hello_world_with_layout_nil" + assert_body "Hello world!" + assert_status 200 + end + + class TestCustomLayout < SimpleRouteCase + describe "rendering a normal template with full path with layout => 'greetings'" + + test "raises an exception when requesting a layout that does not exist" do + assert_raise(ActionView::MissingTemplate) { get "/render_action/basic/hello_world_with_custom_layout" } + end + end + +end + +module RenderActionWithApplicationLayout + + # # ==== Render actions with layouts ==== + + class BasicController < ::ApplicationController + # Set the view path to an application view structure with layouts + self.view_paths = self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "render_action_with_application_layout/basic/hello_world.html.erb" => "Hello World!", + "layouts/application.html.erb" => "OHAI <%= yield %> KTHXBAI", + "layouts/greetings.html.erb" => "Greetings <%= yield %> Bai" + )] + + def hello_world + render :action => "hello_world" + end + + def hello_world_with_layout + render :action => "hello_world", :layout => true + end + + def hello_world_with_layout_false + render :action => "hello_world", :layout => false + end + + def hello_world_with_layout_nil + render :action => "hello_world", :layout => nil + end + + def hello_world_with_custom_layout + render :action => "hello_world", :layout => "greetings" + end + end + + class TestDefaultLayout < SimpleRouteCase + describe %( + Render hello_world and implicitly use application.html.erb as a layout if + no layout is specified and no controller layout is present + ) + + get "/render_action_with_application_layout/basic/hello_world" + assert_body "OHAI Hello World! KTHXBAI" + assert_status 200 + end + + class TestLayoutTrue < SimpleRouteCase + describe "rendering a normal template with full path with layout => true" + + get "/render_action_with_application_layout/basic/hello_world_with_layout" + assert_body "OHAI Hello World! KTHXBAI" + assert_status 200 + end + + class TestLayoutFalse < SimpleRouteCase + describe "rendering a normal template with full path with layout => false" + + get "/render_action_with_application_layout/basic/hello_world_with_layout_false" + assert_body "Hello World!" + assert_status 200 + end + + class TestLayoutNil < SimpleRouteCase + describe "rendering a normal template with full path with layout => :nil" + + get "/render_action_with_application_layout/basic/hello_world_with_layout_nil" + assert_body "Hello World!" + assert_status 200 + end + + class TestCustomLayout < SimpleRouteCase + describe "rendering a normal template with full path with layout => 'greetings'" + + get "/render_action_with_application_layout/basic/hello_world_with_custom_layout" + assert_body "Greetings Hello World! Bai" + assert_status 200 + end + +end + +module RenderActionWithControllerLayout + + class BasicController < ActionController::Base2 + self.view_paths = self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "render_action_with_controller_layout/basic/hello_world.html.erb" => "Hello World!", + "layouts/render_action_with_controller_layout/basic.html.erb" => "With Controller Layout! <%= yield %> KTHXBAI" + )] + + def hello_world + render :action => "hello_world" + end + + def hello_world_with_layout + render :action => "hello_world", :layout => true + end + + def hello_world_with_layout_false + render :action => "hello_world", :layout => false + end + + def hello_world_with_layout_nil + render :action => "hello_world", :layout => nil + end + + def hello_world_with_custom_layout + render :action => "hello_world", :layout => "greetings" + end + end + + class TestControllerLayout < SimpleRouteCase + describe "Render hello_world and implicitly use <controller_path>.html.erb as a layout." + + get "/render_action_with_controller_layout/basic/hello_world" + assert_body "With Controller Layout! Hello World! KTHXBAI" + assert_status 200 + end + + class TestLayoutTrue < SimpleRouteCase + describe "rendering a normal template with full path with layout => true" + + get "/render_action_with_controller_layout/basic/hello_world_with_layout" + assert_body "With Controller Layout! Hello World! KTHXBAI" + assert_status 200 + end + + class TestLayoutFalse < SimpleRouteCase + describe "rendering a normal template with full path with layout => false" + + get "/render_action_with_controller_layout/basic/hello_world_with_layout_false" + assert_body "Hello World!" + assert_status 200 + end + + class TestLayoutNil < SimpleRouteCase + describe "rendering a normal template with full path with layout => :nil" + + get "/render_action_with_controller_layout/basic/hello_world_with_layout_nil" + assert_body "Hello World!" + assert_status 200 + end + +end + +module RenderActionWithBothLayouts + + class BasicController < ActionController::Base2 + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new({ + "render_action_with_both_layouts/basic/hello_world.html.erb" => "Hello World!", + "layouts/application.html.erb" => "OHAI <%= yield %> KTHXBAI", + "layouts/render_action_with_both_layouts/basic.html.erb" => "With Controller Layout! <%= yield %> KTHXBAI" + })] + + def hello_world + render :action => "hello_world" + end + + def hello_world_with_layout + render :action => "hello_world", :layout => true + end + + def hello_world_with_layout_false + render :action => "hello_world", :layout => false + end + + def hello_world_with_layout_nil + render :action => "hello_world", :layout => nil + end + end + + class TestControllerLayoutFirst < SimpleRouteCase + describe "Render hello_world and implicitly use <controller_path>.html.erb over application.html.erb as a layout" + + get "/render_action_with_both_layouts/basic/hello_world" + assert_body "With Controller Layout! Hello World! KTHXBAI" + assert_status 200 + end + + class TestLayoutTrue < SimpleRouteCase + describe "rendering a normal template with full path with layout => true" + + get "/render_action_with_both_layouts/basic/hello_world_with_layout" + assert_body "With Controller Layout! Hello World! KTHXBAI" + assert_status 200 + end + + class TestLayoutFalse < SimpleRouteCase + describe "rendering a normal template with full path with layout => false" + + get "/render_action_with_both_layouts/basic/hello_world_with_layout_false" + assert_body "Hello World!" + assert_status 200 + end + + class TestLayoutNil < SimpleRouteCase + describe "rendering a normal template with full path with layout => :nil" + + get "/render_action_with_both_layouts/basic/hello_world_with_layout_nil" + assert_body "Hello World!" + assert_status 200 + end + +end
\ No newline at end of file diff --git a/actionpack/test/new_base/render_implicit_action_test.rb b/actionpack/test/new_base/render_implicit_action_test.rb new file mode 100644 index 0000000000..798505b539 --- /dev/null +++ b/actionpack/test/new_base/render_implicit_action_test.rb @@ -0,0 +1,16 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module HappyPath + + class RenderImplicitActionController < ActionController::Base2 + # No actions yet, they are implicit + end + + class TestRendersActionImplicitly < SimpleRouteCase + + test "renders action implicitly" do + assert true + end + + end +end
\ No newline at end of file diff --git a/actionpack/test/new_base/render_layout_test.rb b/actionpack/test/new_base/render_layout_test.rb new file mode 100644 index 0000000000..facf67ea85 --- /dev/null +++ b/actionpack/test/new_base/render_layout_test.rb @@ -0,0 +1,45 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module ControllerLayouts + class ImplicitController < ::ApplicationController + + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "layouts/application.html.erb" => "OMG <%= yield %> KTHXBAI", + "basic.html.erb" => "Hello world!" + )] + + def index + render :template => "basic" + end + end + + class TestImplicitLayout < SimpleRouteCase + describe "rendering a normal template, but using the implicit layout" + + get "/controller_layouts/implicit/index" + assert_body "OMG Hello world! KTHXBAI" + assert_status 200 + end + + class ImplicitNameController < ::ApplicationController + + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "layouts/controller_layouts/implicit_name.html.erb" => "OMGIMPLICIT <%= yield %> KTHXBAI", + "basic.html.erb" => "Hello world!" + )] + + def index + render :template => "basic" + end + end + + class TestImplicitNamedLayout < SimpleRouteCase + describe "rendering a normal template, but using an implicit NAMED layout" + + get "/controller_layouts/implicit_name/index" + assert_body "OMGIMPLICIT Hello world! KTHXBAI" + assert_status 200 + end + + +end
\ No newline at end of file diff --git a/actionpack/test/new_base/render_template_test.rb b/actionpack/test/new_base/render_template_test.rb new file mode 100644 index 0000000000..c6c0269b40 --- /dev/null +++ b/actionpack/test/new_base/render_template_test.rb @@ -0,0 +1,133 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +module HappyPath + + class RenderTemplateWithoutLayoutController < ActionController::Base2 + + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "test/basic.html.erb" => "Hello from basic.html.erb", + "shared.html.erb" => "Elastica" + )] + + def render_hello_world + render :template => "test/basic" + end + + def render_hello_world_with_forward_slash + render :template => "/test/basic" + end + + def render_template_in_top_directory + render :template => 'shared' + end + + def render_template_in_top_directory_with_slash + render :template => '/shared' + end + end + + class TestTemplateRenderWithoutLayout < SimpleRouteCase + describe "rendering a normal template with full path without layout" + + get "/happy_path/render_template_without_layout/render_hello_world" + assert_body "Hello from basic.html.erb" + assert_status 200 + end + + class TestTemplateRenderWithForwardSlash < SimpleRouteCase + describe "rendering a normal template with full path starting with a leading slash" + + get "/happy_path/render_template_without_layout/render_hello_world_with_forward_slash" + assert_body "Hello from basic.html.erb" + assert_status 200 + end + + class TestTemplateRenderInTopDirectory < SimpleRouteCase + describe "rendering a template not in a subdirectory" + + get "/happy_path/render_template_without_layout/render_template_in_top_directory" + assert_body "Elastica" + assert_status 200 + end + + class TestTemplateRenderInTopDirectoryWithSlash < SimpleRouteCase + describe "rendering a template not in a subdirectory with a leading slash" + + get "/happy_path/render_template_without_layout/render_template_in_top_directory_with_slash" + assert_body "Elastica" + assert_status 200 + end + + class RenderTemplateWithLayoutController < ::ApplicationController + + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "test/basic.html.erb" => "Hello from basic.html.erb", + "shared.html.erb" => "Elastica", + "layouts/application.html.erb" => "<%= yield %>, I'm here!", + "layouts/greetings.html.erb" => "<%= yield %>, I wish thee well." + )] + + def render_hello_world + render :template => "test/basic" + end + + def render_hello_world_with_layout + render :template => "test/basic", :layout => true + end + + def render_hello_world_with_layout_false + render :template => "test/basic", :layout => false + end + + def render_hello_world_with_layout_nil + render :template => "test/basic", :layout => nil + end + + def render_hello_world_with_custom_layout + render :template => "test/basic", :layout => "greetings" + end + end + + class TestTemplateRenderWithLayout < SimpleRouteCase + describe "rendering a normal template with full path with layout" + + get "/happy_path/render_template_with_layout/render_hello_world" + assert_body "Hello from basic.html.erb, I'm here!" + assert_status 200 + end + + class TestTemplateRenderWithLayoutTrue < SimpleRouteCase + describe "rendering a normal template with full path with layout => :true" + + get "/happy_path/render_template_with_layout/render_hello_world_with_layout" + assert_body "Hello from basic.html.erb, I'm here!" + assert_status 200 + end + + class TestTemplateRenderWithLayoutFalse < SimpleRouteCase + describe "rendering a normal template with full path with layout => :false" + + get "/happy_path/render_template_with_layout/render_hello_world_with_layout_false" + assert_body "Hello from basic.html.erb" + assert_status 200 + end + + class TestTemplateRenderWithLayoutNil < SimpleRouteCase + describe "rendering a normal template with full path with layout => :nil" + + get "/happy_path/render_template_with_layout/render_hello_world_with_layout_nil" + assert_body "Hello from basic.html.erb" + assert_status 200 + end + + class TestTemplateRenderWithCustomLayout < SimpleRouteCase + describe "rendering a normal template with full path with layout => 'greetings'" + + get "/happy_path/render_template_with_layout/render_hello_world_with_custom_layout" + assert_body "Hello from basic.html.erb, I wish thee well." + assert_status 200 + end + + + +end
\ No newline at end of file diff --git a/actionpack/test/new_base/render_text_test.rb b/actionpack/test/new_base/render_text_test.rb new file mode 100644 index 0000000000..a20ca5fb8c --- /dev/null +++ b/actionpack/test/new_base/render_text_test.rb @@ -0,0 +1,144 @@ +require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper") + +class ApplicationController < ActionController::Base2 +end + +module HappyPath + + class RenderTextWithoutLayoutsController < ActionController::Base2 + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new] + + def render_hello_world + render :text => "hello david" + end + end + + class RenderTextWithLayoutsController < ::ApplicationController + self.view_paths = [ActionView::FixtureTemplate::FixturePath.new( + "layouts/application.html.erb" => "<%= yield %>, I'm here!", + "layouts/greetings.html.erb" => "<%= yield %>, I wish thee well." + )] + + def render_hello_world + render :text => "hello david" + end + + def render_custom_code + render :text => "hello world", :status => 404 + end + + def render_with_custom_code_as_string + render :text => "hello world", :status => "404 Not Found" + end + + def render_text_with_nil + render :text => nil + end + + def render_text_with_nil_and_status + render :text => nil, :status => 403 + end + + def render_text_with_false + render :text => false + end + + def render_text_with_layout + render :text => "hello world", :layout => true + end + + def render_text_with_layout_false + render :text => "hello world", :layout => false + end + + def render_text_with_layout_nil + render :text => "hello world", :layout => nil + end + + def render_text_with_custom_layout + render :text => "hello world", :layout => "greetings" + end + end + + class TestSimpleTextRenderWithNoLayout < SimpleRouteCase + describe "Rendering text from a action with default options renders the text with the layout" + + get "/happy_path/render_text_without_layouts/render_hello_world" + assert_body "hello david" + assert_status 200 + end + + class TestSimpleTextRenderWithLayout < SimpleRouteCase + describe "Rendering text from a action with default options renders the text without the layout" + + get "/happy_path/render_text_with_layouts/render_hello_world" + assert_body "hello david" + assert_status 200 + end + + class TestTextRenderWithStatus < SimpleRouteCase + describe "Rendering text, while also providing a custom status code" + + get "/happy_path/render_text_with_layouts/render_custom_code" + assert_body "hello world" + assert_status 404 + end + + class TestTextRenderWithNil < SimpleRouteCase + describe "Rendering text with nil returns a single space character" + + get "/happy_path/render_text_with_layouts/render_text_with_nil" + assert_body " " + assert_status 200 + end + + class TestTextRenderWithNilAndStatus < SimpleRouteCase + describe "Rendering text with nil and custom status code returns a single space character with the status" + + get "/happy_path/render_text_with_layouts/render_text_with_nil_and_status" + assert_body " " + assert_status 403 + end + + class TestTextRenderWithFalse < SimpleRouteCase + describe "Rendering text with false returns the string 'false'" + + get "/happy_path/render_text_with_layouts/render_text_with_false" + assert_body "false" + assert_status 200 + end + + class TestTextRenderWithLayoutTrue < SimpleRouteCase + describe "Rendering text with :layout => true" + + get "/happy_path/render_text_with_layouts/render_text_with_layout" + assert_body "hello world, I'm here!" + assert_status 200 + end + + class TestTextRenderWithCustomLayout < SimpleRouteCase + describe "Rendering text with :layout => 'greetings'" + + get "/happy_path/render_text_with_layouts/render_text_with_custom_layout" + assert_body "hello world, I wish thee well." + assert_status 200 + end + + class TestTextRenderWithLayoutFalse < SimpleRouteCase + describe "Rendering text with :layout => false" + + get "/happy_path/render_text_with_layouts/render_text_with_layout_false" + assert_body "hello world" + assert_status 200 + end + + class TestTextRenderWithLayoutNil < SimpleRouteCase + describe "Rendering text with :layout => nil" + + get "/happy_path/render_text_with_layouts/render_text_with_layout_nil" + assert_body "hello world" + assert_status 200 + end +end + +ActionController::Base2.app_loaded!
\ No newline at end of file diff --git a/actionpack/test/new_base/test_helper.rb b/actionpack/test/new_base/test_helper.rb new file mode 100644 index 0000000000..d29449ddc1 --- /dev/null +++ b/actionpack/test/new_base/test_helper.rb @@ -0,0 +1,144 @@ +$:.unshift(File.dirname(__FILE__) + '/../../lib') +$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib') +$:.unshift(File.dirname(__FILE__) + '/../lib') + +require 'test/unit' +require 'active_support' +require 'active_support/test_case' +require 'action_controller' +require 'action_view/base' +require 'fixture_template' + +begin + require 'ruby-debug' + Debugger.settings[:autoeval] = true + Debugger.start +rescue LoadError + # Debugging disabled. `gem install ruby-debug` to enable. +end + +require 'action_controller/abstract' +require 'action_controller/new_base' +require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late + +require 'rubygems' +require 'rack/test' + +module ActionController + class Base2 < AbstractBase + use AbstractController::Callbacks + use AbstractController::Helpers + use AbstractController::Logger + + use ActionController::HideActions + use ActionController::UrlFor + use ActionController::Renderer + use ActionController::Layouts + + def self.inherited(klass) + ::ActionController::Base2.subclasses << klass.to_s + super + end + + def self.subclasses + @subclasses ||= [] + end + + def self.app_loaded! + @subclasses.each do |subclass| + subclass.constantize._write_layout_method + end + end + + # append_view_path File.join(File.dirname(__FILE__), '..', 'fixtures') + + CORE_METHODS = self.public_instance_methods + end +end + +# Temporary base class +class Rack::TestCase < ActiveSupport::TestCase + include Rack::Test::Methods + + setup do + ActionController::Base.session_options[:key] = "abc" + ActionController::Base.session_options[:secret] = ("*" * 30) + + controllers = ActionController::Base2.subclasses.map do |k| + k.underscore.sub(/_controller$/, '') + end + + ActionController::Routing.use_controllers!(controllers) + + # Move into a bootloader + AbstractController::Base.subclasses.each do |klass| + klass = klass.constantize + next unless klass < AbstractController::Layouts + klass.class_eval do + _write_layout_method + end + end + end + + def app + @app ||= ActionController::Dispatcher.new + end + + def self.get(url) + setup do |test| + test.get url + end + end + + def assert_body(body) + assert_equal [body], last_response.body + end + + def self.assert_body(body) + test "body is set to '#{body}'" do + assert_body body + end + end + + def assert_status(code) + assert_equal code, last_response.status + end + + def self.assert_status(code) + test "status code is set to #{code}" do + assert_status code + end + end + + def assert_content_type(type) + assert_equal type, last_response.headers["Content-Type"] + end + + def self.assert_content_type(type) + test "content type is set to #{type}" do + assert_content_type(type) + end + end + + def assert_header(name, value) + assert_equal value, last_response.headers[name] + end + + def self.assert_header(name, value) + test "'#{name}' header is set to #{value.inspect}" do + assert_header(name, value) + end + end + +end + +class ::ApplicationController < ActionController::Base2 +end + +class SimpleRouteCase < Rack::TestCase + setup do + ActionController::Routing::Routes.draw do |map| + map.connect ':controller/:action/:id' + end + end +end
\ No newline at end of file diff --git a/actionpack/test/runner b/actionpack/test/runner new file mode 100755 index 0000000000..c2bbe63c75 --- /dev/null +++ b/actionpack/test/runner @@ -0,0 +1,8 @@ +#!/usr/bin/env ruby + + +ARGV.each do |arg| + Dir["#{Dir.pwd}/#{arg}/**/*_test.rb"].each do |file| + require file + end +end
\ No newline at end of file diff --git a/actionpack/test/template/active_record_helper_test.rb b/actionpack/test/template/active_record_helper_test.rb index 83c028b5f2..b4b8cbe074 100644 --- a/actionpack/test/template/active_record_helper_test.rb +++ b/actionpack/test/template/active_record_helper_test.rb @@ -112,6 +112,7 @@ class ActiveRecordHelperTest < ActionView::TestCase attr_accessor :request_forgery_protection_token, :form_authenticity_token def setup + super setup_post setup_user diff --git a/actionpack/test/template/asset_tag_helper_test.rb b/actionpack/test/template/asset_tag_helper_test.rb index 32ad87c12d..76ceff8d6c 100644 --- a/actionpack/test/template/asset_tag_helper_test.rb +++ b/actionpack/test/template/asset_tag_helper_test.rb @@ -4,6 +4,7 @@ class AssetTagHelperTest < ActionView::TestCase tests ActionView::Helpers::AssetTagHelper def setup + super silence_warnings do ActionView::Helpers::AssetTagHelper.send( :const_set, @@ -627,6 +628,7 @@ class AssetTagHelperNonVhostTest < ActionView::TestCase tests ActionView::Helpers::AssetTagHelper def setup + super ActionController::Base.relative_url_root = "/collaboration/hieraki" @controller = Class.new do diff --git a/actionpack/test/template/atom_feed_helper_test.rb b/actionpack/test/template/atom_feed_helper_test.rb index 8a00a397ca..bd97caf5d7 100644 --- a/actionpack/test/template/atom_feed_helper_test.rb +++ b/actionpack/test/template/atom_feed_helper_test.rb @@ -170,6 +170,7 @@ class AtomFeedTest < ActionController::TestCase tests ScrollsController def setup + super @request.host = "www.nextangle.com" end diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb index 7d1d7634a8..a7ed13cf57 100644 --- a/actionpack/test/template/compiled_templates_test.rb +++ b/actionpack/test/template/compiled_templates_test.rb @@ -2,7 +2,6 @@ require 'abstract_unit' require 'controller/fake_models' class CompiledTemplatesTest < Test::Unit::TestCase - def setup @compiled_templates = ActionView::Base::CompiledTemplates @compiled_templates.instance_methods.each do |m| @@ -11,193 +10,76 @@ class CompiledTemplatesTest < Test::Unit::TestCase end def test_template_gets_compiled - with_caching(true) do - assert_equal 0, @compiled_templates.instance_methods.size - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - assert_equal 1, @compiled_templates.instance_methods.size - end + assert_equal 0, @compiled_templates.instance_methods.size + assert_equal "Hello world!", render(:file => "test/hello_world.erb") + assert_equal 1, @compiled_templates.instance_methods.size end def test_template_gets_recompiled_when_using_different_keys_in_local_assigns - with_caching(true) do - assert_equal 0, @compiled_templates.instance_methods.size - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - assert_equal "Hello world!", render(:file => "test/hello_world.erb", :locals => {:foo => "bar"}) - assert_equal 2, @compiled_templates.instance_methods.size - end + assert_equal 0, @compiled_templates.instance_methods.size + assert_equal "Hello world!", render(:file => "test/hello_world.erb") + assert_equal "Hello world!", render(:file => "test/hello_world.erb", :locals => {:foo => "bar"}) + assert_equal 2, @compiled_templates.instance_methods.size end def test_compiled_template_will_not_be_recompiled_when_rendered_with_identical_local_assigns - with_caching(true) do - assert_equal 0, @compiled_templates.instance_methods.size - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - ActionView::Template.any_instance.expects(:compile!).never - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - end - end - - def test_template_changes_are_not_reflected_with_cached_template_loading - with_caching(true) do - with_reloading(false) do - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - modify_template "test/hello_world.erb", "Goodbye world!" do - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - end - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - end - end - end - - def test_template_changes_are_reflected_without_cached_template_loading - with_caching(true) do - with_reloading(true) do - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - modify_template "test/hello_world.erb", "Goodbye world!" do - assert_equal "Goodbye world!", render(:file => "test/hello_world.erb") - end - assert_equal "Hello world!", render(:file => "test/hello_world.erb") - end - end + assert_equal 0, @compiled_templates.instance_methods.size + assert_equal "Hello world!", render(:file => "test/hello_world.erb") + ActionView::Template.any_instance.expects(:compile!).never + assert_equal "Hello world!", render(:file => "test/hello_world.erb") end - def test_template_becomes_missing_if_deleted_without_cached_template_loading - with_reloading(true) do - assert_equal 'Hello world!', render(:file => 'test/hello_world.erb') - delete_template 'test/hello_world.erb' do - assert_raise(ActionView::MissingTemplate) { render(:file => 'test/hello_world.erb') } - end - assert_equal 'Hello world!', render(:file => 'test/hello_world.erb') - end - end - - def test_swapping_template_handler_is_working_without_cached_template_loading - with_reloading(true) do - assert_equal 'Hello world!', render(:file => 'test/hello_world') - delete_template 'test/hello_world.erb' do - rename_template 'test/hello_world_from_rxml.builder', 'test/hello_world.builder' do - assert_equal "<html>\n <p>Hello</p>\n</html>\n", render(:file => 'test/hello_world') - end - end - assert_equal 'Hello world!', render(:file => 'test/hello_world') - end + def test_compiled_template_will_always_be_recompiled_when_template_is_not_cached + ActionView::Template.any_instance.expects(:recompile?).times(3).returns(true) + assert_equal 0, @compiled_templates.instance_methods.size + assert_equal "Hello world!", render(:file => "#{FIXTURE_LOAD_PATH}/test/hello_world.erb") + ActionView::Template.any_instance.expects(:compile!).times(3) + 3.times { assert_equal "Hello world!", render(:file => "#{FIXTURE_LOAD_PATH}/test/hello_world.erb") } + assert_equal 1, @compiled_templates.instance_methods.size end - def test_adding_localized_template_will_take_precedence_without_cached_template_loading - with_reloading(true) do - assert_equal 'Hello world!', render(:file => 'test/hello_world') - rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do - assert_equal 'Hey verden', render(:file => 'test/hello_world') - end + def test_template_changes_are_not_reflected_with_cached_templates + assert_equal "Hello world!", render(:file => "test/hello_world.erb") + modify_template "test/hello_world.erb", "Goodbye world!" do + assert_equal "Hello world!", render(:file => "test/hello_world.erb") end + assert_equal "Hello world!", render(:file => "test/hello_world.erb") end - def test_deleting_localized_template_will_fall_back_to_non_localized_template_without_cached_template_loading - with_reloading(true) do - rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do - assert_equal 'Hey verden', render(:file => 'test/hello_world') - delete_template 'test/hello_world.en.html.erb' do - assert_equal 'Hello world!', render(:file => 'test/hello_world') - end - assert_equal 'Hey verden', render(:file => 'test/hello_world') - end - end - end - - def test_parallel_reloadable_view_paths_are_working - with_reloading(true) do - view_paths_copy = new_reloadable_view_paths - assert_equal 'Hello world!', render(:file => 'test/hello_world') - with_view_paths(view_paths_copy, new_reloadable_view_paths) do - assert_equal 'Hello world!', render(:file => 'test/hello_world') - end - modify_template 'test/hello_world.erb', 'Goodbye world!' do - assert_equal 'Goodbye world!', render(:file => 'test/hello_world') - modify_template 'test/hello_world.erb', 'So long, world!' do - with_view_paths(view_paths_copy, new_reloadable_view_paths) do - assert_equal 'So long, world!', render(:file => 'test/hello_world') - end - assert_equal 'So long, world!', render(:file => 'test/hello_world') - end - end + def test_template_changes_are_reflected_with_uncached_templates + assert_equal "Hello world!", render_without_cache(:file => "test/hello_world.erb") + modify_template "test/hello_world.erb", "Goodbye world!" do + assert_equal "Goodbye world!", render_without_cache(:file => "test/hello_world.erb") end + assert_equal "Hello world!", render_without_cache(:file => "test/hello_world.erb") end private def render(*args) - view_paths = @explicit_view_paths || ActionController::Base.view_paths - ActionView::Base.new(view_paths, {}).render(*args) + render_with_cache(*args) end - def with_view_paths(*args) - args.each do |view_paths| - begin - @explicit_view_paths = view_paths - yield - ensure - @explicit_view_paths = nil - end - end + def render_with_cache(*args) + view_paths = ActionController::Base.view_paths + assert_equal ActionView::Template::EagerPath, view_paths.first.class + ActionView::Base.new(view_paths, {}).render(*args) end - def reset_mtime_of(template_name, view_paths_to_use) - view_paths_to_use.find_template(template_name).previously_last_modified = 10.seconds.ago unless ActionView::Base.cache_template_loading? + def render_without_cache(*args) + path = ActionView::Template::Path.new(FIXTURE_LOAD_PATH) + view_paths = ActionView::Base.process_view_paths(path) + assert_equal ActionView::Template::Path, view_paths.first.class + ActionView::Base.new(view_paths, {}).render(*args) end - def modify_template(template, content, view_paths_to_use = ActionController::Base.view_paths) - filename = filename_for(template) + def modify_template(template, content) + filename = "#{FIXTURE_LOAD_PATH}/#{template}" old_content = File.read(filename) begin File.open(filename, "wb+") { |f| f.write(content) } - reset_mtime_of(template, view_paths_to_use) yield ensure File.open(filename, "wb+") { |f| f.write(old_content) } - reset_mtime_of(template, view_paths_to_use) end end - - def filename_for(template) - File.join(FIXTURE_LOAD_PATH, template) - end - - def rename_template(old_name, new_name) - File.rename(filename_for(old_name), filename_for(new_name)) - yield - ensure - File.rename(filename_for(new_name), filename_for(old_name)) - end - - def delete_template(template, &block) - rename_template(template, File.join(File.dirname(template), "__#{File.basename(template)}"), &block) - end - - def with_caching(perform_caching) - old_perform_caching = ActionController::Base.perform_caching - begin - ActionController::Base.perform_caching = perform_caching - yield - ensure - ActionController::Base.perform_caching = old_perform_caching - end - end - - def with_reloading(reload_templates, view_paths_owner = ActionController::Base) - old_view_paths, old_cache_templates = view_paths_owner.view_paths, ActionView::Base.cache_template_loading - begin - ActionView::Base.cache_template_loading = !reload_templates - view_paths_owner.view_paths = view_paths_for(reload_templates) - yield - ensure - view_paths_owner.view_paths, ActionView::Base.cache_template_loading = old_view_paths, old_cache_templates - end - end - - def new_reloadable_view_paths - ActionView::PathSet.new(CACHED_VIEW_PATHS.map(&:to_s)) - end - - def view_paths_for(reload_templates) - # reloadable paths are cheap to create - reload_templates ? new_reloadable_view_paths : CACHED_VIEW_PATHS - end end diff --git a/actionpack/test/template/form_helper_test.rb b/actionpack/test/template/form_helper_test.rb index 654eee40a3..104649deac 100644 --- a/actionpack/test/template/form_helper_test.rb +++ b/actionpack/test/template/form_helper_test.rb @@ -45,6 +45,7 @@ class FormHelperTest < ActionView::TestCase tests ActionView::Helpers::FormHelper def setup + super @post = Post.new @comment = Comment.new def @post.errors() diff --git a/actionpack/test/template/form_tag_helper_test.rb b/actionpack/test/template/form_tag_helper_test.rb index c713b8da8e..ea0be4a27a 100644 --- a/actionpack/test/template/form_tag_helper_test.rb +++ b/actionpack/test/template/form_tag_helper_test.rb @@ -4,6 +4,7 @@ class FormTagHelperTest < ActionView::TestCase tests ActionView::Helpers::FormTagHelper def setup + super @controller = Class.new do def url_for(options) "http://www.example.com" diff --git a/actionpack/test/template/javascript_helper_test.rb b/actionpack/test/template/javascript_helper_test.rb index d2fb24e36e..f9bc92c7c9 100644 --- a/actionpack/test/template/javascript_helper_test.rb +++ b/actionpack/test/template/javascript_helper_test.rb @@ -3,9 +3,10 @@ require 'abstract_unit' class JavaScriptHelperTest < ActionView::TestCase tests ActionView::Helpers::JavaScriptHelper - attr_accessor :template_format, :output_buffer + attr_accessor :formats, :output_buffer def setup + super @template = self end diff --git a/actionpack/test/template/prototype_helper_test.rb b/actionpack/test/template/prototype_helper_test.rb index d6b86a3964..cd6ee6ea11 100644 --- a/actionpack/test/template/prototype_helper_test.rb +++ b/actionpack/test/template/prototype_helper_test.rb @@ -25,9 +25,10 @@ class Author::Nested < Author; end class PrototypeHelperBaseTest < ActionView::TestCase - attr_accessor :template_format, :output_buffer + attr_accessor :formats, :output_buffer def setup + super @template = self @controller = Class.new do def url_for(options) diff --git a/actionpack/test/template/record_tag_helper_test.rb b/actionpack/test/template/record_tag_helper_test.rb index 67aa047745..809ed6d6af 100644 --- a/actionpack/test/template/record_tag_helper_test.rb +++ b/actionpack/test/template/record_tag_helper_test.rb @@ -13,6 +13,7 @@ class RecordTagHelperTest < ActionView::TestCase tests ActionView::Helpers::RecordTagHelper def setup + super @post = Post.new end diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb index 80fd549fd7..8bad866ce3 100644 --- a/actionpack/test/template/render_test.rb +++ b/actionpack/test/template/render_test.rb @@ -29,38 +29,48 @@ module RenderTestCases end def test_render_file_with_localization - old_locale = I18n.locale - I18n.locale = :da - assert_equal "Hey verden", @view.render(:file => "test/hello_world") - ensure - I18n.locale = old_locale + pending do + begin + old_locale = I18n.locale + I18n.locale = :da + assert_equal "Hey verden", @view.render(:file => "test/hello_world") + ensure + I18n.locale = old_locale + end + end end def test_render_file_with_dashed_locale old_locale = I18n.locale - I18n.locale = :"pt-BR" - assert_equal "Ola mundo", @view.render(:file => "test/hello_world") + pending do + I18n.locale = :"pt-BR" + assert_equal "Ola mundo", @view.render(:file => "test/hello_world") + end ensure I18n.locale = old_locale end def test_render_implicit_html_template_from_xhr_request - old_format = @view.template_format - @view.template_format = :js - assert_equal "Hello HTML!", @view.render(:file => "test/render_implicit_html_template_from_xhr_request") + old_format = @view.formats + pending do + @view.formats = [:js] + assert_equal "Hello HTML!", @view.render(:file => "test/render_implicit_html_template_from_xhr_request") + end ensure - @view.template_format = old_format + @view.formats = old_format end def test_render_implicit_html_template_from_xhr_request_with_localization old_locale = I18n.locale - old_format = @view.template_format - I18n.locale = :da - @view.template_format = :js - assert_equal "Hey HTML!\n", @view.render(:file => "test/render_implicit_html_template_from_xhr_request") + old_format = @view.formats + pending do + I18n.locale = :da + @view.formats = [:js] + assert_equal "Hey HTML!\n", @view.render(:file => "test/render_implicit_html_template_from_xhr_request") + end ensure I18n.locale = old_locale - @view.template_format = old_format + @view.formats = old_format end def test_render_file_at_top_level @@ -186,7 +196,7 @@ module RenderTestCases # TODO: The reason for this test is unclear, improve documentation def test_render_missing_xml_partial_and_raise_missing_template - @view.template_format = :xml + @view.formats = [:xml] assert_raise(ActionView::MissingTemplate) { @view.render(:partial => "test/layout_for_partial") } end @@ -255,42 +265,28 @@ module RenderTestCases assert_equal Encoding::UTF_8, result.encoding end end - - def test_render_with_backup_files - result = @view.render :file => "/test/backup_files/item" - assert_equal "The correct item.erb was loaded.\n", result - end - end -module TemplatesSetupTeardown - def setup_view_paths_for(new_cache_template_loading) - @previous_cache_template_loading, ActionView::Base.cache_template_loading = ActionView::Base.cache_template_loading, new_cache_template_loading - view_paths = new_cache_template_loading ? CACHED_VIEW_PATHS : ActionView::Base.process_view_paths(CACHED_VIEW_PATHS.map(&:to_s)) - assert_equal(new_cache_template_loading ? ActionView::Template::EagerPath : ActionView::ReloadableTemplate::ReloadablePath, view_paths.first.class) - setup_view(view_paths) - end - - def teardown - ActionView::Base.cache_template_loading = @previous_cache_template_loading - end -end - -class CachedRenderTest < Test::Unit::TestCase - include TemplatesSetupTeardown +class CachedViewRenderTest < ActiveSupport::TestCase include RenderTestCases + # Ensure view path cache is primed def setup - setup_view_paths_for(cache_templates = true) + view_paths = ActionController::Base.view_paths + assert_equal ActionView::Template::EagerPath, view_paths.first.class + setup_view(view_paths) end end -class ReloadableRenderTest < Test::Unit::TestCase - include TemplatesSetupTeardown +class LazyViewRenderTest < ActiveSupport::TestCase include RenderTestCases + # Test the same thing as above, but make sure the view path + # is not eager loaded def setup - setup_view_paths_for(cache_templates = false) + path = ActionView::Template::Path.new(FIXTURE_LOAD_PATH) + view_paths = ActionView::Base.process_view_paths(path) + assert_equal ActionView::Template::Path, view_paths.first.class + setup_view(view_paths) end end - diff --git a/actionpack/test/template/scriptaculous_helper_test.rb b/actionpack/test/template/scriptaculous_helper_test.rb index 690a7751b5..bebc3cb9f4 100644 --- a/actionpack/test/template/scriptaculous_helper_test.rb +++ b/actionpack/test/template/scriptaculous_helper_test.rb @@ -4,6 +4,7 @@ class ScriptaculousHelperTest < ActionView::TestCase tests ActionView::Helpers::ScriptaculousHelper def setup + super @controller = Class.new do def url_for(options) url = "http://www.example.com/" diff --git a/actionpack/test/template/template_test.rb b/actionpack/test/template/template_test.rb deleted file mode 100644 index 5c6523201b..0000000000 --- a/actionpack/test/template/template_test.rb +++ /dev/null @@ -1,34 +0,0 @@ -require 'abstract_unit' - -class TemplateTest < Test::Unit::TestCase - def test_template_path_parsing - with_options :base_path => nil, :name => 'abc', :locale => nil, :format => 'html', :extension => 'erb' do |t| - t.assert_parses_template_path 'abc.en.html.erb', :locale => 'en' - t.assert_parses_template_path 'abc.en.plain.html.erb', :locale => 'en', :format => 'plain.html' - t.assert_parses_template_path 'abc.html.erb' - t.assert_parses_template_path 'abc.plain.html.erb', :format => 'plain.html' - t.assert_parses_template_path 'abc.erb', :format => nil - t.assert_parses_template_path 'abc.html', :extension => nil - - t.assert_parses_template_path '_abc.html.erb', :name => '_abc' - - t.assert_parses_template_path 'test/abc.html.erb', :base_path => 'test' - t.assert_parses_template_path './test/abc.html.erb', :base_path => './test' - t.assert_parses_template_path '../test/abc.html.erb', :base_path => '../test' - - t.assert_parses_template_path 'abc', :extension => nil, :format => nil, :name => nil - t.assert_parses_template_path 'abc.xxx', :extension => nil, :format => 'xxx', :name => 'abc' - t.assert_parses_template_path 'abc.html.xxx', :extension => nil, :format => 'xxx', :name => 'abc' - - t.assert_parses_template_path 'abc.html.erb.orig', :format => 'orig', :extension => nil - end - end - - private - def assert_parses_template_path(path, parse_results) - template = ActionView::Template.new(path, '') - parse_results.each_pair do |k, v| - assert_block(%Q{Expected template to parse #{k.inspect} from "#{path}" as #{v.inspect}, but got #{template.send(k).inspect}}) { v == template.send(k) } - end - end -end diff --git a/actionpack/test/template/test_test.rb b/actionpack/test/template/test_test.rb index ccd299f46a..dd07a6d438 100644 --- a/actionpack/test/template/test_test.rb +++ b/actionpack/test/template/test_test.rb @@ -20,6 +20,7 @@ end class PeopleHelperTest < ActionView::TestCase def setup + super ActionController::Routing::Routes.draw do |map| map.people 'people', :controller => 'people', :action => 'index' map.connect ':controller/:action/:id' diff --git a/actionpack/test/template/text_helper_test.rb b/actionpack/test/template/text_helper_test.rb index a370f1458f..be7163888e 100644 --- a/actionpack/test/template/text_helper_test.rb +++ b/actionpack/test/template/text_helper_test.rb @@ -6,6 +6,7 @@ class TextHelperTest < ActionView::TestCase include TestingSandbox def setup + super # This simulates the fact that instance variables are reset every time # a view is rendered. The cycle helper depends on this behavior. @_cycles = nil if (defined? @_cycles) diff --git a/actionpack/test/template/url_helper_test.rb b/actionpack/test/template/url_helper_test.rb index 5900709d81..f3d2f87b4a 100644 --- a/actionpack/test/template/url_helper_test.rb +++ b/actionpack/test/template/url_helper_test.rb @@ -7,6 +7,7 @@ class UrlHelperTest < ActionView::TestCase tests ActionView::Helpers::UrlHelper def setup + super @controller = Class.new do attr_accessor :url, :request def url_for(options) @@ -380,6 +381,7 @@ class UrlHelperWithControllerTest < ActionView::TestCase tests ActionView::Helpers::UrlHelper def setup + super @request = ActionController::TestRequest.new @response = ActionController::TestResponse.new @controller = UrlHelperController.new @@ -458,6 +460,7 @@ class LinkToUnlessCurrentWithControllerTest < ActionView::TestCase tests ActionView::Helpers::UrlHelper def setup + super @request = ActionController::TestRequest.new @response = ActionController::TestResponse.new @controller = TasksController.new @@ -560,6 +563,7 @@ class PolymorphicControllerTest < ActionView::TestCase tests ActionView::Helpers::UrlHelper def setup + super @request = ActionController::TestRequest.new @response = ActionController::TestResponse.new end |