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_with_write_api_scope
  81       user = create(:user)
  82       auth_header = bearer_authorization_header user, :scopes => %w[write_api]
  83       changeset = create(:changeset, :closed)
  84
  85       assert_difference "ChangesetComment.count", 1 do
  86         post changeset_comment_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
  87         assert_response :success
  88       end
  89
  90       comment = ChangesetComment.last
  91       assert_equal changeset.id, comment.changeset_id
  92       assert_equal user.id, comment.author_id
  93       assert_equal "This is a comment", comment.body
  94       assert comment.visible
  95     end
  96
  97     def test_create_on_changeset_with_no_subscribers
  98       changeset = create(:changeset, :closed)
  99       auth_header = bearer_authorization_header
 100
 101       assert_difference "ChangesetComment.count", 1 do
 102         assert_no_difference "ActionMailer::Base.deliveries.size" do
 103           perform_enqueued_jobs do
 104             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 105             assert_response :success
 106           end
 107         end
 108       end
 109     end
 110
 111     def test_create_on_changeset_with_commenter_subscriber
 112       user = create(:user)
 113       changeset = create(:changeset, :closed, :user => user)
 114       changeset.subscribers << user
 115       auth_header = bearer_authorization_header user
 116
 117       assert_difference "ChangesetComment.count", 1 do
 118         assert_no_difference "ActionMailer::Base.deliveries.size" do
 119           perform_enqueued_jobs do
 120             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 121             assert_response :success
 122           end
 123         end
 124       end
 125     end
 126
 127     def test_create_on_changeset_with_invisible_subscribers
 128       changeset = create(:changeset, :closed)
 129       changeset.subscribers << create(:user, :suspended)
 130       changeset.subscribers << create(:user, :deleted)
 131       auth_header = bearer_authorization_header
 132
 133       assert_difference "ChangesetComment.count", 1 do
 134         assert_no_difference "ActionMailer::Base.deliveries.size" do
 135           perform_enqueued_jobs do
 136             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 137             assert_response :success
 138           end
 139         end
 140       end
 141     end
 142
 143     def test_create_on_changeset_with_changeset_creator_subscriber
 144       creator_user = create(:user)
 145       changeset = create(:changeset, :closed, :user => creator_user)
 146       changeset.subscribers << creator_user
 147       commenter_user = create(:user)
 148       auth_header = bearer_authorization_header commenter_user
 149
 150       assert_difference "ChangesetComment.count", 1 do
 151         assert_difference "ActionMailer::Base.deliveries.size", 1 do
 152           perform_enqueued_jobs do
 153             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 154             assert_response :success
 155           end
 156         end
 157       end
 158
 159       email = ActionMailer::Base.deliveries.first
 160       assert_equal 1, email.to.length
 161       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on one of your changesets", email.subject
 162       assert_equal creator_user.email, email.to.first
 163
 164       ActionMailer::Base.deliveries.clear
 165     end
 166
 167     def test_create_on_changeset_with_changeset_creator_and_other_user_subscribers
 168       creator_user = create(:user)
 169       changeset = create(:changeset, :closed, :user => creator_user)
 170       changeset.subscribers << creator_user
 171       other_user = create(:user)
 172       changeset.subscribers << other_user
 173       commenter_user = create(:user)
 174       auth_header = bearer_authorization_header commenter_user
 175
 176       assert_difference "ChangesetComment.count", 1 do
 177         assert_difference "ActionMailer::Base.deliveries.size", 2 do
 178           perform_enqueued_jobs do
 179             post changeset_comment_path(changeset, :text => "This is a comment"), :headers => auth_header
 180             assert_response :success
 181           end
 182         end
 183       end
 184
 185       email = ActionMailer::Base.deliveries.find { |e| e.to.first == creator_user.email }
 186       assert_not_nil email
 187       assert_equal 1, email.to.length
 188       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on one of your changesets", email.subject
 189
 190       email = ActionMailer::Base.deliveries.find { |e| e.to.first == other_user.email }
 191       assert_not_nil email
 192       assert_equal 1, email.to.length
 193       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on a changeset you are interested in", email.subject
 194
 195       ActionMailer::Base.deliveries.clear
 196     end
 197
 198     ##
 199     # create comment rate limit for new users
 200     def test_create_by_new_user_with_rate_limit
 201       changeset = create(:changeset, :closed)
 202       user = create(:user)
 203
 204       auth_header = bearer_authorization_header user
 205
 206       assert_difference "ChangesetComment.count", Settings.initial_changeset_comments_per_hour do
 207         1.upto(Settings.initial_changeset_comments_per_hour) do |count|
 208           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 209           assert_response :success
 210         end
 211       end
 212
 213       assert_no_difference "ChangesetComment.count" do
 214         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 215         assert_response :too_many_requests
 216       end
 217     end
 218
 219     ##
 220     # create comment rate limit for experienced users
 221     def test_create_by_experienced_user_with_rate_limit
 222       changeset = create(:changeset, :closed)
 223       user = create(:user)
 224       create_list(:changeset_comment, Settings.comments_to_max_changeset_comments, :author_id => user.id, :created_at => Time.now.utc - 1.day)
 225
 226       auth_header = bearer_authorization_header user
 227
 228       assert_difference "ChangesetComment.count", Settings.max_changeset_comments_per_hour do
 229         1.upto(Settings.max_changeset_comments_per_hour) do |count|
 230           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 231           assert_response :success
 232         end
 233       end
 234
 235       assert_no_difference "ChangesetComment.count" do
 236         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 237         assert_response :too_many_requests
 238       end
 239     end
 240
 241     ##
 242     # create comment rate limit for reported users
 243     def test_create_by_reported_user_with_rate_limit
 244       changeset = create(:changeset, :closed)
 245       user = create(:user)
 246       create(:issue_with_reports, :reportable => user, :reported_user => user)
 247
 248       auth_header = bearer_authorization_header user
 249
 250       assert_difference "ChangesetComment.count", Settings.initial_changeset_comments_per_hour / 2 do
 251         1.upto(Settings.initial_changeset_comments_per_hour / 2) do |count|
 252           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 253           assert_response :success
 254         end
 255       end
 256
 257       assert_no_difference "ChangesetComment.count" do
 258         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 259         assert_response :too_many_requests
 260       end
 261     end
 262
 263     ##
 264     # create comment rate limit for moderator users
 265     def test_create_by_moderator_user_with_rate_limit
 266       changeset = create(:changeset, :closed)
 267       user = create(:moderator_user)
 268
 269       auth_header = bearer_authorization_header user
 270
 271       assert_difference "ChangesetComment.count", Settings.moderator_changeset_comments_per_hour do
 272         1.upto(Settings.moderator_changeset_comments_per_hour) do |count|
 273           post changeset_comment_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 274           assert_response :success
 275         end
 276       end
 277
 278       assert_no_difference "ChangesetComment.count" do
 279         post changeset_comment_path(changeset, :text => "One comment too many"), :headers => auth_header
 280         assert_response :too_many_requests
 281       end
 282     end
 283
 284     def test_hide_by_unauthorized
 285       comment = create(:changeset_comment)
 286
 287       post changeset_comment_hide_path(comment)
 288
 289       assert_response :unauthorized
 290       assert comment.reload.visible
 291     end
 292
 293     def test_hide_by_normal_user
 294       comment = create(:changeset_comment)
 295       auth_header = bearer_authorization_header
 296
 297       post changeset_comment_hide_path(comment), :headers => auth_header
 298
 299       assert_response :forbidden
 300       assert comment.reload.visible
 301     end
 302
 303     def test_hide_missing_comment
 304       auth_header = bearer_authorization_header create(:moderator_user)
 305
 306       post changeset_comment_hide_path(999111), :headers => auth_header
 307
 308       assert_response :not_found
 309     end
 310
 311     ##
 312     # test hide comment succes
 313     def test_hide
 314       comment = create(:changeset_comment)
 315       assert comment.visible
 316
 317       auth_header = bearer_authorization_header create(:moderator_user)
 318
 319       post changeset_comment_hide_path(comment), :headers => auth_header
 320       assert_response :success
 321       assert_not comment.reload.visible
 322     end
 323
 324     def test_unhide_by_unauthorized
 325       comment = create(:changeset_comment, :visible => false)
 326
 327       post changeset_comment_unhide_path(comment)
 328
 329       assert_response :unauthorized
 330       assert_not comment.reload.visible
 331     end
 332
 333     def test_unhide_by_normal_user
 334       comment = create(:changeset_comment, :visible => false)
 335       auth_header = bearer_authorization_header
 336
 337       post changeset_comment_unhide_path(comment), :headers => auth_header
 338
 339       assert_response :forbidden
 340       assert_not comment.reload.visible
 341     end
 342
 343     def test_unhide_missing_comment
 344       auth_header = bearer_authorization_header create(:moderator_user)
 345
 346       post changeset_comment_unhide_path(999111), :headers => auth_header
 347
 348       assert_response :not_found
 349     end
 350
 351     ##
 352     # test unhide comment succes
 353     def test_unhide
 354       comment = create(:changeset_comment, :visible => false)
 355       assert_not comment.visible
 356
 357       auth_header = bearer_authorization_header create(:moderator_user)
 358
 359       post changeset_comment_unhide_path(comment), :headers => auth_header
 360       assert_response :success
 361       assert comment.reload.visible
 362     end
 363   end
 364 end