test/controllers/api/user_blocks_controller_test.rb

   1 # frozen_string_literal: true
   2
   3 require "test_helper"
   4
   5 module Api
   6   class UserBlocksControllerTest < ActionDispatch::IntegrationTest
   7     def test_routes
   8       assert_routing(
   9         { :path => "/api/0.6/user_blocks", :method => :post },
  10         { :controller => "api/user_blocks", :action => "create" }
  11       )
  12       assert_routing(
  13         { :path => "/api/0.6/user_blocks/1", :method => :get },
  14         { :controller => "api/user_blocks", :action => "show", :id => "1" }
  15       )
  16       assert_routing(
  17         { :path => "/api/0.6/user_blocks/1.json", :method => :get },
  18         { :controller => "api/user_blocks", :action => "show", :id => "1", :format => "json" }
  19       )
  20     end
  21
  22     def test_show
  23       blocked_user = create(:user)
  24       creator_user = create(:moderator_user)
  25       block = create(:user_block, :user => blocked_user, :creator => creator_user, :reason => "because running tests")
  26
  27       get api_user_block_path(block)
  28       assert_response :success
  29       assert_select "osm>user_block", 1 do
  30         assert_select ">@id", block.id.to_s
  31         assert_select ">user", 1
  32         assert_select ">user>@uid", blocked_user.id.to_s
  33         assert_select ">creator", 1
  34         assert_select ">creator>@uid", creator_user.id.to_s
  35         assert_select ">revoker", 0
  36         assert_select ">reason", 1
  37         assert_select ">reason", "because running tests"
  38       end
  39
  40       get api_user_block_path(block, :format => "json")
  41       assert_response :success
  42       js = ActiveSupport::JSON.decode(@response.body)
  43       assert_not_nil js
  44       assert_equal block.id, js["user_block"]["id"]
  45     end
  46
  47     def test_show_not_found
  48       get api_user_block_path(123)
  49       assert_response :not_found
  50       assert_equal "text/plain", @response.media_type
  51     end
  52
  53     def test_create_no_permission
  54       blocked_user = create(:user)
  55       assert_empty blocked_user.blocks
  56
  57       post api_user_blocks_path(:user => blocked_user.id, :reason => "because", :period => 1)
  58       assert_response :unauthorized
  59       assert_empty blocked_user.blocks
  60
  61       regular_creator_user = create(:user)
  62       auth_header = bearer_authorization_header(regular_creator_user, :scopes => %w[read_prefs])
  63       post api_user_blocks_path(:user => blocked_user.id, :reason => "because", :period => 1), :headers => auth_header
  64       assert_response :forbidden
  65       assert_empty blocked_user.blocks
  66
  67       auth_header = bearer_authorization_header(regular_creator_user, :scopes => %w[read_prefs write_blocks])
  68       post api_user_blocks_path(:user => blocked_user.id, :reason => "because", :period => 1), :headers => auth_header
  69       assert_response :forbidden
  70       assert_empty blocked_user.blocks
  71
  72       moderator_creator_user = create(:moderator_user)
  73       auth_header = bearer_authorization_header(moderator_creator_user, :scopes => %w[read_prefs])
  74       post api_user_blocks_path(:user => blocked_user.id, :reason => "because", :period => 1), :headers => auth_header
  75       assert_response :forbidden
  76       assert_empty blocked_user.blocks
  77     end
  78
  79     def test_create_invalid_because_no_user
  80       blocked_user = create(:user, :deleted)
  81       assert_empty blocked_user.blocks
  82
  83       creator_user = create(:moderator_user)
  84       auth_header = bearer_authorization_header(creator_user, :scopes => %w[read_prefs write_blocks])
  85       post api_user_blocks_path(:reason => "because", :period => 1), :headers => auth_header
  86       assert_response :bad_request
  87       assert_equal "text/plain", @response.media_type
  88       assert_equal "No user was given", @response.body
  89
  90       assert_empty blocked_user.blocks
  91     end
  92
  93     def test_create_invalid_because_user_is_unknown
  94       creator_user = create(:moderator_user)
  95       auth_header = bearer_authorization_header(creator_user, :scopes => %w[read_prefs write_blocks])
  96       post api_user_blocks_path(:user => 0, :reason => "because", :period => 1), :headers => auth_header
  97       assert_response :not_found
  98       assert_equal "text/plain", @response.media_type
  99     end
 100
 101     def test_create_invalid_because_user_is_deleted
 102       blocked_user = create(:user, :deleted)
 103       assert_empty blocked_user.blocks
 104
 105       creator_user = create(:moderator_user)
 106       auth_header = bearer_authorization_header(creator_user, :scopes => %w[read_prefs write_blocks])
 107       post api_user_blocks_path(:user => blocked_user.id, :reason => "because", :period => 1), :headers => auth_header
 108       assert_response :not_found
 109       assert_equal "text/plain", @response.media_type
 110
 111       assert_empty blocked_user.blocks
 112     end
 113
 114     def test_create_invalid_because_missing_reason
 115       create_with_params_and_assert_bad_request("No reason was given", :period => "10")
 116     end
 117
 118     def test_create_invalid_because_missing_period
 119       create_with_params_and_assert_bad_request("No period was given", :reason => "because")
 120     end
 121
 122     def test_create_invalid_because_non_numeric_period
 123       create_with_params_and_assert_bad_request("Period should be a number of hours", :reason => "because", :period => "one hour")
 124     end
 125
 126     def test_create_invalid_because_negative_period
 127       create_with_params_and_assert_bad_request("Period must be between 0 and #{UserBlock::PERIODS.max}", :reason => "go away", :period => "-1")
 128     end
 129
 130     def test_create_invalid_because_excessive_period
 131       create_with_params_and_assert_bad_request("Period must be between 0 and #{UserBlock::PERIODS.max}", :reason => "go away", :period => "10000000")
 132     end
 133
 134     def test_create_invalid_because_unknown_needs_view
 135       create_with_params_and_assert_bad_request("Needs_view must be true if provided", :reason => "because", :period => "1", :needs_view => "maybe")
 136     end
 137
 138     def test_create_success
 139       blocked_user = create(:user)
 140       creator_user = create(:moderator_user)
 141
 142       assert_empty blocked_user.blocks
 143       auth_header = bearer_authorization_header(creator_user, :scopes => %w[read_prefs write_blocks])
 144       post api_user_blocks_path(:user => blocked_user.id, :reason => "because", :period => 1), :headers => auth_header
 145       assert_response :success
 146       assert_equal 1, blocked_user.blocks.length
 147
 148       block = blocked_user.blocks.take
 149       assert_predicate block, :active?
 150       assert_equal "because", block.reason
 151       assert_equal creator_user, block.creator
 152
 153       assert_equal "application/xml", @response.media_type
 154       assert_select "osm>user_block", 1 do
 155         assert_select ">@id", block.id.to_s
 156         assert_select ">@needs_view", "false"
 157         assert_select ">user", 1
 158         assert_select ">user>@uid", blocked_user.id.to_s
 159         assert_select ">creator", 1
 160         assert_select ">creator>@uid", creator_user.id.to_s
 161         assert_select ">revoker", 0
 162         assert_select ">reason", 1
 163         assert_select ">reason", "because"
 164       end
 165     end
 166
 167     def test_create_success_with_needs_view
 168       blocked_user = create(:user)
 169       creator_user = create(:moderator_user)
 170
 171       assert_empty blocked_user.blocks
 172       auth_header = bearer_authorization_header(creator_user, :scopes => %w[read_prefs write_blocks])
 173       post api_user_blocks_path(:user => blocked_user.id, :reason => "because", :period => "1", :needs_view => "true"), :headers => auth_header
 174       assert_response :success
 175       assert_equal 1, blocked_user.blocks.length
 176
 177       block = blocked_user.blocks.take
 178       assert_predicate block, :active?
 179       assert_equal "because", block.reason
 180       assert_equal creator_user, block.creator
 181
 182       assert_equal "application/xml", @response.media_type
 183       assert_select "osm>user_block", 1 do
 184         assert_select ">@id", block.id.to_s
 185         assert_select ">@needs_view", "true"
 186         assert_select ">user", 1
 187         assert_select ">user>@uid", blocked_user.id.to_s
 188         assert_select ">creator", 1
 189         assert_select ">creator>@uid", creator_user.id.to_s
 190         assert_select ">revoker", 0
 191         assert_select ">reason", 1
 192         assert_select ">reason", "because"
 193       end
 194     end
 195
 196     private
 197
 198     def create_with_params_and_assert_bad_request(message, **params)
 199       blocked_user = create(:user)
 200       assert_empty blocked_user.blocks
 201
 202       moderator_creator_user = create(:moderator_user)
 203       auth_header = bearer_authorization_header(moderator_creator_user, :scopes => %w[read_prefs write_blocks])
 204
 205       post api_user_blocks_path({ :user => blocked_user.id }.merge(params)), :headers => auth_header
 206       assert_response :bad_request
 207       assert_equal "text/plain", @response.media_type
 208       assert_equal message, @response.body
 209
 210       assert_empty blocked_user.blocks
 211     end
 212   end
 213 end