Refactor more controller tests
[rails.git] / test / controllers / user_blocks_controller_test.rb
1 require "test_helper"
2
3 class UserBlocksControllerTest < ActionDispatch::IntegrationTest
4   ##
5   # test all routes which lead to this controller
6   def test_routes
7     assert_routing(
8       { :path => "/blocks/new/username", :method => :get },
9       { :controller => "user_blocks", :action => "new", :display_name => "username" }
10     )
11
12     assert_routing(
13       { :path => "/user_blocks", :method => :get },
14       { :controller => "user_blocks", :action => "index" }
15     )
16     assert_routing(
17       { :path => "/user_blocks/new", :method => :get },
18       { :controller => "user_blocks", :action => "new" }
19     )
20     assert_routing(
21       { :path => "/user_blocks", :method => :post },
22       { :controller => "user_blocks", :action => "create" }
23     )
24     assert_routing(
25       { :path => "/user_blocks/1", :method => :get },
26       { :controller => "user_blocks", :action => "show", :id => "1" }
27     )
28     assert_routing(
29       { :path => "/user_blocks/1/edit", :method => :get },
30       { :controller => "user_blocks", :action => "edit", :id => "1" }
31     )
32     assert_routing(
33       { :path => "/user_blocks/1", :method => :put },
34       { :controller => "user_blocks", :action => "update", :id => "1" }
35     )
36     assert_routing(
37       { :path => "/user_blocks/1", :method => :delete },
38       { :controller => "user_blocks", :action => "destroy", :id => "1" }
39     )
40     assert_routing(
41       { :path => "/blocks/1/revoke", :method => :get },
42       { :controller => "user_blocks", :action => "revoke", :id => "1" }
43     )
44     assert_routing(
45       { :path => "/blocks/1/revoke", :method => :post },
46       { :controller => "user_blocks", :action => "revoke", :id => "1" }
47     )
48
49     assert_routing(
50       { :path => "/user/username/blocks", :method => :get },
51       { :controller => "user_blocks", :action => "blocks_on", :display_name => "username" }
52     )
53     assert_routing(
54       { :path => "/user/username/blocks_by", :method => :get },
55       { :controller => "user_blocks", :action => "blocks_by", :display_name => "username" }
56     )
57   end
58
59   ##
60   # test the index action
61   def test_index
62     active_block = create(:user_block)
63     expired_block = create(:user_block, :expired)
64     revoked_block = create(:user_block, :revoked)
65
66     get user_blocks_path
67     assert_response :success
68     assert_select "table#block_list", :count => 1 do
69       assert_select "tr", 4
70       assert_select "a[href='#{user_block_path(active_block)}']", 1
71       assert_select "a[href='#{user_block_path(expired_block)}']", 1
72       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
73     end
74   end
75
76   ##
77   # test the index action with multiple pages
78   def test_index_paged
79     create_list(:user_block, 50)
80
81     get user_blocks_path
82     assert_response :success
83     assert_select "table#block_list", :count => 1 do
84       assert_select "tr", :count => 21
85     end
86
87     get user_blocks_path(:page => 2)
88     assert_response :success
89     assert_select "table#block_list", :count => 1 do
90       assert_select "tr", :count => 21
91     end
92   end
93
94   ##
95   # test the show action
96   def test_show
97     active_block = create(:user_block, :needs_view)
98     expired_block = create(:user_block, :expired)
99     revoked_block = create(:user_block, :revoked)
100
101     # Viewing a block should fail when a bogus ID is given
102     get user_block_path(:id => 99999)
103     assert_response :not_found
104     assert_template "not_found"
105     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
106
107     # Viewing an expired block should work
108     get user_block_path(:id => expired_block)
109     assert_response :success
110
111     # Viewing a revoked block should work
112     get user_block_path(:id => revoked_block)
113     assert_response :success
114
115     # Viewing an active block should work, but shouldn't mark it as seen
116     get user_block_path(:id => active_block)
117     assert_response :success
118     assert UserBlock.find(active_block.id).needs_view
119
120     # Login as the blocked user
121     session_for(active_block.user)
122
123     # Now viewing it should mark it as seen
124     get user_block_path(:id => active_block)
125     assert_response :success
126     assert_not UserBlock.find(active_block.id).needs_view
127   end
128
129   ##
130   # test the new action
131   def test_new
132     target_user = create(:user)
133
134     # Check that the block creation page requires us to login
135     get new_user_block_path(:display_name => target_user.display_name)
136     assert_redirected_to login_path(:referer => new_user_block_path(:display_name => target_user.display_name))
137
138     # Login as a normal user
139     session_for(create(:user))
140
141     # Check that normal users can't load the block creation page
142     get new_user_block_path(:display_name => target_user.display_name)
143     assert_response :redirect
144     assert_redirected_to :controller => "errors", :action => "forbidden"
145
146     # Login as a moderator
147     session_for(create(:moderator_user))
148
149     # Check that the block creation page loads for moderators
150     get new_user_block_path(:display_name => target_user.display_name)
151     assert_response :success
152     assert_select "form#new_user_block", :count => 1 do
153       assert_select "textarea#user_block_reason", :count => 1
154       assert_select "select#user_block_period", :count => 1
155       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
156       assert_select "input#display_name[type='hidden']", :count => 1
157       assert_select "input[type='submit'][value='Create block']", :count => 1
158     end
159
160     # We should get an error if the user doesn't exist
161     get new_user_block_path(:display_name => "non_existent_user")
162     assert_response :not_found
163     assert_template "users/no_such_user"
164     assert_select "h1", "The user non_existent_user does not exist"
165   end
166
167   ##
168   # test the edit action
169   def test_edit
170     active_block = create(:user_block)
171
172     # Check that the block edit page requires us to login
173     get edit_user_block_path(:id => active_block)
174     assert_redirected_to login_path(:referer => edit_user_block_path(active_block))
175
176     # Login as a normal user
177     session_for(create(:user))
178
179     # Check that normal users can't load the block edit page
180     get edit_user_block_path(:id => active_block)
181     assert_response :redirect
182     assert_redirected_to :controller => "errors", :action => "forbidden"
183
184     # Login as a moderator
185     session_for(create(:moderator_user))
186
187     # Check that the block edit page loads for moderators
188     get edit_user_block_path(:id => active_block)
189     assert_response :success
190     assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
191       assert_select "textarea#user_block_reason", :count => 1
192       assert_select "select#user_block_period", :count => 1
193       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
194       assert_select "input[type='submit'][value='Update block']", :count => 1
195     end
196
197     # We should get an error if the user doesn't exist
198     get edit_user_block_path(:id => 99999)
199     assert_response :not_found
200     assert_template "not_found"
201     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
202   end
203
204   ##
205   # test the create action
206   def test_create
207     target_user = create(:user)
208     moderator_user = create(:moderator_user)
209
210     # Not logged in yet, so creating a block should fail
211     post user_blocks_path
212     assert_response :forbidden
213
214     # Login as a normal user
215     session_for(create(:user))
216
217     # Check that normal users can't create blocks
218     post user_blocks_path
219     assert_response :redirect
220     assert_redirected_to :controller => "errors", :action => "forbidden"
221
222     # Login as a moderator
223     session_for(moderator_user)
224
225     # A bogus block period should result in an error
226     assert_no_difference "UserBlock.count" do
227       post user_blocks_path(:display_name => target_user.display_name,
228                             :user_block_period => "99")
229     end
230     assert_redirected_to new_user_block_path(:display_name => target_user.display_name)
231     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
232
233     # Check that creating a block works
234     assert_difference "UserBlock.count", 1 do
235       post user_blocks_path(:display_name => target_user.display_name,
236                             :user_block_period => "12",
237                             :user_block => { :needs_view => false, :reason => "Vandalism" })
238     end
239     id = UserBlock.order(:id).ids.last
240     assert_redirected_to user_block_path(:id => id)
241     assert_equal "Created a block on user #{target_user.display_name}.", flash[:notice]
242     b = UserBlock.find(id)
243     assert_in_delta Time.now, b.created_at, 1
244     assert_in_delta Time.now, b.updated_at, 1
245     assert_in_delta Time.now + 12.hours, b.ends_at, 1
246     assert_not b.needs_view
247     assert_equal "Vandalism", b.reason
248     assert_equal "markdown", b.reason_format
249     assert_equal moderator_user.id, b.creator_id
250
251     # We should get an error if no user is specified
252     post user_blocks_path
253     assert_response :not_found
254     assert_template "users/no_such_user"
255     assert_select "h1", "The user  does not exist"
256
257     # We should get an error if the user doesn't exist
258     post user_blocks_path(:display_name => "non_existent_user")
259     assert_response :not_found
260     assert_template "users/no_such_user"
261     assert_select "h1", "The user non_existent_user does not exist"
262   end
263
264   ##
265   # test the update action
266   def test_update
267     moderator_user = create(:moderator_user)
268     second_moderator_user = create(:moderator_user)
269     active_block = create(:user_block, :creator => moderator_user)
270
271     # Not logged in yet, so updating a block should fail
272     put user_block_path(:id => active_block)
273     assert_response :forbidden
274
275     # Login as a normal user
276     session_for(create(:user))
277
278     # Check that normal users can't update blocks
279     put user_block_path(:id => active_block)
280     assert_response :redirect
281     assert_redirected_to :controller => "errors", :action => "forbidden"
282
283     # Login as the wrong moderator
284     session_for(second_moderator_user)
285
286     # Check that only the person who created a block can update it
287     assert_no_difference "UserBlock.count" do
288       put user_block_path(:id => active_block,
289                           :user_block_period => "12",
290                           :user_block => { :needs_view => true, :reason => "Vandalism" })
291     end
292     assert_redirected_to edit_user_block_path(active_block)
293     assert_equal "Only the moderator who created this block can edit it.", flash[:error]
294
295     # Login as the correct moderator
296     session_for(moderator_user)
297
298     # A bogus block period should result in an error
299     assert_no_difference "UserBlock.count" do
300       put user_block_path(:id => active_block, :user_block_period => "99")
301     end
302     assert_redirected_to edit_user_block_path(active_block)
303     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
304
305     # Check that updating a block works
306     assert_no_difference "UserBlock.count" do
307       put user_block_path(:id => active_block,
308                           :user_block_period => "12",
309                           :user_block => { :needs_view => true, :reason => "Vandalism" })
310     end
311     assert_redirected_to user_block_path(active_block)
312     assert_equal "Block updated.", flash[:notice]
313     b = UserBlock.find(active_block.id)
314     assert_in_delta Time.now, b.updated_at, 1
315     assert b.needs_view
316     assert_equal "Vandalism", b.reason
317
318     # We should get an error if the block doesn't exist
319     put user_block_path(:id => 99999)
320     assert_response :not_found
321     assert_template "not_found"
322     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
323   end
324
325   ##
326   # test the revoke action
327   def test_revoke
328     active_block = create(:user_block)
329
330     # Check that the block revoke page requires us to login
331     get revoke_user_block_path(:id => active_block)
332     assert_redirected_to login_path(:referer => revoke_user_block_path(:id => active_block))
333
334     # Login as a normal user
335     session_for(create(:user))
336
337     # Check that normal users can't load the block revoke page
338     get revoke_user_block_path(:id => active_block)
339     assert_response :redirect
340     assert_redirected_to :controller => "errors", :action => "forbidden"
341
342     # Login as a moderator
343     session_for(create(:moderator_user))
344
345     # Check that the block revoke page loads for moderators
346     get revoke_user_block_path(:id => active_block)
347     assert_response :success
348     assert_template "revoke"
349     assert_select "form", :count => 1 do
350       assert_select "input#confirm[type='checkbox']", :count => 1
351       assert_select "input[type='submit'][value='Revoke!']", :count => 1
352     end
353
354     # Check that revoking a block works
355     post revoke_user_block_path(:id => active_block, :confirm => true)
356     assert_redirected_to user_block_path(active_block)
357     b = UserBlock.find(active_block.id)
358     assert_in_delta Time.now, b.ends_at, 1
359
360     # We should get an error if the block doesn't exist
361     get revoke_user_block_path(:id => 99999)
362     assert_response :not_found
363     assert_template "not_found"
364     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
365   end
366
367   ##
368   # test the blocks_on action
369   def test_blocks_on
370     blocked_user = create(:user)
371     unblocked_user = create(:user)
372     normal_user = create(:user)
373     active_block = create(:user_block, :user => blocked_user)
374     revoked_block = create(:user_block, :revoked, :user => blocked_user)
375     expired_block = create(:user_block, :expired, :user => unblocked_user)
376
377     # Asking for a list of blocks with a bogus user name should fail
378     get user_blocks_on_path(:display_name => "non_existent_user")
379     assert_response :not_found
380     assert_template "users/no_such_user"
381     assert_select "h1", "The user non_existent_user does not exist"
382
383     # Check the list of blocks for a user that has never been blocked
384     get user_blocks_on_path(:display_name => normal_user.display_name)
385     assert_response :success
386     assert_select "table#block_list", false
387     assert_select "p", "#{normal_user.display_name} has not been blocked yet."
388
389     # Check the list of blocks for a user that is currently blocked
390     get user_blocks_on_path(:display_name => blocked_user.display_name)
391     assert_response :success
392     assert_select "table#block_list", :count => 1 do
393       assert_select "tr", 3
394       assert_select "a[href='#{user_block_path(active_block)}']", 1
395       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
396     end
397
398     # Check the list of blocks for a user that has previously been blocked
399     get user_blocks_on_path(:display_name => unblocked_user.display_name)
400     assert_response :success
401     assert_select "table#block_list", :count => 1 do
402       assert_select "tr", 2
403       assert_select "a[href='#{user_block_path(expired_block)}']", 1
404     end
405   end
406
407   ##
408   # test the blocks_on action with multiple pages
409   def test_blocks_on_paged
410     user = create(:user)
411     create_list(:user_block, 50, :user => user)
412
413     get user_blocks_on_path(:display_name => user.display_name)
414     assert_response :success
415     assert_select "table#block_list", :count => 1 do
416       assert_select "tr", :count => 21
417     end
418
419     get user_blocks_on_path(:display_name => user.display_name, :page => 2)
420     assert_response :success
421     assert_select "table#block_list", :count => 1 do
422       assert_select "tr", :count => 21
423     end
424   end
425
426   ##
427   # test the blocks_by action
428   def test_blocks_by
429     moderator_user = create(:moderator_user)
430     second_moderator_user = create(:moderator_user)
431     normal_user = create(:user)
432     active_block = create(:user_block, :creator => moderator_user)
433     expired_block = create(:user_block, :expired, :creator => second_moderator_user)
434     revoked_block = create(:user_block, :revoked, :creator => second_moderator_user)
435
436     # Asking for a list of blocks with a bogus user name should fail
437     get user_blocks_by_path(:display_name => "non_existent_user")
438     assert_response :not_found
439     assert_template "users/no_such_user"
440     assert_select "h1", "The user non_existent_user does not exist"
441
442     # Check the list of blocks given by one moderator
443     get user_blocks_by_path(:display_name => moderator_user.display_name)
444     assert_response :success
445     assert_select "table#block_list", :count => 1 do
446       assert_select "tr", 2
447       assert_select "a[href='#{user_block_path(active_block)}']", 1
448     end
449
450     # Check the list of blocks given by a different moderator
451     get user_blocks_by_path(:display_name => second_moderator_user.display_name)
452     assert_response :success
453     assert_select "table#block_list", :count => 1 do
454       assert_select "tr", 3
455       assert_select "a[href='#{user_block_path(expired_block)}']", 1
456       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
457     end
458
459     # Check the list of blocks (not) given by a normal user
460     get user_blocks_by_path(:display_name => normal_user.display_name)
461     assert_response :success
462     assert_select "table#block_list", false
463     assert_select "p", "#{normal_user.display_name} has not made any blocks yet."
464   end
465
466   ##
467   # test the blocks_by action with multiple pages
468   def test_blocks_by_paged
469     user = create(:moderator_user)
470     create_list(:user_block, 50, :creator => user)
471
472     get user_blocks_by_path(:display_name => user.display_name)
473     assert_response :success
474     assert_select "table#block_list", :count => 1 do
475       assert_select "tr", :count => 21
476     end
477
478     get user_blocks_by_path(:display_name => user.display_name, :page => 2)
479     assert_response :success
480     assert_select "table#block_list", :count => 1 do
481       assert_select "tr", :count => 21
482     end
483   end
484 end