test/controllers/api/changeset_comments_controller_test.rb

   1 require "test_helper"
   2
   3 module Api
   4   class ChangesetCommentsControllerTest < ActionDispatch::IntegrationTest
   5     ##
   6     # test all routes which lead to this controller
   7     def test_routes
   8       assert_routing(
   9         { :path => "/api/0.6/changeset/1/comment", :method => :post },
  10         { :controller => "api/changeset_comments", :action => "create", :id => "1" }
  11       )
  12       assert_routing(
  13         { :path => "/api/0.6/changeset/1/comment.json", :method => :post },
  14         { :controller => "api/changeset_comments", :action => "create", :id => "1", :format => "json" }
  15       )
  16       assert_routing(
  17         { :path => "/api/0.6/changeset/comment/1/hide", :method => :post },
  18         { :controller => "api/changeset_comments", :action => "destroy", :id => "1" }
  19       )
  20       assert_routing(
  21         { :path => "/api/0.6/changeset/comment/1/hide.json", :method => :post },
  22         { :controller => "api/changeset_comments", :action => "destroy", :id => "1", :format => "json" }
  23       )
  24       assert_routing(
  25         { :path => "/api/0.6/changeset/comment/1/unhide", :method => :post },
  26         { :controller => "api/changeset_comments", :action => "restore", :id => "1" }
  27       )
  28       assert_routing(
  29         { :path => "/api/0.6/changeset/comment/1/unhide.json", :method => :post },
  30         { :controller => "api/changeset_comments", :action => "restore", :id => "1", :format => "json" }
  31       )
  32     end
  33
  34     def test_create_by_unauthorized
  35       assert_no_difference "ChangesetComment.count" do
  36         post changeset_comment_path(create(:changeset, :closed), :text => "This is a comment")
  37         assert_response :unauthorized
  38       end
  39     end
  40
  41     def test_create_on_missing_changeset
  42       assert_no_difference "ChangesetComment.count" do
  43         post changeset_comment_path(999111, :text => "This is a comment"), :headers => bearer_authorization_header
  44         assert_response :not_found
  45       end
  46     end
  47
  48     def test_create_on_open_changeset
  49       assert_no_difference "ChangesetComment.count" do
  50         post changeset_comment_path(create(:changeset), :text => "This is a comment"), :headers => bearer_authorization_header
  51         assert_response :conflict
  52       end
  53     end
  54
  55     def test_create_without_text
  56       assert_no_difference "ChangesetComment.count" do
  57         post changeset_comment_path(create(:changeset, :closed)), :headers => bearer_authorization_header
  58         assert_response :bad_request
  59       end
  60     end
  61
  62     def test_create_with_empty_text
  63       assert_no_difference "ChangesetComment.count" do
  64         post changeset_comment_path(create(:changeset, :closed), :text => ""), :headers => bearer_authorization_header
  65         assert_response :bad_request
  66       end
  67     end
  68
  69     def test_create_when_not_agreed_to_terms
  70       user = create(:user, :terms_agreed => nil)
  71       auth_header = bearer_authorization_header user
  72       changeset = create(:changeset, :closed)
  73
  74       assert_difference "ChangesetComment.count", 0 do
  75         post changeset_comment_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
  76         assert_response :forbidden
  77       end
  78     end
  79
  80     def test_create_without_required_scope
  81       user = create(:user)
  82       auth_header = bearer_authorization_header user, :scopes => %w[read_prefs]
  83       changeset = create(:changeset, :closed)
  84
  85       assert_difference "ChangesetComment.count", 0 do
  86         post changeset_comment_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
  87         assert_response :forbidden
  88       end
  89     end
  90
  91     def test_create_with_write_changeset_comments_scope
  92       user = create(:user)
  93       auth_header = bearer_authorization_header user, :scopes => %w[write_changeset_comments]
  94       changeset = create(:changeset, :closed)
  95
  96       assert_difference "ChangesetComment.count", 1 do
  97         post changeset_comment_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
  98         assert_response :success
  99       end
 100
 101       comment = ChangesetComment.last
 102       assert_equal changeset.id, comment.changeset_id
 103       assert_equal user.id, comment.author_id
 104       assert_equal "This is a comment", comment.body
 105       assert comment.visible
 106     end
 107
 108     def test_create_with_write_api_scope
 109       user = create(:user)
 110       auth_header = bearer_authorization_header user, :scopes => %w[write_api]
 111       changeset = create(:changeset, :closed)
 112
 113       assert_difference "ChangesetComment.count", 1 do
 114         post changeset_comment_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
 115         assert_response :success
 116       end
 117
 118       comment = ChangesetComment.last
 119       assert_equal changeset.id, comment.changeset_id
 120       assert_equal user.id, comment.author_id
 121       assert_equal "This is a comment", comment.body
 122       assert comment.visible
 123     end
 124
 125     def test_create_on_changeset_with_no_subscribers
 126       changeset = create(:changeset, :closed)
 127       auth_header = bearer_authorization_header
 128
 129       assert_difference "ChangesetComment.count", 1 do
 130         assert_no_difference "ActionMailer::Base.deliveries.size" do
 131           perform_enqueued_jobs do
 132             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 133             assert_response :success
 134           end
 135         end
 136       end
 137     end
 138
 139     def test_create_on_changeset_with_commenter_subscriber
 140       user = create(:user)
 141       changeset = create(:changeset, :closed, :user => user)
 142       changeset.subscribers << user
 143       auth_header = bearer_authorization_header user
 144
 145       assert_difference "ChangesetComment.count", 1 do
 146         assert_no_difference "ActionMailer::Base.deliveries.size" do
 147           perform_enqueued_jobs do
 148             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 149             assert_response :success
 150           end
 151         end
 152       end
 153     end
 154
 155     def test_create_on_changeset_with_invisible_subscribers
 156       changeset = create(:changeset, :closed)
 157       changeset.subscribers << create(:user, :suspended)
 158       changeset.subscribers << create(:user, :deleted)
 159       auth_header = bearer_authorization_header
 160
 161       assert_difference "ChangesetComment.count", 1 do
 162         assert_no_difference "ActionMailer::Base.deliveries.size" do
 163           perform_enqueued_jobs do
 164             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 165             assert_response :success
 166           end
 167         end
 168       end
 169     end
 170
 171     def test_create_on_changeset_with_changeset_creator_subscriber
 172       creator_user = create(:user)
 173       changeset = create(:changeset, :closed, :user => creator_user)
 174       changeset.subscribers << creator_user
 175       commenter_user = create(:user)
 176       auth_header = bearer_authorization_header commenter_user
 177
 178       assert_difference "ChangesetComment.count", 1 do
 179         assert_difference "ActionMailer::Base.deliveries.size", 1 do
 180           perform_enqueued_jobs do
 181             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 182             assert_response :success
 183           end
 184         end
 185       end
 186
 187       email = ActionMailer::Base.deliveries.first
 188       assert_equal 1, email.to.length
 189       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on one of your changesets", email.subject
 190       assert_equal creator_user.email, email.to.first
 191
 192       ActionMailer::Base.deliveries.clear
 193     end
 194
 195     def test_create_on_changeset_with_changeset_creator_and_other_user_subscribers
 196       creator_user = create(:user)
 197       changeset = create(:changeset, :closed, :user => creator_user)
 198       changeset.subscribers << creator_user
 199       other_user = create(:user)
 200       changeset.subscribers << other_user
 201       commenter_user = create(:user)
 202       auth_header = bearer_authorization_header commenter_user
 203
 204       assert_difference "ChangesetComment.count", 1 do
 205         assert_difference "ActionMailer::Base.deliveries.size", 2 do
 206           perform_enqueued_jobs do
 207             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 208             assert_response :success
 209           end
 210         end
 211       end
 212
 213       email = ActionMailer::Base.deliveries.find { |e| e.to.first == creator_user.email }
 214       assert_not_nil email
 215       assert_equal 1, email.to.length
 216       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on one of your changesets", email.subject
 217
 218       email = ActionMailer::Base.deliveries.find { |e| e.to.first == other_user.email }
 219       assert_not_nil email
 220       assert_equal 1, email.to.length
 221       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on a changeset you are interested in", email.subject
 222
 223       ActionMailer::Base.deliveries.clear
 224     end
 225
 226     ##
 227     # create comment rate limit for new users
 228     def test_create_by_new_user_with_rate_limit
 229       changeset = create(:changeset, :closed)
 230       user = create(:user)
 231
 232       auth_header = bearer_authorization_header user
 233
 234       assert_difference "ChangesetComment.count", Settings.initial_changeset_comments_per_hour do
 235         1.upto(Settings.initial_changeset_comments_per_hour) do |count|
 236           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 237           assert_response :success
 238         end
 239       end
 240
 241       assert_no_difference "ChangesetComment.count" do
 242         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 243         assert_response :too_many_requests
 244       end
 245     end
 246
 247     ##
 248     # create comment rate limit for experienced users
 249     def test_create_by_experienced_user_with_rate_limit
 250       changeset = create(:changeset, :closed)
 251       user = create(:user)
 252       create_list(:changeset_comment, Settings.comments_to_max_changeset_comments, :author_id => user.id, :created_at => Time.now.utc - 1.day)
 253
 254       auth_header = bearer_authorization_header user
 255
 256       assert_difference "ChangesetComment.count", Settings.max_changeset_comments_per_hour do
 257         1.upto(Settings.max_changeset_comments_per_hour) do |count|
 258           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 259           assert_response :success
 260         end
 261       end
 262
 263       assert_no_difference "ChangesetComment.count" do
 264         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 265         assert_response :too_many_requests
 266       end
 267     end
 268
 269     ##
 270     # create comment rate limit for reported users
 271     def test_create_by_reported_user_with_rate_limit
 272       changeset = create(:changeset, :closed)
 273       user = create(:user)
 274       create(:issue_with_reports, :reportable => user, :reported_user => user)
 275
 276       auth_header = bearer_authorization_header user
 277
 278       assert_difference "ChangesetComment.count", Settings.initial_changeset_comments_per_hour / 2 do
 279         1.upto(Settings.initial_changeset_comments_per_hour / 2) do |count|
 280           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 281           assert_response :success
 282         end
 283       end
 284
 285       assert_no_difference "ChangesetComment.count" do
 286         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 287         assert_response :too_many_requests
 288       end
 289     end
 290
 291     ##
 292     # create comment rate limit for moderator users
 293     def test_create_by_moderator_user_with_rate_limit
 294       changeset = create(:changeset, :closed)
 295       user = create(:moderator_user)
 296
 297       auth_header = bearer_authorization_header user
 298
 299       assert_difference "ChangesetComment.count", Settings.moderator_changeset_comments_per_hour do
 300         1.upto(Settings.moderator_changeset_comments_per_hour) do |count|
 301           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 302           assert_response :success
 303         end
 304       end
 305
 306       assert_no_difference "ChangesetComment.count" do
 307         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 308         assert_response :too_many_requests
 309       end
 310     end
 311
 312     def test_hide_by_unauthorized
 313       comment = create(:changeset_comment)
 314
 315       post changeset_comment_hide_path(comment)
 316
 317       assert_response :unauthorized
 318       assert comment.reload.visible
 319     end
 320
 321     def test_hide_by_normal_user
 322       comment = create(:changeset_comment)
 323       auth_header = bearer_authorization_header
 324
 325       post changeset_comment_hide_path(comment), :headers => auth_header
 326
 327       assert_response :forbidden
 328       assert comment.reload.visible
 329     end
 330
 331     def test_hide_missing_comment
 332       auth_header = bearer_authorization_header create(:moderator_user)
 333
 334       post changeset_comment_hide_path(999111), :headers => auth_header
 335
 336       assert_response :not_found
 337     end
 338
 339     def test_hide_without_required_scope
 340       comment = create(:changeset_comment)
 341       auth_header = bearer_authorization_header create(:moderator_user), :scopes => %w[read_prefs]
 342
 343       post changeset_comment_hide_path(comment), :headers => auth_header
 344
 345       assert_response :forbidden
 346       assert comment.reload.visible
 347     end
 348
 349     def test_hide_with_write_changeset_comments_scope
 350       comment = create(:changeset_comment)
 351       auth_header = bearer_authorization_header create(:moderator_user), :scopes => %w[write_changeset_comments]
 352
 353       post changeset_comment_hide_path(comment), :headers => auth_header
 354
 355       assert_response :success
 356       assert_not comment.reload.visible
 357     end
 358
 359     def test_hide_with_write_api_scope
 360       comment = create(:changeset_comment)
 361       auth_header = bearer_authorization_header create(:moderator_user), :scopes => %w[write_api]
 362
 363       post changeset_comment_hide_path(comment), :headers => auth_header
 364
 365       assert_response :success
 366       assert_not comment.reload.visible
 367     end
 368
 369     def test_unhide_by_unauthorized
 370       comment = create(:changeset_comment, :visible => false)
 371
 372       post changeset_comment_unhide_path(comment)
 373
 374       assert_response :unauthorized
 375       assert_not comment.reload.visible
 376     end
 377
 378     def test_unhide_by_normal_user
 379       comment = create(:changeset_comment, :visible => false)
 380       auth_header = bearer_authorization_header
 381
 382       post changeset_comment_unhide_path(comment), :headers => auth_header
 383
 384       assert_response :forbidden
 385       assert_not comment.reload.visible
 386     end
 387
 388     def test_unhide_missing_comment
 389       auth_header = bearer_authorization_header create(:moderator_user)
 390
 391       post changeset_comment_unhide_path(999111), :headers => auth_header
 392
 393       assert_response :not_found
 394     end
 395
 396     def test_unhide_without_required_scope
 397       comment = create(:changeset_comment, :visible => false)
 398       auth_header = bearer_authorization_header create(:moderator_user), :scopes => %w[read_prefs]
 399
 400       post changeset_comment_unhide_path(comment), :headers => auth_header
 401
 402       assert_response :forbidden
 403       assert_not comment.reload.visible
 404     end
 405
 406     def test_unhide_with_write_changeset_comments_scope
 407       comment = create(:changeset_comment, :visible => false)
 408       auth_header = bearer_authorization_header create(:moderator_user), :scopes => %w[write_changeset_comments]
 409
 410       post changeset_comment_unhide_path(comment), :headers => auth_header
 411
 412       assert_response :success
 413       assert comment.reload.visible
 414     end
 415
 416     def test_unhide_with_write_api_scope
 417       comment = create(:changeset_comment, :visible => false)
 418       auth_header = bearer_authorization_header create(:moderator_user), :scopes => %w[write_api]
 419
 420       post changeset_comment_unhide_path(comment), :headers => auth_header
 421
 422       assert_response :success
 423       assert comment.reload.visible
 424     end
 425   end
 426 end