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     assert_routing(
  58       { :path => "/user/username/blocks/revoke_all", :method => :get },
  59       { :controller => "user_blocks", :action => "revoke_all", :display_name => "username" }
  60     )
  61     assert_routing(
  62       { :path => "/user/username/blocks/revoke_all", :method => :post },
  63       { :controller => "user_blocks", :action => "revoke_all", :display_name => "username" }
  64     )
  65   end
  66
  67   ##
  68   # test the index action
  69   def test_index
  70     revoked_block = create(:user_block, :revoked)
  71
  72     get user_blocks_path
  73     assert_response :success
  74     assert_select "table#block_list tbody tr", :count => 1 do
  75       assert_select "a[href='#{user_path revoked_block.user}']", :text => revoked_block.user.display_name
  76       assert_select "a[href='#{user_path revoked_block.creator}']", :text => revoked_block.creator.display_name
  77       assert_select "a[href='#{user_path revoked_block.revoker}']", :text => revoked_block.revoker.display_name
  78     end
  79
  80     active_block = create(:user_block)
  81     expired_block = create(:user_block, :expired)
  82
  83     get user_blocks_path
  84     assert_response :success
  85     assert_select "table#block_list tbody", :count => 1 do
  86       assert_select "tr", 3
  87       assert_select "a[href='#{user_block_path(active_block)}']", 1
  88       assert_select "a[href='#{user_block_path(expired_block)}']", 1
  89       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
  90     end
  91   end
  92
  93   ##
  94   # test the index action with multiple pages
  95   def test_index_paged
  96     user_blocks = create_list(:user_block, 50).reverse
  97     next_path = user_blocks_path
  98
  99     get next_path
 100     assert_response :success
 101     check_user_blocks_table user_blocks[0...20]
 102     check_no_page_link "Newer Blocks"
 103     next_path = check_page_link "Older Blocks"
 104
 105     get next_path
 106     assert_response :success
 107     check_user_blocks_table user_blocks[20...40]
 108     check_page_link "Newer Blocks"
 109     next_path = check_page_link "Older Blocks"
 110
 111     get next_path
 112     assert_response :success
 113     check_user_blocks_table user_blocks[40...50]
 114     check_page_link "Newer Blocks"
 115     check_no_page_link "Older Blocks"
 116   end
 117
 118   ##
 119   # test the index action with invalid pages
 120   def test_index_invalid_paged
 121     %w[-1 0 fred].each do |id|
 122       get user_blocks_path(:before => id)
 123       assert_redirected_to :controller => :errors, :action => :bad_request
 124
 125       get user_blocks_path(:after => id)
 126       assert_redirected_to :controller => :errors, :action => :bad_request
 127     end
 128   end
 129
 130   ##
 131   # test the show action
 132   def test_show
 133     active_block = create(:user_block, :needs_view)
 134     expired_block = create(:user_block, :expired)
 135     revoked_block = create(:user_block, :revoked)
 136
 137     # Viewing a block should fail when a bogus ID is given
 138     get user_block_path(:id => 99999)
 139     assert_response :not_found
 140     assert_template "not_found"
 141     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
 142
 143     # Viewing an expired block should work
 144     get user_block_path(:id => expired_block)
 145     assert_response :success
 146     assert_select "h1 a[href='#{user_path expired_block.user}']", :text => expired_block.user.display_name
 147     assert_select "h1 a[href='#{user_path expired_block.creator}']", :text => expired_block.creator.display_name
 148
 149     # Viewing a revoked block should work
 150     get user_block_path(:id => revoked_block)
 151     assert_response :success
 152     assert_select "h1 a[href='#{user_path revoked_block.user}']", :text => revoked_block.user.display_name
 153     assert_select "h1 a[href='#{user_path revoked_block.creator}']", :text => revoked_block.creator.display_name
 154     assert_select "a[href='#{user_path revoked_block.revoker}']", :text => revoked_block.revoker.display_name
 155
 156     # Viewing an active block should work, but shouldn't mark it as seen
 157     get user_block_path(:id => active_block)
 158     assert_response :success
 159     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
 160     assert_select "h1 a[href='#{user_path active_block.creator}']", :text => active_block.creator.display_name
 161     assert UserBlock.find(active_block.id).needs_view
 162
 163     # Login as the blocked user
 164     session_for(active_block.user)
 165
 166     # Now viewing it should mark it as seen
 167     get user_block_path(:id => active_block)
 168     assert_response :success
 169     assert_not UserBlock.find(active_block.id).needs_view
 170   end
 171
 172   ##
 173   # test the new action
 174   def test_new
 175     target_user = create(:user)
 176
 177     # Check that the block creation page requires us to login
 178     get new_user_block_path(target_user)
 179     assert_redirected_to login_path(:referer => new_user_block_path(target_user))
 180
 181     # Login as a normal user
 182     session_for(create(:user))
 183
 184     # Check that normal users can't load the block creation page
 185     get new_user_block_path(target_user)
 186     assert_redirected_to :controller => "errors", :action => "forbidden"
 187
 188     # Login as a moderator
 189     session_for(create(:moderator_user))
 190
 191     # Check that the block creation page loads for moderators
 192     get new_user_block_path(target_user)
 193     assert_response :success
 194     assert_select "h1 a[href='#{user_path target_user}']", :text => target_user.display_name
 195     assert_select "form#new_user_block", :count => 1 do
 196       assert_select "textarea#user_block_reason", :count => 1
 197       assert_select "select#user_block_period", :count => 1
 198       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
 199       assert_select "input#display_name[type='hidden']", :count => 1
 200       assert_select "input[type='submit'][value='Create block']", :count => 1
 201     end
 202
 203     # We should get an error if the user doesn't exist
 204     get new_user_block_path(:display_name => "non_existent_user")
 205     assert_response :not_found
 206     assert_template "users/no_such_user"
 207     assert_select "h1", "The user non_existent_user does not exist"
 208   end
 209
 210   ##
 211   # test the edit action
 212   def test_edit
 213     active_block = create(:user_block)
 214
 215     # Check that the block edit page requires us to login
 216     get edit_user_block_path(:id => active_block)
 217     assert_redirected_to login_path(:referer => edit_user_block_path(active_block))
 218
 219     # Login as a normal user
 220     session_for(create(:user))
 221
 222     # Check that normal users can't load the block edit page
 223     get edit_user_block_path(:id => active_block)
 224     assert_redirected_to :controller => "errors", :action => "forbidden"
 225
 226     # Login as a moderator
 227     session_for(create(:moderator_user))
 228
 229     # Check that the block edit page loads for moderators
 230     get edit_user_block_path(:id => active_block)
 231     assert_response :success
 232     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
 233     assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
 234       assert_select "textarea#user_block_reason", :count => 1
 235       assert_select "select#user_block_period", :count => 1
 236       assert_select "input#user_block_needs_view[type='checkbox']", :count => 1
 237       assert_select "input[type='submit'][value='Update block']", :count => 1
 238     end
 239
 240     # We should get an error if the user doesn't exist
 241     get edit_user_block_path(:id => 99999)
 242     assert_response :not_found
 243     assert_template "not_found"
 244     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
 245   end
 246
 247   ##
 248   # test the edit action when the remaining block duration doesn't match the available select options
 249   def test_edit_duration
 250     moderator_user = create(:moderator_user)
 251
 252     freeze_time do
 253       active_block = create(:user_block, :creator => moderator_user, :ends_at => Time.now.utc + 96.hours)
 254
 255       session_for(moderator_user)
 256       get edit_user_block_path(active_block)
 257
 258       assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
 259         assert_select "select#user_block_period", :count => 1 do
 260           assert_select "option[value='96'][selected]", :count => 1
 261         end
 262       end
 263
 264       travel 2.hours
 265       get edit_user_block_path(active_block)
 266
 267       assert_select "form#edit_user_block_#{active_block.id}", :count => 1 do
 268         assert_select "select#user_block_period", :count => 1 do
 269           assert_select "option[value='96'][selected]", :count => 1
 270         end
 271       end
 272     end
 273   end
 274
 275   ##
 276   # test the create action
 277   def test_create
 278     target_user = create(:user)
 279     moderator_user = create(:moderator_user)
 280
 281     # Not logged in yet, so creating a block should fail
 282     post user_blocks_path
 283     assert_response :forbidden
 284
 285     # Login as a normal user
 286     session_for(create(:user))
 287
 288     # Check that normal users can't create blocks
 289     post user_blocks_path
 290     assert_redirected_to :controller => "errors", :action => "forbidden"
 291
 292     # Login as a moderator
 293     session_for(moderator_user)
 294
 295     # A bogus block period should result in an error
 296     assert_no_difference "UserBlock.count" do
 297       post user_blocks_path(:display_name => target_user.display_name,
 298                             :user_block_period => "99")
 299     end
 300     assert_redirected_to new_user_block_path(target_user)
 301     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
 302
 303     # Check that creating a block works
 304     assert_difference "UserBlock.count", 1 do
 305       post user_blocks_path(:display_name => target_user.display_name,
 306                             :user_block_period => "12",
 307                             :user_block => { :needs_view => false, :reason => "Vandalism" })
 308     end
 309     id = UserBlock.order(:id).ids.last
 310     assert_redirected_to user_block_path(:id => id)
 311     assert_equal "Created a block on user #{target_user.display_name}.", flash[:notice]
 312     b = UserBlock.find(id)
 313     assert_in_delta Time.now.utc, b.created_at, 1
 314     assert_in_delta Time.now.utc, b.updated_at, 1
 315     assert_in_delta Time.now.utc + 12.hours, b.ends_at, 1
 316     assert_not b.needs_view
 317     assert_equal "Vandalism", b.reason
 318     assert_equal "markdown", b.reason_format
 319     assert_equal moderator_user.id, b.creator_id
 320
 321     # We should get an error if no user is specified
 322     post user_blocks_path
 323     assert_response :not_found
 324     assert_template "users/no_such_user"
 325     assert_select "h1", "The user  does not exist"
 326
 327     # We should get an error if the user doesn't exist
 328     post user_blocks_path(:display_name => "non_existent_user")
 329     assert_response :not_found
 330     assert_template "users/no_such_user"
 331     assert_select "h1", "The user non_existent_user does not exist"
 332   end
 333
 334   ##
 335   # test the duration of a created block
 336   def test_create_duration
 337     target_user = create(:user)
 338     moderator_user = create(:moderator_user)
 339
 340     session_for(moderator_user)
 341     post user_blocks_path(:display_name => target_user.display_name,
 342                           :user_block_period => "336",
 343                           :user_block => { :needs_view => false, :reason => "Vandalism" })
 344
 345     block = UserBlock.order(:id).last
 346     assert_equal 1209600, block.ends_at - block.created_at
 347   end
 348
 349   ##
 350   # test the update action
 351   def test_update
 352     moderator_user = create(:moderator_user)
 353     second_moderator_user = create(:moderator_user)
 354     active_block = create(:user_block, :creator => moderator_user)
 355
 356     # Not logged in yet, so updating a block should fail
 357     put user_block_path(:id => active_block)
 358     assert_response :forbidden
 359
 360     # Login as a normal user
 361     session_for(create(:user))
 362
 363     # Check that normal users can't update blocks
 364     put user_block_path(:id => active_block)
 365     assert_redirected_to :controller => "errors", :action => "forbidden"
 366
 367     # Login as the wrong moderator
 368     session_for(second_moderator_user)
 369
 370     # Check that only the person who created a block can update it
 371     assert_no_difference "UserBlock.count" do
 372       put user_block_path(:id => active_block,
 373                           :user_block_period => "12",
 374                           :user_block => { :needs_view => true, :reason => "Vandalism" })
 375     end
 376     assert_redirected_to edit_user_block_path(active_block)
 377     assert_equal "Only the moderator who created this block can edit it.", flash[:error]
 378
 379     # Login as the correct moderator
 380     session_for(moderator_user)
 381
 382     # A bogus block period should result in an error
 383     assert_no_difference "UserBlock.count" do
 384       put user_block_path(:id => active_block, :user_block_period => "99")
 385     end
 386     assert_redirected_to edit_user_block_path(active_block)
 387     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
 388
 389     # Check that updating a block works
 390     assert_no_difference "UserBlock.count" do
 391       put user_block_path(:id => active_block,
 392                           :user_block_period => "12",
 393                           :user_block => { :needs_view => true, :reason => "Vandalism" })
 394     end
 395     assert_redirected_to user_block_path(active_block)
 396     assert_equal "Block updated.", flash[:notice]
 397     b = UserBlock.find(active_block.id)
 398     assert_in_delta Time.now.utc, b.updated_at, 1
 399     assert b.needs_view
 400     assert_equal "Vandalism", b.reason
 401
 402     # We should get an error if the block doesn't exist
 403     put user_block_path(:id => 99999)
 404     assert_response :not_found
 405     assert_template "not_found"
 406     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
 407   end
 408
 409   ##
 410   # test the revoke action
 411   def test_revoke
 412     active_block = create(:user_block)
 413
 414     # Check that the block revoke page requires us to login
 415     get revoke_user_block_path(:id => active_block)
 416     assert_redirected_to login_path(:referer => revoke_user_block_path(:id => active_block))
 417
 418     # Login as a normal user
 419     session_for(create(:user))
 420
 421     # Check that normal users can't load the block revoke page
 422     get revoke_user_block_path(:id => active_block)
 423     assert_redirected_to :controller => "errors", :action => "forbidden"
 424
 425     # Login as a moderator
 426     session_for(create(:moderator_user))
 427
 428     # Check that the block revoke page loads for moderators
 429     get revoke_user_block_path(:id => active_block)
 430     assert_response :success
 431     assert_template "revoke"
 432     assert_select "h1 a[href='#{user_path active_block.user}']", :text => active_block.user.display_name
 433     assert_select "form", :count => 1 do
 434       assert_select "input#confirm[type='checkbox']", :count => 1
 435       assert_select "input[type='submit'][value='Revoke!']", :count => 1
 436     end
 437
 438     # Check that revoking a block using GET should fail
 439     get revoke_user_block_path(:id => active_block, :confirm => true)
 440     assert_response :success
 441     assert_template "revoke"
 442     b = UserBlock.find(active_block.id)
 443     assert_operator b.ends_at - Time.now.utc, :>, 100
 444
 445     # Check that revoking a block works using POST
 446     post revoke_user_block_path(:id => active_block, :confirm => true)
 447     assert_redirected_to user_block_path(active_block)
 448     b = UserBlock.find(active_block.id)
 449     assert_in_delta Time.now.utc, b.ends_at, 1
 450
 451     # We should get an error if the block doesn't exist
 452     get revoke_user_block_path(:id => 99999)
 453     assert_response :not_found
 454     assert_template "not_found"
 455     assert_select "p", "Sorry, the user block with ID 99999 could not be found."
 456   end
 457
 458   ##
 459   # test the revoke all page
 460   def test_revoke_all_page
 461     blocked_user = create(:user)
 462     create(:user_block, :user => blocked_user)
 463
 464     # Asking for the revoke all blocks page with a bogus user name should fail
 465     get user_blocks_on_path("non_existent_user")
 466     assert_response :not_found
 467
 468     # Check that the revoke all blocks page requires us to login
 469     get revoke_all_user_blocks_path(blocked_user)
 470     assert_redirected_to login_path(:referer => revoke_all_user_blocks_path(blocked_user))
 471
 472     # Login as a normal user
 473     session_for(create(:user))
 474
 475     # Check that normal users can't load the revoke all blocks page
 476     get revoke_all_user_blocks_path(blocked_user)
 477     assert_redirected_to :controller => "errors", :action => "forbidden"
 478
 479     # Login as a moderator
 480     session_for(create(:moderator_user))
 481
 482     # Check that the revoke all blocks page loads for moderators
 483     get revoke_all_user_blocks_path(blocked_user)
 484     assert_response :success
 485     assert_select "h1 a[href='#{user_path blocked_user}']", :text => blocked_user.display_name
 486   end
 487
 488   ##
 489   # test the revoke all action
 490   def test_revoke_all_action
 491     blocked_user = create(:user)
 492     active_block1 = create(:user_block, :user => blocked_user)
 493     active_block2 = create(:user_block, :user => blocked_user)
 494     expired_block1 = create(:user_block, :expired, :user => blocked_user)
 495     blocks = [active_block1, active_block2, expired_block1]
 496     moderator_user = create(:moderator_user)
 497
 498     assert_predicate active_block1, :active?
 499     assert_predicate active_block2, :active?
 500     assert_not_predicate expired_block1, :active?
 501
 502     # Login as a normal user
 503     session_for(create(:user))
 504
 505     # Check that normal users can't load the block revoke page
 506     get revoke_all_user_blocks_path(:blocked_user)
 507     assert_redirected_to :controller => "errors", :action => "forbidden"
 508
 509     # Login as a moderator
 510     session_for(moderator_user)
 511
 512     # Check that revoking blocks using GET should fail
 513     get revoke_all_user_blocks_path(blocked_user, :confirm => true)
 514     assert_response :success
 515     assert_template "revoke_all"
 516
 517     blocks.each(&:reload)
 518     assert_predicate active_block1, :active?
 519     assert_predicate active_block2, :active?
 520     assert_not_predicate expired_block1, :active?
 521
 522     # Check that revoking blocks works using POST
 523     post revoke_all_user_blocks_path(blocked_user, :confirm => true)
 524     assert_redirected_to user_blocks_on_path(blocked_user)
 525
 526     blocks.each(&:reload)
 527     assert_not_predicate active_block1, :active?
 528     assert_not_predicate active_block2, :active?
 529     assert_not_predicate expired_block1, :active?
 530     assert_equal moderator_user, active_block1.revoker
 531     assert_equal moderator_user, active_block2.revoker
 532     assert_not_equal moderator_user, expired_block1.revoker
 533   end
 534
 535   ##
 536   # test the blocks_on action
 537   def test_blocks_on
 538     blocked_user = create(:user)
 539     unblocked_user = create(:user)
 540     normal_user = create(:user)
 541     active_block = create(:user_block, :user => blocked_user)
 542     revoked_block = create(:user_block, :revoked, :user => blocked_user)
 543     expired_block = create(:user_block, :expired, :user => unblocked_user)
 544
 545     # Asking for a list of blocks with a bogus user name should fail
 546     get user_blocks_on_path("non_existent_user")
 547     assert_response :not_found
 548     assert_template "users/no_such_user"
 549     assert_select "h1", "The user non_existent_user does not exist"
 550
 551     # Check the list of blocks for a user that has never been blocked
 552     get user_blocks_on_path(normal_user)
 553     assert_response :success
 554     assert_select "table#block_list", false
 555     assert_select "p", "#{normal_user.display_name} has not been blocked yet."
 556
 557     # Check the list of blocks for a user that is currently blocked
 558     get user_blocks_on_path(blocked_user)
 559     assert_response :success
 560     assert_select "h1 a[href='#{user_path blocked_user}']", :text => blocked_user.display_name
 561     assert_select "table#block_list tbody", :count => 1 do
 562       assert_select "tr", 2
 563       assert_select "a[href='#{user_block_path(active_block)}']", 1
 564       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
 565     end
 566
 567     # Check the list of blocks for a user that has previously been blocked
 568     get user_blocks_on_path(unblocked_user)
 569     assert_response :success
 570     assert_select "h1 a[href='#{user_path unblocked_user}']", :text => unblocked_user.display_name
 571     assert_select "table#block_list tbody", :count => 1 do
 572       assert_select "tr", 1
 573       assert_select "a[href='#{user_block_path(expired_block)}']", 1
 574     end
 575   end
 576
 577   ##
 578   # test the blocks_on action with multiple pages
 579   def test_blocks_on_paged
 580     user = create(:user)
 581     user_blocks = create_list(:user_block, 50, :user => user).reverse
 582     next_path = user_blocks_on_path(user)
 583
 584     get next_path
 585     assert_response :success
 586     check_user_blocks_table user_blocks[0...20]
 587     check_no_page_link "Newer Blocks"
 588     next_path = check_page_link "Older Blocks"
 589
 590     get next_path
 591     assert_response :success
 592     check_user_blocks_table user_blocks[20...40]
 593     check_page_link "Newer Blocks"
 594     next_path = check_page_link "Older Blocks"
 595
 596     get next_path
 597     assert_response :success
 598     check_user_blocks_table user_blocks[40...50]
 599     check_page_link "Newer Blocks"
 600     check_no_page_link "Older Blocks"
 601   end
 602
 603   ##
 604   # test the blocks_on action with invalid pages
 605   def test_blocks_on_invalid_paged
 606     user = create(:user)
 607
 608     %w[-1 0 fred].each do |id|
 609       get user_blocks_on_path(user, :before => id)
 610       assert_redirected_to :controller => :errors, :action => :bad_request
 611
 612       get user_blocks_on_path(user, :after => id)
 613       assert_redirected_to :controller => :errors, :action => :bad_request
 614     end
 615   end
 616
 617   ##
 618   # test the blocks_by action
 619   def test_blocks_by
 620     moderator_user = create(:moderator_user)
 621     second_moderator_user = create(:moderator_user)
 622     normal_user = create(:user)
 623     active_block = create(:user_block, :creator => moderator_user)
 624     expired_block = create(:user_block, :expired, :creator => second_moderator_user)
 625     revoked_block = create(:user_block, :revoked, :creator => second_moderator_user)
 626
 627     # Asking for a list of blocks with a bogus user name should fail
 628     get user_blocks_by_path("non_existent_user")
 629     assert_response :not_found
 630     assert_template "users/no_such_user"
 631     assert_select "h1", "The user non_existent_user does not exist"
 632
 633     # Check the list of blocks given by one moderator
 634     get user_blocks_by_path(moderator_user)
 635     assert_response :success
 636     assert_select "h1 a[href='#{user_path moderator_user}']", :text => moderator_user.display_name
 637     assert_select "table#block_list tbody", :count => 1 do
 638       assert_select "tr", 1
 639       assert_select "a[href='#{user_block_path(active_block)}']", 1
 640     end
 641
 642     # Check the list of blocks given by a different moderator
 643     get user_blocks_by_path(second_moderator_user)
 644     assert_response :success
 645     assert_select "h1 a[href='#{user_path second_moderator_user}']", :text => second_moderator_user.display_name
 646     assert_select "table#block_list tbody", :count => 1 do
 647       assert_select "tr", 2
 648       assert_select "a[href='#{user_block_path(expired_block)}']", 1
 649       assert_select "a[href='#{user_block_path(revoked_block)}']", 1
 650     end
 651
 652     # Check the list of blocks (not) given by a normal user
 653     get user_blocks_by_path(normal_user)
 654     assert_response :success
 655     assert_select "table#block_list", false
 656     assert_select "p", "#{normal_user.display_name} has not made any blocks yet."
 657   end
 658
 659   ##
 660   # test the blocks_by action with multiple pages
 661   def test_blocks_by_paged
 662     user = create(:moderator_user)
 663     user_blocks = create_list(:user_block, 50, :creator => user).reverse
 664     next_path = user_blocks_by_path(user)
 665
 666     get next_path
 667     assert_response :success
 668     check_user_blocks_table user_blocks[0...20]
 669     check_no_page_link "Newer Blocks"
 670     next_path = check_page_link "Older Blocks"
 671
 672     get next_path
 673     assert_response :success
 674     check_user_blocks_table user_blocks[20...40]
 675     check_page_link "Newer Blocks"
 676     next_path = check_page_link "Older Blocks"
 677
 678     get next_path
 679     assert_response :success
 680     check_user_blocks_table user_blocks[40...50]
 681     check_page_link "Newer Blocks"
 682     check_no_page_link "Older Blocks"
 683   end
 684
 685   ##
 686   # test the blocks_by action with invalid pages
 687   def test_blocks_by_invalid_paged
 688     user = create(:moderator_user)
 689
 690     %w[-1 0 fred].each do |id|
 691       get user_blocks_by_path(user, :before => id)
 692       assert_redirected_to :controller => :errors, :action => :bad_request
 693
 694       get user_blocks_by_path(user, :after => id)
 695       assert_redirected_to :controller => :errors, :action => :bad_request
 696     end
 697   end
 698
 699   private
 700
 701   def check_user_blocks_table(user_blocks)
 702     assert_dom "table#block_list tbody tr" do |rows|
 703       assert_equal user_blocks.count, rows.count, "unexpected number of rows in user blocks table"
 704       rows.zip(user_blocks).map do |row, user_block|
 705         assert_dom row, "a[href='#{user_block_path user_block}']", 1
 706       end
 707     end
 708   end
 709
 710   def check_no_page_link(name)
 711     assert_select "a.page-link", { :text => /#{Regexp.quote(name)}/, :count => 0 }, "unexpected #{name} page link"
 712   end
 713
 714   def check_page_link(name)
 715     assert_select "a.page-link", { :text => /#{Regexp.quote(name)}/ }, "missing #{name} page link" do |buttons|
 716       return buttons.first.attributes["href"].value
 717     end
 718   end
 719 end