← Back to branch summary

~michaelforrest/use-case-mapper/trunk

« back to all changes in this revision

Viewing changes to vendor/rails/actionpack/test/controller/dispatcher_test.rb

  • Committer: Michael Forrest
  • Date: 2010-10-15 16:28:50 UTC
  • Revision ID: michael.forrest@canonical.com-20101015162850-tj2vchanv0kr0dun
refroze gems

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/rails/actionpack/test/controller/dispatcher_test.rb
 
1
require 'abstract_unit'
 
2
 
 
3
class DispatcherTest < Test::Unit::TestCase
 
4
  Dispatcher = ActionController::Dispatcher
 
5
  Reloader   = ActionController::Reloader
 
6
 
 
7
  def setup
 
8
    ENV['REQUEST_METHOD'] = 'GET'
 
9
    reset_dispatcher
 
10
    Dispatcher.stubs(:require_dependency)
 
11
  end
 
12
 
 
13
  def teardown
 
14
    ENV.delete 'REQUEST_METHOD'
 
15
    reset_dispatcher
 
16
  end
 
17
 
 
18
  def test_clears_dependencies_after_dispatch_if_in_loading_mode
 
19
    ActiveSupport::Dependencies.expects(:clear).once
 
20
    # Close the response so dependencies kicks in
 
21
    dispatch(false).last.close
 
22
  end
 
23
 
 
24
  def test_reloads_routes_before_dispatch_if_in_loading_mode
 
25
    ActionController::Routing::Routes.expects(:reload).once
 
26
    dispatch(false)
 
27
  end
 
28
 
 
29
  def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
 
30
    ActionController::Routing::Routes.expects(:reload).never
 
31
    ActiveSupport::Dependencies.expects(:clear).never
 
32
 
 
33
    dispatch
 
34
  end
 
35
 
 
36
  def test_builds_middleware_stack_only_during_initialization_if_not_in_loading_mode
 
37
    dispatcher = create_dispatcher
 
38
    assert_not_nil dispatcher.instance_variable_get(:"@app")
 
39
    dispatcher.instance_variable_set(:"@app", lambda { |env| })
 
40
    dispatcher.expects(:build_middleware_stack).never
 
41
    dispatcher.call(nil)
 
42
    dispatcher.call(nil)
 
43
  end
 
44
 
 
45
  def test_rebuilds_middleware_stack_on_every_request_if_in_loading_mode
 
46
    dispatcher = create_dispatcher(false)
 
47
    dispatcher.instance_variable_set(:"@app", lambda { |env| })
 
48
    dispatcher.expects(:build_middleware_stack).twice
 
49
    dispatcher.call(nil)
 
50
    Reloader.default_lock.unlock
 
51
    dispatcher.call(nil)
 
52
  end
 
53
 
 
54
  def test_doesnt_wrap_call_in_reloader_if_not_in_loading_mode
 
55
    Reloader.expects(:run).never
 
56
    dispatch
 
57
  end
 
58
 
 
59
  def test_wraps_call_in_reloader_if_in_loading_mode
 
60
    Reloader.expects(:run).once
 
61
    dispatch(false)
 
62
  end
 
63
 
 
64
  # Stub out dispatch error logger
 
65
  class << Dispatcher
 
66
    def log_failsafe_exception(status, exception); end
 
67
  end
 
68
 
 
69
  def test_failsafe_response
 
70
    Dispatcher.any_instance.expects(:dispatch).raises('b00m')
 
71
    ActionController::Failsafe.any_instance.expects(:log_failsafe_exception)
 
72
 
 
73
    response = nil
 
74
    assert_nothing_raised do
 
75
      response = dispatch
 
76
    end
 
77
    assert_equal 3, response.size
 
78
    assert_equal 500, response[0]
 
79
    assert_equal({"Content-Type" => "text/html"}, response[1])
 
80
    assert_match /500 Internal Server Error/, response[2].join
 
81
  end
 
82
 
 
83
  def test_prepare_callbacks
 
84
    a = b = c = nil
 
85
    Dispatcher.to_prepare { |*args| a = b = c = 1 }
 
86
    Dispatcher.to_prepare { |*args| b = c = 2 }
 
87
    Dispatcher.to_prepare { |*args| c = 3 }
 
88
 
 
89
    # Ensure to_prepare callbacks are not run when defined
 
90
    assert_nil a || b || c
 
91
 
 
92
    # Run callbacks
 
93
    Dispatcher.run_prepare_callbacks
 
94
 
 
95
    assert_equal 1, a
 
96
    assert_equal 2, b
 
97
    assert_equal 3, c
 
98
 
 
99
    # Make sure they are only run once
 
100
    a = b = c = nil
 
101
    dispatch
 
102
    assert_nil a || b || c
 
103
  end
 
104
 
 
105
  def test_to_prepare_with_identifier_replaces
 
106
    a = b = nil
 
107
    Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
 
108
    Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
 
109
 
 
110
    Dispatcher.run_prepare_callbacks
 
111
    assert_equal 2, a
 
112
    assert_equal nil, b
 
113
  end
 
114
 
 
115
  private
 
116
    def dispatch(cache_classes = true)
 
117
      ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
 
118
      Dispatcher.define_dispatcher_callbacks(cache_classes)
 
119
      Dispatcher.new.call({'rack.input' => StringIO.new('')})
 
120
    end
 
121
 
 
122
    def create_dispatcher(cache_classes = true)
 
123
      Dispatcher.define_dispatcher_callbacks(cache_classes)
 
124
      Dispatcher.new
 
125
    end
 
126
 
 
127
    def reset_dispatcher
 
128
      Dispatcher.middleware = ActionController::MiddlewareStack.new do |middleware|
 
129
        middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/middlewares.rb"))
 
130
        middleware.instance_eval(File.read(middlewares))
 
131
      end
 
132
 
 
133
      # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
 
134
      Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
 
135
      Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
 
136
      Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
 
137
 
 
138
      Dispatcher.define_dispatcher_callbacks(true)
 
139
    end
 
140
 
 
141
    def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
 
142
      assert_equal howmany, klass.subclasses.size, message
 
143
    end
 
144
end