]> git.openstreetmap.org Git - rails.git/blob - test/controllers/user_blocks_controller_test.rb
Merge remote-tracking branch 'upstream/pull/5135'
[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", :method => :post },
18       { :controller => "user_blocks", :action => "create" }
19     )
20     assert_routing(
21       { :path => "/user_blocks/1", :method => :get },
22       { :controller => "user_blocks", :action => "show", :id => "1" }
23     )
24     assert_routing(
25       { :path => "/user_blocks/1/edit", :method => :get },
26       { :controller => "user_blocks", :action => "edit", :id => "1" }
27     )
28     assert_routing(
29       { :path => "/user_blocks/1", :method => :put },
30       { :controller => "user_blocks", :action => "update", :id => "1" }
31     )
32     assert_routing(
33       { :path => "/user_blocks/1", :method => :delete },
34       { :controller => "user_blocks", :action => "destroy", :id => "1" }
35     )
36
37     assert_routing(
38       { :path => "/user/username/blocks", :method => :get },
39       { :controller => "user_blocks", :action => "blocks_on", :display_name => "username" }
40     )
41     assert_routing(
42       { :path => "/user/username/blocks_by", :method => :get },
43       { :controller => "user_blocks", :action => "blocks_by", :display_name => "username" }
44     )
45     assert_routing(
46       { :path => "/user/username/blocks/revoke_all", :method => :get },
47       { :controller => "user_blocks", :action => "revoke_all", :display_name => "username" }
48     )
49     assert_routing(
50       { :path => "/user/username/blocks/revoke_all", :method => :post },
51       { :controller => "user_blocks", :action => "revoke_all", :display_name => "username" }
52     )
53   end
54
55   ##
56   # test the index action
57   def test_index
58     revoked_block = create(:user_block, :revoked)
59
60     get user_blocks_path
61     assert_response :success
62     assert_select "table#block_list tbody tr", :count => 1 do
63       assert_select "a[href='#{user_path revoked_block.user}']", :text => revoked_block.user.display_name
64       assert_select "a[href='#{user_path revoked_block.creator}']", :text => revoked_block.creator.display_name
65       assert_select "a[href='#{user_path revoked_block.revoker}']", :text => revoked_block.revoker.display_name
66     end
67
68     active_block = create(:user_block)
69     expired_block = create(:user_block, :expired)
70
71     get user_blocks_path
72     assert_response :success
73     assert_select "table#block_list tbody", :count => 1 do
74       assert_select "tr", 3
75       assert_select "a[href='#{user_block_path(active_block)}']", 1
76       assert_select "a[href='#{user_block_path(expired_block)}']", 1
77       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
78     end
79   end
80
81   ##
82   # test the index action with multiple pages
83   def test_index_paged
84     user_blocks = create_list(:user_block, 50).reverse
85     next_path = user_blocks_path
86
87     get next_path
88     assert_response :success
89     check_user_blocks_table user_blocks[0...20]
90     check_no_page_link "Newer Blocks"
91     next_path = check_page_link "Older Blocks"
92
93     get next_path
94     assert_response :success
95     check_user_blocks_table user_blocks[20...40]
96     check_page_link "Newer Blocks"
97     next_path = check_page_link "Older Blocks"
98
99     get next_path
100     assert_response :success
101     check_user_blocks_table user_blocks[40...50]
102     check_page_link "Newer Blocks"
103     check_no_page_link "Older Blocks"
104   end
105
106   ##
107   # test the index action with invalid pages
108   def test_index_invalid_paged
109     %w[-1 0 fred].each do |id|
110       get user_blocks_path(:before => id)
111       assert_redirected_to :controller => :errors, :action => :bad_request
112
113       get user_blocks_path(:after => id)
114       assert_redirected_to :controller => :errors, :action => :bad_request
115     end
116   end
117
118   ##
119   # test the show action
120   def test_show
121     active_block = create(:user_block, :needs_view)
122     expired_block = create(:user_block, :expired)
123     revoked_block = create(:user_block, :revoked)
124
125     # Viewing a block should fail when a bogus ID is given
126     get user_block_path(:id => 99999)
127     assert_response :not_found
128     assert_template "not_found"
129     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
130
131     # Viewing an expired block should work
132     get user_block_path(:id => expired_block)
133     assert_response :success
134     assert_select "h1 a[href='#{user_path expired_block.user}']", :text => expired_block.user.display_name
135     assert_select "h1 a[href='#{user_path expired_block.creator}']", :text => expired_block.creator.display_name
136
137     # Viewing a revoked block should work
138     get user_block_path(:id => revoked_block)
139     assert_response :success
140     assert_select "h1 a[href='#{user_path revoked_block.user}']", :text => revoked_block.user.display_name
141     assert_select "h1 a[href='#{user_path revoked_block.creator}']", :text => revoked_block.creator.display_name
142     assert_select "a[href='#{user_path revoked_block.revoker}']", :text => revoked_block.revoker.display_name
143
144     # Viewing an active block should work, but shouldn't mark it as seen
145     get user_block_path(:id => active_block)
146     assert_response :success
147     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
148     assert_select "h1 a[href='#{user_path active_block.creator}']", :text => active_block.creator.display_name
149     assert UserBlock.find(active_block.id).needs_view
150
151     # Login as the blocked user
152     session_for(active_block.user)
153
154     # Now viewing it should mark it as seen
155     get user_block_path(:id => active_block)
156     assert_response :success
157     assert_not UserBlock.find(active_block.id).needs_view
158   end
159
160   ##
161   # test edit/revoke link for active blocks
162   def test_active_block_buttons
163     creator_user = create(:moderator_user)
164     other_moderator_user = create(:moderator_user)
165     block = create(:user_block, :creator => creator_user)
166
167     session_for(other_moderator_user)
168     check_block_buttons block, :edit => 1
169
170     session_for(creator_user)
171     check_block_buttons block, :edit => 1
172   end
173
174   ##
175   # test the edit link for expired blocks
176   def test_expired_block_buttons
177     creator_user = create(:moderator_user)
178     other_moderator_user = create(:moderator_user)
179     block = create(:user_block, :expired, :creator => creator_user)
180
181     session_for(other_moderator_user)
182     check_block_buttons block
183
184     session_for(creator_user)
185     check_block_buttons block, :edit => 1
186   end
187
188   ##
189   # test the edit link for revoked blocks
190   def test_revoked_block_buttons
191     creator_user = create(:moderator_user)
192     revoker_user = create(:moderator_user)
193     other_moderator_user = create(:moderator_user)
194     block = create(:user_block, :revoked, :creator => creator_user, :revoker => revoker_user)
195
196     session_for(other_moderator_user)
197     check_block_buttons block
198
199     session_for(creator_user)
200     check_block_buttons block, :edit => 1
201
202     session_for(revoker_user)
203     check_block_buttons block, :edit => 1
204   end
205
206   ##
207   # test the new action
208   def test_new
209     target_user = create(:user)
210
211     # Check that the block creation page requires us to login
212     get new_user_block_path(target_user)
213     assert_redirected_to login_path(:referer => new_user_block_path(target_user))
214
215     # Login as a normal user
216     session_for(create(:user))
217
218     # Check that normal users can't load the block creation page
219     get new_user_block_path(target_user)
220     assert_redirected_to :controller => "errors", :action => "forbidden"
221
222     # Login as a moderator
223     session_for(create(:moderator_user))
224
225     # Check that the block creation page loads for moderators
226     get new_user_block_path(target_user)
227     assert_response :success
228     assert_select "h1 a[href='#{user_path target_user}']", :text => target_user.display_name
229     assert_select "form#new_user_block", :count => 1 do
230       assert_select "textarea#user_block_reason", :count => 1
231       assert_select "select#user_block_period", :count => 1
232       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
233       assert_select "input#display_name[type='hidden']", :count => 1
234       assert_select "input[type='submit'][value='Create block']", :count => 1
235     end
236
237     # We should get an error if the user doesn't exist
238     get new_user_block_path(:display_name => "non_existent_user")
239     assert_response :not_found
240     assert_template "users/no_such_user"
241     assert_select "h1", "The user non_existent_user does not exist"
242   end
243
244   ##
245   # test the edit action
246   def test_edit
247     creator_user = create(:moderator_user)
248     other_moderator_user = create(:moderator_user)
249     active_block = create(:user_block, :creator => creator_user)
250
251     # Check that the block edit page requires us to login
252     get edit_user_block_path(:id => active_block)
253     assert_redirected_to login_path(:referer => edit_user_block_path(active_block))
254
255     # Login as a normal user
256     session_for(create(:user))
257
258     # Check that normal users can't load the block edit page
259     get edit_user_block_path(:id => active_block)
260     assert_redirected_to :controller => "errors", :action => "forbidden"
261
262     # Login as a moderator
263     session_for(other_moderator_user)
264
265     # Check that the block edit page loads for moderators
266     get edit_user_block_path(:id => active_block)
267     assert_response :success
268     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
269     assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
270       assert_select "textarea#user_block_reason", :count => 1
271       assert_select "select#user_block_period", :count => 0
272       assert_select "input#user_block_needs_view[type='checkbox']", :count => 0
273       assert_select "input[type='submit'][value='Update block']", :count => 0
274       assert_select "input#user_block_period[type='hidden']", :count => 1
275       assert_select "input#user_block_needs_view[type='hidden']", :count => 1
276       assert_select "input[type='submit'][value='Revoke block']", :count => 1
277     end
278
279     # Login as the block creator
280     session_for(creator_user)
281
282     # Check that the block edit page loads for the creator
283     get edit_user_block_path(:id => active_block)
284     assert_response :success
285     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
286     assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
287       assert_select "textarea#user_block_reason", :count => 1
288       assert_select "select#user_block_period", :count => 1
289       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
290       assert_select "input[type='submit'][value='Update block']", :count => 1
291       assert_select "input#user_block_period[type='hidden']", :count => 0
292       assert_select "input#user_block_needs_view[type='hidden']", :count => 0
293       assert_select "input[type='submit'][value='Revoke block']", :count => 0
294     end
295
296     # We should get an error if the user doesn't exist
297     get edit_user_block_path(:id => 99999)
298     assert_response :not_found
299     assert_template "not_found"
300     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
301   end
302
303   ##
304   # test the edit action when the remaining block duration doesn't match the available select options
305   def test_edit_duration
306     moderator_user = create(:moderator_user)
307
308     freeze_time do
309       active_block = create(:user_block, :creator => moderator_user, :ends_at => Time.now.utc + 96.hours)
310
311       session_for(moderator_user)
312       get edit_user_block_path(active_block)
313
314       assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
315         assert_select "select#user_block_period", :count => 1 do
316           assert_select "option[value='96'][selected]", :count => 1
317         end
318       end
319
320       travel 2.hours
321       get edit_user_block_path(active_block)
322
323       assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
324         assert_select "select#user_block_period", :count => 1 do
325           assert_select "option[value='96'][selected]", :count => 1
326         end
327       end
328     end
329   end
330
331   ##
332   # test the create action
333   def test_create
334     target_user = create(:user)
335     moderator_user = create(:moderator_user)
336
337     # Not logged in yet, so creating a block should fail
338     post user_blocks_path
339     assert_response :forbidden
340
341     # Login as a normal user
342     session_for(create(:user))
343
344     # Check that normal users can't create blocks
345     post user_blocks_path
346     assert_redirected_to :controller => "errors", :action => "forbidden"
347
348     # Login as a moderator
349     session_for(moderator_user)
350
351     # A bogus block period should result in an error
352     assert_no_difference "UserBlock.count" do
353       post user_blocks_path(:display_name => target_user.display_name,
354                             :user_block_period => "99")
355     end
356     assert_redirected_to new_user_block_path(target_user)
357     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
358
359     # Check that creating a block works
360     assert_difference "UserBlock.count", 1 do
361       post user_blocks_path(:display_name => target_user.display_name,
362                             :user_block_period => "12",
363                             :user_block => { :needs_view => false, :reason => "Vandalism" })
364     end
365     b = UserBlock.last
366     assert_redirected_to user_block_path(:id => b.id)
367     assert_equal "Created a block on user #{target_user.display_name}.", flash[:notice]
368     assert_in_delta Time.now.utc, b.created_at, 1
369     assert_in_delta Time.now.utc, b.updated_at, 1
370     assert_in_delta Time.now.utc + 12.hours, b.ends_at, 1
371     assert_not b.needs_view
372     assert_equal "Vandalism", b.reason
373     assert_equal "markdown", b.reason_format
374     assert_equal moderator_user.id, b.creator_id
375
376     # We should get an error if no user is specified
377     post user_blocks_path
378     assert_response :not_found
379     assert_template "users/no_such_user"
380     assert_select "h1", "The user  does not exist"
381
382     # We should get an error if the user doesn't exist
383     post user_blocks_path(:display_name => "non_existent_user")
384     assert_response :not_found
385     assert_template "users/no_such_user"
386     assert_select "h1", "The user non_existent_user does not exist"
387   end
388
389   ##
390   # test the duration of a created block
391   def test_create_duration
392     target_user = create(:user)
393     moderator_user = create(:moderator_user)
394
395     session_for(moderator_user)
396     post user_blocks_path(:display_name => target_user.display_name,
397                           :user_block_period => "336",
398                           :user_block => { :needs_view => false, :reason => "Vandalism" })
399
400     block = UserBlock.last
401     assert_equal 1209600, block.ends_at - block.created_at
402   end
403
404   ##
405   # test the update action
406   def test_update
407     moderator_user = create(:moderator_user)
408     active_block = create(:user_block, :creator => moderator_user)
409
410     # Not logged in yet, so updating a block should fail
411     put user_block_path(:id => active_block)
412     assert_response :forbidden
413
414     # Login as a normal user
415     session_for(create(:user))
416
417     # Check that normal users can't update blocks
418     put user_block_path(:id => active_block)
419     assert_redirected_to :controller => "errors", :action => "forbidden"
420
421     # Login as the moderator
422     session_for(moderator_user)
423
424     # A bogus block period should result in an error
425     assert_no_difference "UserBlock.count" do
426       put user_block_path(:id => active_block, :user_block_period => "99")
427     end
428     assert_redirected_to edit_user_block_path(active_block)
429     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
430
431     # Check that updating a block works
432     assert_no_difference "UserBlock.count" do
433       put user_block_path(:id => active_block,
434                           :user_block_period => "12",
435                           :user_block => { :needs_view => true, :reason => "Vandalism" })
436     end
437     assert_redirected_to user_block_path(active_block)
438     assert_equal "Block updated.", flash[:notice]
439     b = UserBlock.find(active_block.id)
440     assert_in_delta Time.now.utc, b.updated_at, 1
441     assert b.needs_view
442     assert_equal "Vandalism", b.reason
443
444     # We should get an error if the block doesn't exist
445     put user_block_path(:id => 99999)
446     assert_response :not_found
447     assert_template "not_found"
448     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
449   end
450
451   ##
452   # test the update action on expired blocks
453   def test_update_expired
454     creator_user = create(:moderator_user)
455     other_moderator_user = create(:moderator_user)
456     block = create(:user_block, :expired, :creator => creator_user, :reason => "Original Reason")
457
458     session_for(other_moderator_user)
459     put user_block_path(block,
460                         :user_block_period => "0",
461                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
462     assert_redirected_to edit_user_block_path(block)
463     assert_equal "Only the moderator who created this block can edit it.", flash[:error]
464     block.reload
465     assert_not block.active?
466     assert_equal "Original Reason", block.reason
467
468     session_for(creator_user)
469     check_inactive_block_updates(block)
470   end
471
472   ##
473   # test the update action on revoked blocks
474   def test_update_revoked
475     creator_user = create(:moderator_user)
476     revoker_user = create(:moderator_user)
477     other_moderator_user = create(:moderator_user)
478     block = create(:user_block, :revoked, :creator => creator_user, :revoker => revoker_user, :reason => "Original Reason")
479
480     session_for(other_moderator_user)
481     put user_block_path(block,
482                         :user_block_period => "0",
483                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
484     assert_redirected_to edit_user_block_path(block)
485     assert_equal "Only the moderators who created or revoked this block can edit it.", flash[:error]
486     block.reload
487     assert_not_predicate block, :active?
488     assert_equal "Original Reason", block.reason
489
490     session_for(creator_user)
491     check_inactive_block_updates(block)
492
493     session_for(revoker_user)
494     check_inactive_block_updates(block)
495   end
496
497   ##
498   # test the update action revoking the block
499   def test_revoke_using_update_by_creator
500     moderator_user = create(:moderator_user)
501     block = create(:user_block, :creator => moderator_user)
502
503     session_for(moderator_user)
504     put user_block_path(block,
505                         :user_block_period => "24",
506                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
507     assert_redirected_to user_block_path(block)
508     assert_equal "Block updated.", flash[:notice]
509     block.reload
510     assert_predicate block, :active?
511     assert_nil block.revoker
512
513     put user_block_path(block,
514                         :user_block_period => "0",
515                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
516     assert_redirected_to user_block_path(block)
517     assert_equal "Block updated.", flash[:notice]
518     block.reload
519     assert_not_predicate block, :active?
520     assert_equal moderator_user, block.revoker
521   end
522
523   def test_revoke_using_update_by_other_moderator
524     creator_user = create(:moderator_user)
525     other_moderator_user = create(:moderator_user)
526     block = create(:user_block, :creator => creator_user)
527
528     session_for(other_moderator_user)
529     put user_block_path(block,
530                         :user_block_period => "24",
531                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
532     assert_response :success
533     assert_equal "Only the moderator who created this block can edit it without revoking.", flash[:error]
534     block.reload
535     assert_predicate block, :active?
536     assert_nil block.revoker
537
538     put user_block_path(block,
539                         :user_block_period => "0",
540                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
541     assert_redirected_to user_block_path(block)
542     assert_equal "Block updated.", flash[:notice]
543     block.reload
544     assert_not_predicate block, :active?
545     assert_equal other_moderator_user, block.revoker
546   end
547
548   ##
549   # test the revoke all page
550   def test_revoke_all_page
551     blocked_user = create(:user)
552     create(:user_block, :user => blocked_user)
553
554     # Asking for the revoke all blocks page with a bogus user name should fail
555     get user_blocks_on_path("non_existent_user")
556     assert_response :not_found
557
558     # Check that the revoke all blocks page requires us to login
559     get revoke_all_user_blocks_path(blocked_user)
560     assert_redirected_to login_path(:referer => revoke_all_user_blocks_path(blocked_user))
561
562     # Login as a normal user
563     session_for(create(:user))
564
565     # Check that normal users can't load the revoke all blocks page
566     get revoke_all_user_blocks_path(blocked_user)
567     assert_redirected_to :controller => "errors", :action => "forbidden"
568
569     # Login as a moderator
570     session_for(create(:moderator_user))
571
572     # Check that the revoke all blocks page loads for moderators
573     get revoke_all_user_blocks_path(blocked_user)
574     assert_response :success
575     assert_select "h1 a[href='#{user_path blocked_user}']", :text => blocked_user.display_name
576   end
577
578   ##
579   # test the revoke all action
580   def test_revoke_all_action
581     blocked_user = create(:user)
582     active_block1 = create(:user_block, :user => blocked_user)
583     active_block2 = create(:user_block, :user => blocked_user)
584     expired_block1 = create(:user_block, :expired, :user => blocked_user)
585     blocks = [active_block1, active_block2, expired_block1]
586     moderator_user = create(:moderator_user)
587
588     assert_predicate active_block1, :active?
589     assert_predicate active_block2, :active?
590     assert_not_predicate expired_block1, :active?
591
592     # Login as a normal user
593     session_for(create(:user))
594
595     # Check that normal users can't load the block revoke page
596     get revoke_all_user_blocks_path(:blocked_user)
597     assert_redirected_to :controller => "errors", :action => "forbidden"
598
599     # Login as a moderator
600     session_for(moderator_user)
601
602     # Check that revoking blocks using GET should fail
603     get revoke_all_user_blocks_path(blocked_user, :confirm => true)
604     assert_response :success
605     assert_template "revoke_all"
606
607     blocks.each(&:reload)
608     assert_predicate active_block1, :active?
609     assert_predicate active_block2, :active?
610     assert_not_predicate expired_block1, :active?
611
612     # Check that revoking blocks works using POST
613     post revoke_all_user_blocks_path(blocked_user, :confirm => true)
614     assert_redirected_to user_blocks_on_path(blocked_user)
615
616     blocks.each(&:reload)
617     assert_not_predicate active_block1, :active?
618     assert_not_predicate active_block2, :active?
619     assert_not_predicate expired_block1, :active?
620     assert_equal moderator_user, active_block1.revoker
621     assert_equal moderator_user, active_block2.revoker
622     assert_not_equal moderator_user, expired_block1.revoker
623   end
624
625   ##
626   # test changes to end/deactivation dates
627   def test_dates_when_viewed_before_end
628     blocked_user = create(:user)
629     moderator_user = create(:moderator_user)
630
631     freeze_time do
632       session_for(moderator_user)
633       assert_difference "UserBlock.count", 1 do
634         post user_blocks_path(:display_name => blocked_user.display_name,
635                               :user_block_period => "48",
636                               :user_block => { :needs_view => true, :reason => "Testing deactivates_at" })
637       end
638       block = UserBlock.last
639       assert_equal Time.now.utc + 2.days, block.ends_at
640       assert_nil block.deactivates_at
641
642       travel 1.day
643       session_for(blocked_user)
644       get user_block_path(block)
645       block.reload
646       assert_equal Time.now.utc + 1.day, block.ends_at
647       assert_equal Time.now.utc + 1.day, block.deactivates_at
648     end
649   end
650
651   def test_dates_when_viewed_after_end
652     blocked_user = create(:user)
653     moderator_user = create(:moderator_user)
654
655     freeze_time do
656       session_for(moderator_user)
657       assert_difference "UserBlock.count", 1 do
658         post user_blocks_path(:display_name => blocked_user.display_name,
659                               :user_block_period => "24",
660                               :user_block => { :needs_view => true, :reason => "Testing deactivates_at" })
661       end
662       block = UserBlock.last
663       assert_equal Time.now.utc + 1.day, block.ends_at
664       assert_nil block.deactivates_at
665
666       travel 2.days
667       session_for(blocked_user)
668       get user_block_path(block)
669       block.reload
670       assert_equal Time.now.utc - 1.day, block.ends_at
671       assert_equal Time.now.utc, block.deactivates_at
672     end
673   end
674
675   def test_dates_when_edited_before_end
676     blocked_user = create(:user)
677     moderator_user = create(:moderator_user)
678
679     freeze_time do
680       session_for(moderator_user)
681       assert_difference "UserBlock.count", 1 do
682         post user_blocks_path(:display_name => blocked_user.display_name,
683                               :user_block_period => "48",
684                               :user_block => { :needs_view => false, :reason => "Testing deactivates_at" })
685       end
686       block = UserBlock.last
687       assert_equal Time.now.utc + 2.days, block.ends_at
688       assert_equal Time.now.utc + 2.days, block.deactivates_at
689
690       travel 1.day
691       put user_block_path(block,
692                           :user_block_period => "48",
693                           :user_block => { :needs_view => false, :reason => "Testing deactivates_at updated" })
694       block.reload
695       assert_equal Time.now.utc + 2.days, block.ends_at
696       assert_equal Time.now.utc + 2.days, block.deactivates_at
697     end
698   end
699
700   def test_dates_when_edited_after_end
701     blocked_user = create(:user)
702     moderator_user = create(:moderator_user)
703
704     freeze_time do
705       session_for(moderator_user)
706       assert_difference "UserBlock.count", 1 do
707         post user_blocks_path(:display_name => blocked_user.display_name,
708                               :user_block_period => "24",
709                               :user_block => { :needs_view => false, :reason => "Testing deactivates_at" })
710       end
711       block = UserBlock.last
712       assert_equal Time.now.utc + 1.day, block.ends_at
713       assert_equal Time.now.utc + 1.day, block.deactivates_at
714
715       travel 2.days
716       put user_block_path(block,
717                           :user_block_period => "0",
718                           :user_block => { :needs_view => false, :reason => "Testing deactivates_at updated" })
719       block.reload
720       assert_equal Time.now.utc - 1.day, block.ends_at
721       assert_equal Time.now.utc - 1.day, block.deactivates_at
722     end
723   end
724
725   ##
726   # test updates on legacy records without correctly initialized deactivates_at
727   def test_update_legacy_deactivates_at
728     blocked_user = create(:user)
729     moderator_user = create(:moderator_user)
730
731     freeze_time do
732       block = UserBlock.new :user => blocked_user,
733                             :creator => moderator_user,
734                             :reason => "because",
735                             :ends_at => Time.now.utc + 1.day,
736                             :needs_view => false
737
738       assert_difference "UserBlock.count", 1 do
739         block.save :validate => false
740       end
741
742       travel 2.days
743       session_for(moderator_user)
744       put user_block_path(block,
745                           :user_block_period => "0",
746                           :user_block => { :needs_view => false, :reason => "Testing legacy block update" })
747       block.reload
748       assert_equal Time.now.utc - 1.day, block.ends_at
749       assert_equal Time.now.utc - 1.day, block.deactivates_at
750     end
751   end
752
753   ##
754   # test the blocks_on action
755   def test_blocks_on
756     blocked_user = create(:user)
757     unblocked_user = create(:user)
758     normal_user = create(:user)
759     active_block = create(:user_block, :user => blocked_user)
760     revoked_block = create(:user_block, :revoked, :user => blocked_user)
761     expired_block = create(:user_block, :expired, :user => unblocked_user)
762
763     # Asking for a list of blocks with a bogus user name should fail
764     get user_blocks_on_path("non_existent_user")
765     assert_response :not_found
766     assert_template "users/no_such_user"
767     assert_select "h1", "The user non_existent_user does not exist"
768
769     # Check the list of blocks for a user that has never been blocked
770     get user_blocks_on_path(normal_user)
771     assert_response :success
772     assert_select "table#block_list", false
773     assert_select "p", "#{normal_user.display_name} has not been blocked yet."
774
775     # Check the list of blocks for a user that is currently blocked
776     get user_blocks_on_path(blocked_user)
777     assert_response :success
778     assert_select "h1 a[href='#{user_path blocked_user}']", :text => blocked_user.display_name
779     assert_select "table#block_list tbody", :count => 1 do
780       assert_select "tr", 2
781       assert_select "a[href='#{user_block_path(active_block)}']", 1
782       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
783     end
784
785     # Check the list of blocks for a user that has previously been blocked
786     get user_blocks_on_path(unblocked_user)
787     assert_response :success
788     assert_select "h1 a[href='#{user_path unblocked_user}']", :text => unblocked_user.display_name
789     assert_select "table#block_list tbody", :count => 1 do
790       assert_select "tr", 1
791       assert_select "a[href='#{user_block_path(expired_block)}']", 1
792     end
793   end
794
795   ##
796   # test the blocks_on action with multiple pages
797   def test_blocks_on_paged
798     user = create(:user)
799     user_blocks = create_list(:user_block, 50, :user => user).reverse
800     next_path = user_blocks_on_path(user)
801
802     get next_path
803     assert_response :success
804     check_user_blocks_table user_blocks[0...20]
805     check_no_page_link "Newer Blocks"
806     next_path = check_page_link "Older Blocks"
807
808     get next_path
809     assert_response :success
810     check_user_blocks_table user_blocks[20...40]
811     check_page_link "Newer Blocks"
812     next_path = check_page_link "Older Blocks"
813
814     get next_path
815     assert_response :success
816     check_user_blocks_table user_blocks[40...50]
817     check_page_link "Newer Blocks"
818     check_no_page_link "Older Blocks"
819   end
820
821   ##
822   # test the blocks_on action with invalid pages
823   def test_blocks_on_invalid_paged
824     user = create(:user)
825
826     %w[-1 0 fred].each do |id|
827       get user_blocks_on_path(user, :before => id)
828       assert_redirected_to :controller => :errors, :action => :bad_request
829
830       get user_blocks_on_path(user, :after => id)
831       assert_redirected_to :controller => :errors, :action => :bad_request
832     end
833   end
834
835   ##
836   # test the blocks_by action
837   def test_blocks_by
838     moderator_user = create(:moderator_user)
839     second_moderator_user = create(:moderator_user)
840     normal_user = create(:user)
841     active_block = create(:user_block, :creator => moderator_user)
842     expired_block = create(:user_block, :expired, :creator => second_moderator_user)
843     revoked_block = create(:user_block, :revoked, :creator => second_moderator_user)
844
845     # Asking for a list of blocks with a bogus user name should fail
846     get user_blocks_by_path("non_existent_user")
847     assert_response :not_found
848     assert_template "users/no_such_user"
849     assert_select "h1", "The user non_existent_user does not exist"
850
851     # Check the list of blocks given by one moderator
852     get user_blocks_by_path(moderator_user)
853     assert_response :success
854     assert_select "h1 a[href='#{user_path moderator_user}']", :text => moderator_user.display_name
855     assert_select "table#block_list tbody", :count => 1 do
856       assert_select "tr", 1
857       assert_select "a[href='#{user_block_path(active_block)}']", 1
858     end
859
860     # Check the list of blocks given by a different moderator
861     get user_blocks_by_path(second_moderator_user)
862     assert_response :success
863     assert_select "h1 a[href='#{user_path second_moderator_user}']", :text => second_moderator_user.display_name
864     assert_select "table#block_list tbody", :count => 1 do
865       assert_select "tr", 2
866       assert_select "a[href='#{user_block_path(expired_block)}']", 1
867       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
868     end
869
870     # Check the list of blocks (not) given by a normal user
871     get user_blocks_by_path(normal_user)
872     assert_response :success
873     assert_select "table#block_list", false
874     assert_select "p", "#{normal_user.display_name} has not made any blocks yet."
875   end
876
877   ##
878   # test the blocks_by action with multiple pages
879   def test_blocks_by_paged
880     user = create(:moderator_user)
881     user_blocks = create_list(:user_block, 50, :creator => user).reverse
882     next_path = user_blocks_by_path(user)
883
884     get next_path
885     assert_response :success
886     check_user_blocks_table user_blocks[0...20]
887     check_no_page_link "Newer Blocks"
888     next_path = check_page_link "Older Blocks"
889
890     get next_path
891     assert_response :success
892     check_user_blocks_table user_blocks[20...40]
893     check_page_link "Newer Blocks"
894     next_path = check_page_link "Older Blocks"
895
896     get next_path
897     assert_response :success
898     check_user_blocks_table user_blocks[40...50]
899     check_page_link "Newer Blocks"
900     check_no_page_link "Older Blocks"
901   end
902
903   ##
904   # test the blocks_by action with invalid pages
905   def test_blocks_by_invalid_paged
906     user = create(:moderator_user)
907
908     %w[-1 0 fred].each do |id|
909       get user_blocks_by_path(user, :before => id)
910       assert_redirected_to :controller => :errors, :action => :bad_request
911
912       get user_blocks_by_path(user, :after => id)
913       assert_redirected_to :controller => :errors, :action => :bad_request
914     end
915   end
916
917   private
918
919   def check_block_buttons(block, edit: 0)
920     [user_blocks_path, user_block_path(block)].each do |path|
921       get path
922       assert_response :success
923       assert_select "a[href='#{edit_user_block_path block}']", :count => edit
924     end
925   end
926
927   def check_inactive_block_updates(block)
928     original_ends_at = block.ends_at
929
930     put user_block_path(block,
931                         :user_block_period => "0",
932                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
933     assert_redirected_to user_block_path(block)
934     assert_equal "Block updated.", flash[:notice]
935     block.reload
936     assert_not_predicate block, :active?
937     assert_equal "Updated Reason", block.reason
938     assert_equal original_ends_at, block.ends_at
939
940     put user_block_path(block,
941                         :user_block_period => "0",
942                         :user_block => { :needs_view => true, :reason => "Updated Reason Needs View" })
943     assert_response :success
944     assert_equal "This block is inactive and cannot be reactivated.", flash[:error]
945     block.reload
946     assert_not_predicate block, :active?
947     assert_equal "Updated Reason", block.reason
948     assert_equal original_ends_at, block.ends_at
949
950     put user_block_path(block,
951                         :user_block_period => "1",
952                         :user_block => { :needs_view => false, :reason => "Updated Reason Duration Extended" })
953     assert_response :success
954     assert_equal "This block is inactive and cannot be reactivated.", flash[:error]
955     block.reload
956     assert_not_predicate block, :active?
957     assert_equal "Updated Reason", block.reason
958     assert_equal original_ends_at, block.ends_at
959
960     put user_block_path(block,
961                         :user_block_period => "0",
962                         :user_block => { :needs_view => false, :reason => "Updated Reason Again" })
963     assert_redirected_to user_block_path(block)
964     assert_equal "Block updated.", flash[:notice]
965     block.reload
966     assert_not_predicate block, :active?
967     assert_equal "Updated Reason Again", block.reason
968     assert_equal original_ends_at, block.ends_at
969   end
970
971   def check_user_blocks_table(user_blocks)
972     assert_dom "table#block_list tbody tr" do |rows|
973       assert_equal user_blocks.count, rows.count, "unexpected number of rows in user blocks table"
974       rows.zip(user_blocks).map do |row, user_block|
975         assert_dom row, "a[href='#{user_block_path user_block}']", 1
976       end
977     end
978   end
979
980   def check_no_page_link(name)
981     assert_select "a.page-link", { :text => /#{Regexp.quote(name)}/, :count => 0 }, "unexpected #{name} page link"
982   end
983
984   def check_page_link(name)
985     assert_select "a.page-link", { :text => /#{Regexp.quote(name)}/ }, "missing #{name} page link" do |buttons|
986       return buttons.first.attributes["href"].value
987     end
988   end
989 end