test/controllers/user_blocks_controller_test.rb

   1 # frozen_string_literal: true
   2
   3 require "test_helper"
   4 require_relative "user_blocks/table_test_helper"
   5
   6 class UserBlocksControllerTest < ActionDispatch::IntegrationTest
   7   include UserBlocks::TableTestHelper
   8
   9   ##
  10   # test all routes which lead to this controller
  11   def test_routes
  12     assert_routing(
  13       { :path => "/user_blocks/new/username", :method => :get },
  14       { :controller => "user_blocks", :action => "new", :display_name => "username" }
  15     )
  16
  17     assert_routing(
  18       { :path => "/user_blocks", :method => :get },
  19       { :controller => "user_blocks", :action => "index" }
  20     )
  21     assert_routing(
  22       { :path => "/user_blocks", :method => :post },
  23       { :controller => "user_blocks", :action => "create" }
  24     )
  25     assert_routing(
  26       { :path => "/user_blocks/1", :method => :get },
  27       { :controller => "user_blocks", :action => "show", :id => "1" }
  28     )
  29     assert_routing(
  30       { :path => "/user_blocks/1/edit", :method => :get },
  31       { :controller => "user_blocks", :action => "edit", :id => "1" }
  32     )
  33     assert_routing(
  34       { :path => "/user_blocks/1", :method => :put },
  35       { :controller => "user_blocks", :action => "update", :id => "1" }
  36     )
  37     assert_routing(
  38       { :path => "/user_blocks/1", :method => :delete },
  39       { :controller => "user_blocks", :action => "destroy", :id => "1" }
  40     )
  41   end
  42
  43   ##
  44   # test the index action
  45   def test_index
  46     revoked_block = create(:user_block, :revoked)
  47
  48     get user_blocks_path
  49     assert_response :success
  50     assert_select "table#block_list tbody tr", :count => 1 do
  51       assert_select "a[href='#{user_path revoked_block.user}']", :text => revoked_block.user.display_name
  52       assert_select "a[href='#{user_path revoked_block.creator}']", :text => revoked_block.creator.display_name
  53       assert_select "a[href='#{user_path revoked_block.revoker}']", :text => revoked_block.revoker.display_name
  54     end
  55
  56     active_block = create(:user_block)
  57     expired_block = create(:user_block, :expired)
  58
  59     get user_blocks_path
  60     assert_response :success
  61     assert_select "table#block_list tbody", :count => 1 do
  62       assert_select "tr", 3
  63       assert_select "a[href='#{user_block_path(active_block)}']", 1
  64       assert_select "a[href='#{user_block_path(expired_block)}']", 1
  65       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
  66     end
  67   end
  68
  69   ##
  70   # test the index action with multiple pages
  71   def test_index_paged
  72     user_blocks = create_list(:user_block, 50).reverse
  73     next_path = user_blocks_path
  74
  75     get next_path
  76     assert_response :success
  77     check_user_blocks_table user_blocks[0...20]
  78     check_no_page_link "Newer Blocks"
  79     next_path = check_page_link "Older Blocks"
  80
  81     get next_path
  82     assert_response :success
  83     check_user_blocks_table user_blocks[20...40]
  84     check_page_link "Newer Blocks"
  85     next_path = check_page_link "Older Blocks"
  86
  87     get next_path
  88     assert_response :success
  89     check_user_blocks_table user_blocks[40...50]
  90     check_page_link "Newer Blocks"
  91     check_no_page_link "Older Blocks"
  92   end
  93
  94   ##
  95   # test the index action with invalid pages
  96   def test_index_invalid_paged
  97     %w[-1 fred].each do |id|
  98       get user_blocks_path(:before => id)
  99       assert_redirected_to :controller => :errors, :action => :bad_request
 100
 101       get user_blocks_path(:after => id)
 102       assert_redirected_to :controller => :errors, :action => :bad_request
 103     end
 104   end
 105
 106   ##
 107   # test the show action
 108   def test_show
 109     active_block = create(:user_block, :needs_view)
 110     expired_block = create(:user_block, :expired)
 111     revoked_block = create(:user_block, :revoked)
 112
 113     # Viewing a block should fail when a bogus ID is given
 114     get user_block_path(99999)
 115     assert_response :not_found
 116     assert_template "not_found"
 117     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
 118
 119     # Viewing an expired block should work
 120     get user_block_path(expired_block)
 121     assert_response :success
 122     assert_select "h1 a[href='#{user_path expired_block.user}']", :text => expired_block.user.display_name
 123     assert_select "h1 a[href='#{user_path expired_block.creator}']", :text => expired_block.creator.display_name
 124
 125     # Viewing a revoked block should work
 126     get user_block_path(revoked_block)
 127     assert_response :success
 128     assert_select "h1 a[href='#{user_path revoked_block.user}']", :text => revoked_block.user.display_name
 129     assert_select "h1 a[href='#{user_path revoked_block.creator}']", :text => revoked_block.creator.display_name
 130     assert_select "a[href='#{user_path revoked_block.revoker}']", :text => revoked_block.revoker.display_name
 131
 132     # Viewing an active block should work, but shouldn't mark it as seen
 133     get user_block_path(active_block)
 134     assert_response :success
 135     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
 136     assert_select "h1 a[href='#{user_path active_block.creator}']", :text => active_block.creator.display_name
 137     assert UserBlock.find(active_block.id).needs_view
 138   end
 139
 140   ##
 141   # test clearing needs_view by showing a zero-hour block to the blocked user
 142   def test_show_sets_deactivates_at_for_zero_hour_block
 143     user = create(:user)
 144     session_for(user)
 145
 146     freeze_time do
 147       block = create(:user_block, :needs_view, :zero_hour, :user => user)
 148       assert block.needs_view
 149       assert_nil block.deactivates_at
 150
 151       travel 1.hour
 152
 153       get user_block_path(block)
 154       assert_response :success
 155       block.reload
 156       assert_not block.needs_view
 157       assert_equal Time.now.utc, block.deactivates_at
 158
 159       travel 1.hour
 160
 161       get user_block_path(block)
 162       assert_response :success
 163       block.reload
 164       assert_not block.needs_view
 165       assert_equal Time.now.utc - 1.hour, block.deactivates_at
 166     end
 167   end
 168
 169   ##
 170   # test clearing needs_view by showing a timed block to the blocked user
 171   def test_show_sets_deactivates_at_for_timed_block
 172     user = create(:user)
 173     session_for(user)
 174
 175     freeze_time do
 176       block = create(:user_block, :needs_view, :created_at => Time.now.utc, :ends_at => Time.now.utc + 24.hours, :user => user)
 177       assert block.needs_view
 178       assert_nil block.deactivates_at
 179
 180       travel 1.hour
 181
 182       get user_block_path(block)
 183       assert_response :success
 184       block.reload
 185       assert_not block.needs_view
 186       assert_equal Time.now.utc + 23.hours, block.deactivates_at
 187
 188       travel 1.hour
 189
 190       get user_block_path(block)
 191       assert_response :success
 192       block.reload
 193       assert_not block.needs_view
 194       assert_equal Time.now.utc + 22.hours, block.deactivates_at
 195
 196       travel 24.hours
 197
 198       get user_block_path(block)
 199       assert_response :success
 200       block.reload
 201       assert_not block.needs_view
 202       assert_equal Time.now.utc - 2.hours, block.deactivates_at
 203     end
 204   end
 205
 206   ##
 207   # test edit/revoke link for active blocks
 208   def test_active_block_buttons
 209     creator_user = create(:moderator_user)
 210     other_moderator_user = create(:moderator_user)
 211     block = create(:user_block, :creator => creator_user)
 212
 213     session_for(other_moderator_user)
 214     check_block_buttons block, :edit => 1
 215
 216     session_for(creator_user)
 217     check_block_buttons block, :edit => 1
 218   end
 219
 220   ##
 221   # test the edit link for expired blocks
 222   def test_expired_block_buttons
 223     creator_user = create(:moderator_user)
 224     other_moderator_user = create(:moderator_user)
 225     block = create(:user_block, :expired, :creator => creator_user)
 226
 227     session_for(other_moderator_user)
 228     check_block_buttons block
 229
 230     session_for(creator_user)
 231     check_block_buttons block, :edit => 1
 232   end
 233
 234   ##
 235   # test the edit link for revoked blocks
 236   def test_revoked_block_buttons
 237     creator_user = create(:moderator_user)
 238     revoker_user = create(:moderator_user)
 239     other_moderator_user = create(:moderator_user)
 240     block = create(:user_block, :revoked, :creator => creator_user, :revoker => revoker_user)
 241
 242     session_for(other_moderator_user)
 243     check_block_buttons block
 244
 245     session_for(creator_user)
 246     check_block_buttons block, :edit => 1
 247
 248     session_for(revoker_user)
 249     check_block_buttons block, :edit => 1
 250   end
 251
 252   ##
 253   # test the new action
 254   def test_new
 255     target_user = create(:user)
 256
 257     # Check that the block creation page requires us to login
 258     get new_user_block_path(target_user)
 259     assert_redirected_to login_path(:referer => new_user_block_path(target_user))
 260
 261     # Login as a normal user
 262     session_for(create(:user))
 263
 264     # Check that normal users can't load the block creation page
 265     get new_user_block_path(target_user)
 266     assert_redirected_to :controller => "errors", :action => "forbidden"
 267
 268     # Login as a moderator
 269     session_for(create(:moderator_user))
 270
 271     # Check that the block creation page loads for moderators
 272     get new_user_block_path(target_user)
 273     assert_response :success
 274     assert_select "h1 a[href='#{user_path target_user}']", :text => target_user.display_name
 275     assert_select "form#new_user_block", :count => 1 do
 276       assert_select "textarea#user_block_reason", :count => 1
 277       assert_select "select#user_block_period", :count => 1
 278       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
 279       assert_select "input#display_name[type='hidden']", :count => 1
 280       assert_select "input[type='submit'][value='Create block']", :count => 1
 281     end
 282
 283     # We should get an error if the user doesn't exist
 284     get new_user_block_path("non_existent_user")
 285     assert_response :not_found
 286     assert_template "users/no_such_user"
 287     assert_select "h1", "The user non_existent_user does not exist"
 288   end
 289
 290   ##
 291   # test the edit action
 292   def test_edit
 293     creator_user = create(:moderator_user)
 294     other_moderator_user = create(:moderator_user)
 295     active_block = create(:user_block, :creator => creator_user)
 296
 297     # Check that the block edit page requires us to login
 298     get edit_user_block_path(active_block)
 299     assert_redirected_to login_path(:referer => edit_user_block_path(active_block))
 300
 301     # Login as a normal user
 302     session_for(create(:user))
 303
 304     # Check that normal users can't load the block edit page
 305     get edit_user_block_path(active_block)
 306     assert_redirected_to :controller => "errors", :action => "forbidden"
 307
 308     # Login as a moderator
 309     session_for(other_moderator_user)
 310
 311     # Check that the block edit page loads for moderators
 312     get edit_user_block_path(active_block)
 313     assert_response :success
 314     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
 315     assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
 316       assert_select "textarea#user_block_reason", :count => 1
 317       assert_select "select#user_block_period", :count => 0
 318       assert_select "input#user_block_needs_view[type='checkbox']", :count => 0
 319       assert_select "input[type='submit'][value='Update block']", :count => 0
 320       assert_select "input#user_block_period[type='hidden']", :count => 1
 321       assert_select "input#user_block_needs_view[type='hidden']", :count => 1
 322       assert_select "input[type='submit'][value='Revoke block']", :count => 1
 323     end
 324
 325     # Login as the block creator
 326     session_for(creator_user)
 327
 328     # Check that the block edit page loads for the creator
 329     get edit_user_block_path(active_block)
 330     assert_response :success
 331     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
 332     assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
 333       assert_select "textarea#user_block_reason", :count => 1
 334       assert_select "select#user_block_period", :count => 1
 335       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
 336       assert_select "input[type='submit'][value='Update block']", :count => 1
 337       assert_select "input#user_block_period[type='hidden']", :count => 0
 338       assert_select "input#user_block_needs_view[type='hidden']", :count => 0
 339       assert_select "input[type='submit'][value='Revoke block']", :count => 0
 340     end
 341
 342     # We should get an error if the user doesn't exist
 343     get edit_user_block_path(99999)
 344     assert_response :not_found
 345     assert_template "not_found"
 346     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
 347   end
 348
 349   ##
 350   # test the edit action when the remaining block duration doesn't match the available select options
 351   def test_edit_duration
 352     moderator_user = create(:moderator_user)
 353
 354     freeze_time do
 355       active_block = create(:user_block, :creator => moderator_user, :ends_at => Time.now.utc + 96.hours)
 356
 357       session_for(moderator_user)
 358       get edit_user_block_path(active_block)
 359
 360       assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
 361         assert_select "select#user_block_period", :count => 1 do
 362           assert_select "option[value='96'][selected]", :count => 1
 363         end
 364       end
 365
 366       travel 2.hours
 367       get edit_user_block_path(active_block)
 368
 369       assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
 370         assert_select "select#user_block_period", :count => 1 do
 371           assert_select "option[value='96'][selected]", :count => 1
 372         end
 373       end
 374     end
 375   end
 376
 377   ##
 378   # test the create action
 379   def test_create
 380     target_user = create(:user)
 381     moderator_user = create(:moderator_user)
 382
 383     # Not logged in yet, so creating a block should fail
 384     post user_blocks_path
 385     assert_response :forbidden
 386
 387     # Login as a normal user
 388     session_for(create(:user))
 389
 390     # Check that normal users can't create blocks
 391     post user_blocks_path
 392     assert_redirected_to :controller => "errors", :action => "forbidden"
 393
 394     # Login as a moderator
 395     session_for(moderator_user)
 396
 397     # A bogus block period should result in an error
 398     assert_no_difference "UserBlock.count" do
 399       post user_blocks_path(:display_name => target_user.display_name,
 400                             :user_block_period => "99")
 401     end
 402     assert_redirected_to new_user_block_path(target_user)
 403     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
 404
 405     # Check that creating a block works
 406     assert_difference "UserBlock.count", 1 do
 407       post user_blocks_path(:display_name => target_user.display_name,
 408                             :user_block_period => "12",
 409                             :user_block => { :needs_view => false, :reason => "Vandalism" })
 410     end
 411     b = UserBlock.last
 412     assert_redirected_to user_block_path(b)
 413     assert_equal "Created a block on user #{target_user.display_name}.", flash[:notice]
 414     assert_in_delta Time.now.utc, b.created_at, 1
 415     assert_in_delta Time.now.utc, b.updated_at, 1
 416     assert_in_delta Time.now.utc + 12.hours, b.ends_at, 1
 417     assert_not b.needs_view
 418     assert_equal "Vandalism", b.reason
 419     assert_equal "markdown", b.reason_format
 420     assert_equal moderator_user.id, b.creator_id
 421
 422     # We should get an error if no user is specified
 423     post user_blocks_path
 424     assert_response :not_found
 425     assert_template "users/no_such_user"
 426     assert_select "h1", :html => "The user  does not exist"
 427
 428     # We should get an error if the user doesn't exist
 429     post user_blocks_path(:display_name => "non_existent_user")
 430     assert_response :not_found
 431     assert_template "users/no_such_user"
 432     assert_select "h1", "The user non_existent_user does not exist"
 433   end
 434
 435   ##
 436   # test the duration of a created block
 437   def test_create_duration
 438     target_user = create(:user)
 439     moderator_user = create(:moderator_user)
 440
 441     session_for(moderator_user)
 442     post user_blocks_path(:display_name => target_user.display_name,
 443                           :user_block_period => "336",
 444                           :user_block => { :needs_view => false, :reason => "Vandalism" })
 445
 446     block = UserBlock.last
 447     assert_equal 1209600, block.ends_at - block.created_at
 448   end
 449
 450   ##
 451   # test the update action
 452   def test_update
 453     moderator_user = create(:moderator_user)
 454     active_block = create(:user_block, :creator => moderator_user)
 455
 456     # Not logged in yet, so updating a block should fail
 457     put user_block_path(active_block)
 458     assert_response :forbidden
 459
 460     # Login as a normal user
 461     session_for(create(:user))
 462
 463     # Check that normal users can't update blocks
 464     put user_block_path(active_block)
 465     assert_redirected_to :controller => "errors", :action => "forbidden"
 466
 467     # Login as the moderator
 468     session_for(moderator_user)
 469
 470     # A bogus block period should result in an error
 471     assert_no_difference "UserBlock.count" do
 472       put user_block_path(active_block, :user_block_period => "99")
 473     end
 474     assert_redirected_to edit_user_block_path(active_block)
 475     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
 476
 477     # Check that updating a block works
 478     assert_no_difference "UserBlock.count" do
 479       put user_block_path(active_block,
 480                           :user_block_period => "12",
 481                           :user_block => { :needs_view => true, :reason => "Vandalism" })
 482     end
 483     assert_redirected_to user_block_path(active_block)
 484     assert_equal "Block updated.", flash[:notice]
 485     b = UserBlock.find(active_block.id)
 486     assert_in_delta Time.now.utc, b.updated_at, 1
 487     assert b.needs_view
 488     assert_equal "Vandalism", b.reason
 489
 490     # We should get an error if the block doesn't exist
 491     put user_block_path(99999)
 492     assert_response :not_found
 493     assert_template "not_found"
 494     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
 495   end
 496
 497   ##
 498   # test the update action on expired blocks
 499   def test_update_expired
 500     creator_user = create(:moderator_user)
 501     other_moderator_user = create(:moderator_user)
 502     block = create(:user_block, :expired, :creator => creator_user, :reason => "Original Reason")
 503
 504     session_for(other_moderator_user)
 505     put user_block_path(block,
 506                         :user_block_period => "0",
 507                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
 508     assert_redirected_to edit_user_block_path(block)
 509     assert_equal "Only the moderator who created this block can edit it.", flash[:error]
 510     block.reload
 511     assert_not block.active?
 512     assert_equal "Original Reason", block.reason
 513
 514     session_for(creator_user)
 515     check_inactive_block_updates(block)
 516   end
 517
 518   ##
 519   # test the update action on revoked blocks
 520   def test_update_revoked
 521     creator_user = create(:moderator_user)
 522     revoker_user = create(:moderator_user)
 523     other_moderator_user = create(:moderator_user)
 524     block = create(:user_block, :revoked, :creator => creator_user, :revoker => revoker_user, :reason => "Original Reason")
 525
 526     session_for(other_moderator_user)
 527     put user_block_path(block,
 528                         :user_block_period => "0",
 529                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
 530     assert_redirected_to edit_user_block_path(block)
 531     assert_equal "Only the moderators who created or revoked this block can edit it.", flash[:error]
 532     block.reload
 533     assert_not_predicate block, :active?
 534     assert_equal "Original Reason", block.reason
 535
 536     session_for(creator_user)
 537     check_inactive_block_updates(block)
 538
 539     session_for(revoker_user)
 540     check_inactive_block_updates(block)
 541   end
 542
 543   ##
 544   # test the update action revoking the block
 545   def test_revoke_using_update_by_creator
 546     moderator_user = create(:moderator_user)
 547     block = create(:user_block, :creator => moderator_user)
 548
 549     session_for(moderator_user)
 550     put user_block_path(block,
 551                         :user_block_period => "24",
 552                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
 553     assert_redirected_to user_block_path(block)
 554     assert_equal "Block updated.", flash[:notice]
 555     block.reload
 556     assert_predicate block, :active?
 557     assert_nil block.revoker
 558
 559     put user_block_path(block,
 560                         :user_block_period => "0",
 561                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
 562     assert_redirected_to user_block_path(block)
 563     assert_equal "Block updated.", flash[:notice]
 564     block.reload
 565     assert_not_predicate block, :active?
 566     assert_equal moderator_user, block.revoker
 567   end
 568
 569   def test_revoke_using_update_by_other_moderator
 570     creator_user = create(:moderator_user)
 571     other_moderator_user = create(:moderator_user)
 572     block = create(:user_block, :creator => creator_user)
 573
 574     session_for(other_moderator_user)
 575     put user_block_path(block,
 576                         :user_block_period => "24",
 577                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
 578     assert_response :success
 579     assert_equal "Only the moderator who created this block can edit it without revoking.", flash[:error]
 580     block.reload
 581     assert_predicate block, :active?
 582     assert_nil block.revoker
 583
 584     put user_block_path(block,
 585                         :user_block_period => "0",
 586                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
 587     assert_redirected_to user_block_path(block)
 588     assert_equal "Block updated.", flash[:notice]
 589     block.reload
 590     assert_not_predicate block, :active?
 591     assert_equal other_moderator_user, block.revoker
 592   end
 593
 594   ##
 595   # test changes to end/deactivation dates
 596   def test_dates_when_viewed_before_end
 597     blocked_user = create(:user)
 598     moderator_user = create(:moderator_user)
 599
 600     freeze_time do
 601       session_for(moderator_user)
 602       assert_difference "UserBlock.count", 1 do
 603         post user_blocks_path(:display_name => blocked_user.display_name,
 604                               :user_block_period => "48",
 605                               :user_block => { :needs_view => true, :reason => "Testing deactivates_at" })
 606       end
 607       block = UserBlock.last
 608       assert_equal Time.now.utc + 48.hours, block.ends_at
 609       assert_nil block.deactivates_at
 610
 611       travel 24.hours
 612       session_for(blocked_user)
 613       get user_block_path(block)
 614       block.reload
 615       assert_equal Time.now.utc + 24.hours, block.ends_at
 616       assert_equal Time.now.utc + 24.hours, block.deactivates_at
 617     end
 618   end
 619
 620   def test_dates_when_viewed_after_end
 621     blocked_user = create(:user)
 622     moderator_user = create(:moderator_user)
 623
 624     freeze_time do
 625       session_for(moderator_user)
 626       assert_difference "UserBlock.count", 1 do
 627         post user_blocks_path(:display_name => blocked_user.display_name,
 628                               :user_block_period => "24",
 629                               :user_block => { :needs_view => true, :reason => "Testing deactivates_at" })
 630       end
 631       block = UserBlock.last
 632       assert_equal Time.now.utc + 24.hours, block.ends_at
 633       assert_nil block.deactivates_at
 634
 635       travel 48.hours
 636       session_for(blocked_user)
 637       get user_block_path(block)
 638       block.reload
 639       assert_equal Time.now.utc - 24.hours, block.ends_at
 640       assert_equal Time.now.utc, block.deactivates_at
 641     end
 642   end
 643
 644   def test_dates_when_edited_before_end
 645     blocked_user = create(:user)
 646     moderator_user = create(:moderator_user)
 647
 648     freeze_time do
 649       session_for(moderator_user)
 650       assert_difference "UserBlock.count", 1 do
 651         post user_blocks_path(:display_name => blocked_user.display_name,
 652                               :user_block_period => "48",
 653                               :user_block => { :needs_view => false, :reason => "Testing deactivates_at" })
 654       end
 655       block = UserBlock.last
 656       assert_equal Time.now.utc + 48.hours, block.ends_at
 657       assert_equal Time.now.utc + 48.hours, block.deactivates_at
 658
 659       travel 24.hours
 660       put user_block_path(block,
 661                           :user_block_period => "48",
 662                           :user_block => { :needs_view => false, :reason => "Testing deactivates_at updated" })
 663       block.reload
 664       assert_equal Time.now.utc + 48.hours, block.ends_at
 665       assert_equal Time.now.utc + 48.hours, block.deactivates_at
 666     end
 667   end
 668
 669   def test_dates_when_edited_after_end
 670     blocked_user = create(:user)
 671     moderator_user = create(:moderator_user)
 672
 673     freeze_time do
 674       session_for(moderator_user)
 675       assert_difference "UserBlock.count", 1 do
 676         post user_blocks_path(:display_name => blocked_user.display_name,
 677                               :user_block_period => "24",
 678                               :user_block => { :needs_view => false, :reason => "Testing deactivates_at" })
 679       end
 680       block = UserBlock.last
 681       assert_equal Time.now.utc + 24.hours, block.ends_at
 682       assert_equal Time.now.utc + 24.hours, block.deactivates_at
 683
 684       travel 48.hours
 685       put user_block_path(block,
 686                           :user_block_period => "0",
 687                           :user_block => { :needs_view => false, :reason => "Testing deactivates_at updated" })
 688       block.reload
 689       assert_equal Time.now.utc - 24.hours, block.ends_at
 690       assert_equal Time.now.utc - 24.hours, block.deactivates_at
 691     end
 692   end
 693
 694   ##
 695   # test updates on legacy records without correctly initialized deactivates_at
 696   def test_update_legacy_deactivates_at
 697     blocked_user = create(:user)
 698     moderator_user = create(:moderator_user)
 699
 700     freeze_time do
 701       block = UserBlock.new :user => blocked_user,
 702                             :creator => moderator_user,
 703                             :reason => "because",
 704                             :ends_at => Time.now.utc + 24.hours,
 705                             :needs_view => false
 706
 707       assert_difference "UserBlock.count", 1 do
 708         block.save :validate => false
 709       end
 710
 711       travel 48.hours
 712       session_for(moderator_user)
 713       put user_block_path(block,
 714                           :user_block_period => "0",
 715                           :user_block => { :needs_view => false, :reason => "Testing legacy block update" })
 716       block.reload
 717       assert_equal Time.now.utc - 24.hours, block.ends_at
 718       assert_equal Time.now.utc - 24.hours, block.deactivates_at
 719     end
 720   end
 721
 722   private
 723
 724   def check_block_buttons(block, edit: 0)
 725     [user_blocks_path, user_block_path(block)].each do |path|
 726       get path
 727       assert_response :success
 728       assert_select "a[href='#{edit_user_block_path block}']", :count => edit
 729     end
 730   end
 731
 732   def check_inactive_block_updates(block)
 733     original_ends_at = block.ends_at
 734
 735     put user_block_path(block,
 736                         :user_block_period => "0",
 737                         :user_block => { :needs_view => false, :reason => "Updated Reason" })
 738     assert_redirected_to user_block_path(block)
 739     assert_equal "Block updated.", flash[:notice]
 740     block.reload
 741     assert_not_predicate block, :active?
 742     assert_equal "Updated Reason", block.reason
 743     assert_equal original_ends_at, block.ends_at
 744
 745     put user_block_path(block,
 746                         :user_block_period => "0",
 747                         :user_block => { :needs_view => true, :reason => "Updated Reason Needs View" })
 748     assert_response :success
 749     assert_equal "This block is inactive and cannot be reactivated.", flash[:error]
 750     block.reload
 751     assert_not_predicate block, :active?
 752     assert_equal "Updated Reason", block.reason
 753     assert_equal original_ends_at, block.ends_at
 754
 755     put user_block_path(block,
 756                         :user_block_period => "1",
 757                         :user_block => { :needs_view => false, :reason => "Updated Reason Duration Extended" })
 758     assert_response :success
 759     assert_equal "This block is inactive and cannot be reactivated.", flash[:error]
 760     block.reload
 761     assert_not_predicate block, :active?
 762     assert_equal "Updated Reason", block.reason
 763     assert_equal original_ends_at, block.ends_at
 764
 765     put user_block_path(block,
 766                         :user_block_period => "0",
 767                         :user_block => { :needs_view => false, :reason => "Updated Reason Again" })
 768     assert_redirected_to user_block_path(block)
 769     assert_equal "Block updated.", flash[:notice]
 770     block.reload
 771     assert_not_predicate block, :active?
 772     assert_equal "Updated Reason Again", block.reason
 773     assert_equal original_ends_at, block.ends_at
 774   end
 775 end