test/controllers/user_blocks_controller_test.rb

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