aboutsummaryrefslogtreecommitdiffstats
path: root/actionpack/test/controller/verification_test.rb
blob: 0600ec2ec1b8af876c13763962f9d10afa2c0b14 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
require 'abstract_unit'

class VerificationTest < ActionController::TestCase
  class TestController < ActionController::Base
    verify :only => :guarded_one, :params => "one",
           :add_flash => { :error => 'unguarded' },
           :redirect_to => { :action => "unguarded" }

    verify :only => :guarded_two, :params => %w( one two ),
           :redirect_to => { :action => "unguarded" }

    verify :only => :guarded_with_flash, :params => "one",
           :add_flash => { :notice => "prereqs failed" },
           :redirect_to => { :action => "unguarded" }

    verify :only => :guarded_in_session, :session => "one",
           :redirect_to => { :action => "unguarded" }

    verify :only => [:multi_one, :multi_two], :session => %w( one two ),
           :redirect_to => { :action => "unguarded" }

    verify :only => :guarded_by_method, :method => :post,
           :redirect_to => { :action => "unguarded" }

    verify :only => :guarded_by_xhr, :xhr => true,
           :redirect_to => { :action => "unguarded" }

    verify :only => :guarded_by_not_xhr, :xhr => false,
           :redirect_to => { :action => "unguarded" }

    before_filter :unconditional_redirect, :only => :two_redirects
    verify :only => :two_redirects, :method => :post,
           :redirect_to => { :action => "unguarded" }

    verify :only => :must_be_post, :method => :post, :render => { :status => 405, :text => "Must be post" }, :add_headers => { "Allow" => "POST" }

    verify :only => :guarded_one_for_named_route_test, :params => "one",
           :redirect_to => :foo_url

    verify :only => :no_default_action, :params => "santa"

    verify :only => :guarded_with_back, :method => :post,
           :redirect_to => :back

    def guarded_one
      render :text => "#{params[:one]}"
    end

    def guarded_one_for_named_route_test
      render :text => "#{params[:one]}"
    end

    def guarded_with_flash
      render :text => "#{params[:one]}"
    end

    def guarded_two
      render :text => "#{params[:one]}:#{params[:two]}"
    end

    def guarded_in_session
      render :text => "#{session["one"]}"
    end

    def multi_one
      render :text => "#{session["one"]}:#{session["two"]}"
    end

    def multi_two
      render :text => "#{session["two"]}:#{session["one"]}"
    end

    def guarded_by_method
      render :text => "#{request.method.downcase}"
    end

    def guarded_by_xhr
      render :text => "#{request.xhr?}"
    end

    def guarded_by_not_xhr
      render :text => "#{request.xhr?}"
    end

    def unguarded
      render :text => "#{params[:one]}"
    end

    def two_redirects
      render :nothing => true
    end

    def must_be_post
      render :text => "Was a post!"
    end

    def guarded_with_back
      render :text => "#{params[:one]}"
    end

    def no_default_action
      # Will never run
    end

    protected

    def unconditional_redirect
      redirect_to :action => "unguarded"
    end
  end

  tests TestController

  def test_using_symbol_back_with_no_referrer
    assert_raise(ActionController::RedirectBackError) { get :guarded_with_back }
  end

  def test_using_symbol_back_redirects_to_referrer
    @request.env["HTTP_REFERER"] = "/foo"
    get :guarded_with_back
    assert_redirected_to '/foo'
  end

  def test_no_deprecation_warning_for_named_route
    assert_not_deprecated do
      with_routing do |set|
        set.draw do |map|
          match 'foo', :to => 'test#foo', :as => :foo
          match 'verification_test/:action', :to => ::VerificationTest::TestController
        end
        get :guarded_one_for_named_route_test, :two => "not one"
        assert_redirected_to '/foo'
      end
    end
  end

  def test_guarded_one_with_prereqs
    get :guarded_one, :one => "here"
    assert_equal "here", @response.body
  end

  def test_guarded_one_without_prereqs
    get :guarded_one
    assert_redirected_to :action => "unguarded"
    assert_equal 'unguarded', flash[:error]
  end

  def test_guarded_with_flash_with_prereqs
    get :guarded_with_flash, :one => "here"
    assert_equal "here", @response.body
    assert flash.empty?
  end

  def test_guarded_with_flash_without_prereqs
    get :guarded_with_flash
    assert_redirected_to :action => "unguarded"
    assert_equal "prereqs failed", flash[:notice]
  end

  def test_guarded_two_with_prereqs
    get :guarded_two, :one => "here", :two => "there"
    assert_equal "here:there", @response.body
  end

  def test_guarded_two_without_prereqs_one
    get :guarded_two, :two => "there"
    assert_redirected_to :action => "unguarded"
  end

  def test_guarded_two_without_prereqs_two
    get :guarded_two, :one => "here"
    assert_redirected_to :action => "unguarded"
  end

  def test_guarded_two_without_prereqs_both
    get :guarded_two
    assert_redirected_to :action => "unguarded"
  end

  def test_unguarded_with_params
    get :unguarded, :one => "here"
    assert_equal "here", @response.body
  end

  def test_unguarded_without_params
    get :unguarded
    assert @response.body.blank?
  end

  def test_guarded_in_session_with_prereqs
    get :guarded_in_session, {}, "one" => "here"
    assert_equal "here", @response.body
  end

  def test_guarded_in_session_without_prereqs
    get :guarded_in_session
    assert_redirected_to :action => "unguarded"
  end

  def test_multi_one_with_prereqs
    get :multi_one, {}, "one" => "here", "two" => "there"
    assert_equal "here:there", @response.body
  end

  def test_multi_one_without_prereqs
    get :multi_one
    assert_redirected_to :action => "unguarded"
  end

  def test_multi_two_with_prereqs
    get :multi_two, {}, "one" => "here", "two" => "there"
    assert_equal "there:here", @response.body
  end

  def test_multi_two_without_prereqs
    get :multi_two
    assert_redirected_to :action => "unguarded"
  end

  def test_guarded_by_method_with_prereqs
    post :guarded_by_method
    assert_equal "post", @response.body
  end

  def test_guarded_by_method_without_prereqs
    get :guarded_by_method
    assert_redirected_to :action => "unguarded"
  end

  def test_guarded_by_xhr_with_prereqs
    xhr :post, :guarded_by_xhr
    assert_equal "true", @response.body
  end

  def test_guarded_by_xhr_without_prereqs
    get :guarded_by_xhr
    assert_redirected_to :action => "unguarded"
  end

  def test_guarded_by_not_xhr_with_prereqs
    get :guarded_by_not_xhr
    assert_equal "false", @response.body
  end

  def test_guarded_by_not_xhr_without_prereqs
    xhr :post, :guarded_by_not_xhr
    assert_redirected_to :action => "unguarded"
  end

  def test_guarded_post_and_calls_render_succeeds
    post :must_be_post
    assert_equal "Was a post!", @response.body
  end

  def test_default_failure_should_be_a_bad_request
    post :no_default_action
    assert_response :bad_request
  end

  def test_guarded_post_and_calls_render_fails_and_sets_allow_header
    get :must_be_post
    assert_response 405
    assert_equal "Must be post", @response.body
    assert_equal "POST", @response.headers["Allow"]
  end

  def test_second_redirect
    assert_nothing_raised { get :two_redirects }
  end
end