test/controllers/users/received_blocks_controller_test.rb

   1 # frozen_string_literal: true
   2
   3 require "test_helper"
   4 require_relative "../user_blocks/table_test_helper"
   5
   6 module Users
   7   class ReceivedBlocksControllerTest < ActionDispatch::IntegrationTest
   8     include UserBlocks::TableTestHelper
   9
  10     ##
  11     # test all routes which lead to this controller
  12     def test_routes
  13       assert_routing(
  14         { :path => "/user/username/blocks", :method => :get },
  15         { :controller => "users/received_blocks", :action => "show", :user_display_name => "username" }
  16       )
  17       assert_routing(
  18         { :path => "/user/username/blocks/edit", :method => :get },
  19         { :controller => "users/received_blocks", :action => "edit", :user_display_name => "username" }
  20       )
  21       assert_routing(
  22         { :path => "/user/username/blocks", :method => :delete },
  23         { :controller => "users/received_blocks", :action => "destroy", :user_display_name => "username" }
  24       )
  25     end
  26
  27     def test_show
  28       blocked_user = create(:user)
  29       unblocked_user = create(:user)
  30       normal_user = create(:user)
  31       active_block = create(:user_block, :user => blocked_user)
  32       revoked_block = create(:user_block, :revoked, :user => blocked_user)
  33       expired_block = create(:user_block, :expired, :user => unblocked_user)
  34
  35       # Asking for a list of blocks with a bogus user name should fail
  36       get user_received_blocks_path("non_existent_user")
  37       assert_response :not_found
  38       assert_template "users/no_such_user"
  39       assert_select "h1", "The user non_existent_user does not exist"
  40
  41       # Check the list of blocks for a user that has never been blocked
  42       get user_received_blocks_path(normal_user)
  43       assert_response :success
  44       assert_select "table#block_list", false
  45       assert_select "p", "#{normal_user.display_name} has not been blocked yet."
  46
  47       # Check the list of blocks for a user that is currently blocked
  48       get user_received_blocks_path(blocked_user)
  49       assert_response :success
  50       assert_select "h1 a[href='#{user_path blocked_user}']", :text => blocked_user.display_name
  51       assert_select "a.active[href='#{user_received_blocks_path blocked_user}']"
  52       assert_select "table#block_list tbody", :count => 1 do
  53         assert_select "tr", 2
  54         assert_select "a[href='#{user_block_path(active_block)}']", 1
  55         assert_select "a[href='#{user_block_path(revoked_block)}']", 1
  56       end
  57
  58       # Check the list of blocks for a user that has previously been blocked
  59       get user_received_blocks_path(unblocked_user)
  60       assert_response :success
  61       assert_select "h1 a[href='#{user_path unblocked_user}']", :text => unblocked_user.display_name
  62       assert_select "a.active[href='#{user_received_blocks_path unblocked_user}']"
  63       assert_select "table#block_list tbody", :count => 1 do
  64         assert_select "tr", 1
  65         assert_select "a[href='#{user_block_path(expired_block)}']", 1
  66       end
  67     end
  68
  69     def test_show_paged
  70       user = create(:user)
  71       user_blocks = create_list(:user_block, 50, :user => user).reverse
  72       next_path = user_received_blocks_path(user)
  73
  74       get next_path
  75       assert_response :success
  76       check_user_blocks_table user_blocks[0...20]
  77       check_no_page_link "Newer Blocks"
  78       next_path = check_page_link "Older Blocks"
  79
  80       get next_path
  81       assert_response :success
  82       check_user_blocks_table user_blocks[20...40]
  83       check_page_link "Newer Blocks"
  84       next_path = check_page_link "Older Blocks"
  85
  86       get next_path
  87       assert_response :success
  88       check_user_blocks_table user_blocks[40...50]
  89       check_page_link "Newer Blocks"
  90       check_no_page_link "Older Blocks"
  91     end
  92
  93     def test_show_invalid_paged
  94       user = create(:user)
  95
  96       %w[-1 fred].each do |id|
  97         get user_received_blocks_path(user, :before => id)
  98         assert_redirected_to :controller => "/errors", :action => :bad_request
  99
 100         get user_received_blocks_path(user, :after => id)
 101         assert_redirected_to :controller => "/errors", :action => :bad_request
 102       end
 103     end
 104
 105     ##
 106     # test the revoke all blocks page
 107     def test_edit
 108       blocked_user = create(:user)
 109       create(:user_block, :user => blocked_user)
 110
 111       # Asking for the revoke all blocks page with a bogus user name should fail
 112       get user_received_blocks_path("non_existent_user")
 113       assert_response :not_found
 114
 115       # Check that the revoke all blocks page requires us to login
 116       get edit_user_received_blocks_path(blocked_user)
 117       assert_redirected_to login_path(:referer => edit_user_received_blocks_path(blocked_user))
 118
 119       # Login as a normal user
 120       session_for(create(:user))
 121
 122       # Check that normal users can't load the revoke all blocks page
 123       get edit_user_received_blocks_path(blocked_user)
 124       assert_redirected_to :controller => "/errors", :action => "forbidden"
 125
 126       # Login as a moderator
 127       session_for(create(:moderator_user))
 128
 129       # Check that the revoke all blocks page loads for moderators
 130       get edit_user_received_blocks_path(blocked_user)
 131       assert_response :success
 132       assert_select "h1 a[href='#{user_path blocked_user}']", :text => blocked_user.display_name
 133     end
 134
 135     ##
 136     # test the revoke all action
 137     def test_destroy
 138       blocked_user = create(:user)
 139       active_block1 = create(:user_block, :user => blocked_user)
 140       active_block2 = create(:user_block, :user => blocked_user)
 141       expired_block1 = create(:user_block, :expired, :user => blocked_user)
 142       blocks = [active_block1, active_block2, expired_block1]
 143       moderator_user = create(:moderator_user)
 144
 145       assert_predicate active_block1, :active?
 146       assert_predicate active_block2, :active?
 147       assert_not_predicate expired_block1, :active?
 148
 149       # Check that normal users can't revoke all blocks
 150       session_for(create(:user))
 151       delete user_received_blocks_path(blocked_user, :confirm => true)
 152       assert_redirected_to :controller => "/errors", :action => "forbidden"
 153
 154       blocks.each(&:reload)
 155       assert_predicate active_block1, :active?
 156       assert_predicate active_block2, :active?
 157       assert_not_predicate expired_block1, :active?
 158
 159       # Check that confirmation is required
 160       session_for(moderator_user)
 161       delete user_received_blocks_path(blocked_user)
 162
 163       blocks.each(&:reload)
 164       assert_predicate active_block1, :active?
 165       assert_predicate active_block2, :active?
 166       assert_not_predicate expired_block1, :active?
 167
 168       # Check that moderators can revoke all blocks
 169       delete user_received_blocks_path(blocked_user, :confirm => true)
 170       assert_redirected_to user_received_blocks_path(blocked_user)
 171
 172       blocks.each(&:reload)
 173       assert_not_predicate active_block1, :active?
 174       assert_not_predicate active_block2, :active?
 175       assert_not_predicate expired_block1, :active?
 176       assert_equal moderator_user, active_block1.revoker
 177       assert_equal moderator_user, active_block2.revoker
 178       assert_not_equal moderator_user, expired_block1.revoker
 179     end
 180   end
 181 end