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_comments", :method => :get },
  10         { :controller => "api/changeset_comments", :action => "index" }
  11       )
  12       assert_routing(
  13         { :path => "/api/0.6/changeset_comments.json", :method => :get },
  14         { :controller => "api/changeset_comments", :action => "index", :format => "json" }
  15       )
  16       assert_routing(
  17         { :path => "/api/0.6/changeset/1/comment", :method => :post },
  18         { :controller => "api/changeset_comments", :action => "create", :changeset_id => "1" }
  19       )
  20       assert_routing(
  21         { :path => "/api/0.6/changeset/1/comment.json", :method => :post },
  22         { :controller => "api/changeset_comments", :action => "create", :changeset_id => "1", :format => "json" }
  23       )
  24     end
  25
  26     def test_index
  27       user1 = create(:user)
  28       user2 = create(:user)
  29       changeset1 = create(:changeset, :closed, :user => user2)
  30       comment11 = create(:changeset_comment, :changeset => changeset1, :author => user1, :created_at => "2023-01-01", :body => "changeset 1 question")
  31       comment12 = create(:changeset_comment, :changeset => changeset1, :author => user2, :created_at => "2023-02-01", :body => "changeset 1 answer")
  32       changeset2 = create(:changeset, :closed, :user => user1)
  33       comment21 = create(:changeset_comment, :changeset => changeset2, :author => user1, :created_at => "2023-03-01", :body => "changeset 2 note")
  34       comment22 = create(:changeset_comment, :changeset => changeset2, :author => user1, :created_at => "2023-04-01", :body => "changeset 2 extra note")
  35       comment23 = create(:changeset_comment, :changeset => changeset2, :author => user2, :created_at => "2023-05-01", :body => "changeset 2 review")
  36
  37       get api_changeset_comments_path
  38       assert_response :success
  39       assert_comments_in_order [comment23, comment22, comment21, comment12, comment11]
  40
  41       get api_changeset_comments_path(:limit => 3)
  42       assert_response :success
  43       assert_comments_in_order [comment23, comment22, comment21]
  44
  45       get api_changeset_comments_path(:from => "2023-03-15T00:00:00Z")
  46       assert_response :success
  47       assert_comments_in_order [comment23, comment22]
  48
  49       get api_changeset_comments_path(:from => "2023-01-15T00:00:00Z", :to => "2023-04-15T00:00:00Z")
  50       assert_response :success
  51       assert_comments_in_order [comment22, comment21, comment12]
  52
  53       get api_changeset_comments_path(:user => user1.id)
  54       assert_response :success
  55       assert_comments_in_order [comment22, comment21, comment11]
  56
  57       get api_changeset_comments_path(:from => "2023-03-15T00:00:00Z", :format => "json")
  58       assert_response :success
  59       js = ActiveSupport::JSON.decode(@response.body)
  60       assert_not_nil js
  61       assert_equal 2, js["comments"].count
  62       assert_equal comment23.id, js["comments"][0]["id"]
  63       assert_equal comment22.id, js["comments"][1]["id"]
  64     end
  65
  66     def test_create_by_unauthorized
  67       assert_no_difference "ChangesetComment.count" do
  68         post api_changeset_changeset_comments_path(create(:changeset, :closed), :text => "This is a comment")
  69         assert_response :unauthorized
  70       end
  71     end
  72
  73     def test_create_on_missing_changeset
  74       assert_no_difference "ChangesetComment.count" do
  75         post api_changeset_changeset_comments_path(999111, :text => "This is a comment"), :headers => bearer_authorization_header
  76         assert_response :not_found
  77       end
  78     end
  79
  80     def test_create_on_open_changeset
  81       assert_no_difference "ChangesetComment.count" do
  82         post api_changeset_changeset_comments_path(create(:changeset), :text => "This is a comment"), :headers => bearer_authorization_header
  83         assert_response :conflict
  84       end
  85     end
  86
  87     def test_create_without_text
  88       assert_no_difference "ChangesetComment.count" do
  89         post api_changeset_changeset_comments_path(create(:changeset, :closed)), :headers => bearer_authorization_header
  90         assert_response :bad_request
  91       end
  92     end
  93
  94     def test_create_with_empty_text
  95       assert_no_difference "ChangesetComment.count" do
  96         post api_changeset_changeset_comments_path(create(:changeset, :closed), :text => ""), :headers => bearer_authorization_header
  97         assert_response :bad_request
  98       end
  99     end
 100
 101     def test_create_when_not_agreed_to_terms
 102       user = create(:user, :terms_agreed => nil)
 103       auth_header = bearer_authorization_header user
 104       changeset = create(:changeset, :closed)
 105
 106       assert_difference "ChangesetComment.count", 0 do
 107         post api_changeset_changeset_comments_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
 108         assert_response :forbidden
 109       end
 110     end
 111
 112     def test_create_without_required_scope
 113       user = create(:user)
 114       auth_header = bearer_authorization_header user, :scopes => %w[read_prefs]
 115       changeset = create(:changeset, :closed)
 116
 117       assert_difference "ChangesetComment.count", 0 do
 118         post api_changeset_changeset_comments_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
 119         assert_response :forbidden
 120       end
 121     end
 122
 123     def test_create_with_write_changeset_comments_scope
 124       user = create(:user)
 125       auth_header = bearer_authorization_header user, :scopes => %w[write_changeset_comments]
 126       changeset = create(:changeset, :closed)
 127
 128       assert_difference "ChangesetComment.count", 1 do
 129         post api_changeset_changeset_comments_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
 130         assert_response :success
 131       end
 132
 133       comment = ChangesetComment.last
 134       assert_equal changeset.id, comment.changeset_id
 135       assert_equal user.id, comment.author_id
 136       assert_equal "This is a comment", comment.body
 137       assert comment.visible
 138     end
 139
 140     def test_create_with_write_api_scope
 141       user = create(:user)
 142       auth_header = bearer_authorization_header user, :scopes => %w[write_api]
 143       changeset = create(:changeset, :closed)
 144
 145       assert_difference "ChangesetComment.count", 1 do
 146         post api_changeset_changeset_comments_path(changeset), :params => { :text => "This is a comment" }, :headers => auth_header
 147         assert_response :success
 148       end
 149
 150       comment = ChangesetComment.last
 151       assert_equal changeset.id, comment.changeset_id
 152       assert_equal user.id, comment.author_id
 153       assert_equal "This is a comment", comment.body
 154       assert comment.visible
 155     end
 156
 157     def test_create_on_changeset_with_no_subscribers
 158       changeset = create(:changeset, :closed)
 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 api_changeset_changeset_comments_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_commenter_subscriber
 172       user = create(:user)
 173       changeset = create(:changeset, :closed, :user => user)
 174       changeset.subscribers << user
 175       auth_header = bearer_authorization_header user
 176
 177       assert_difference "ChangesetComment.count", 1 do
 178         assert_no_difference "ActionMailer::Base.deliveries.size" do
 179           perform_enqueued_jobs do
 180             post api_changeset_changeset_comments_path(changeset, :text => "This is a comment"), :headers => auth_header
 181             assert_response :success
 182           end
 183         end
 184       end
 185     end
 186
 187     def test_create_on_changeset_with_invisible_subscribers
 188       changeset = create(:changeset, :closed)
 189       changeset.subscribers << create(:user, :suspended)
 190       changeset.subscribers << create(:user, :deleted)
 191       auth_header = bearer_authorization_header
 192
 193       assert_difference "ChangesetComment.count", 1 do
 194         assert_no_difference "ActionMailer::Base.deliveries.size" do
 195           perform_enqueued_jobs do
 196             post api_changeset_changeset_comments_path(changeset, :text => "This is a comment"), :headers => auth_header
 197             assert_response :success
 198           end
 199         end
 200       end
 201     end
 202
 203     def test_create_on_changeset_with_changeset_creator_subscriber
 204       creator_user = create(:user)
 205       changeset = create(:changeset, :closed, :user => creator_user)
 206       changeset.subscribers << creator_user
 207       commenter_user = create(:user)
 208       auth_header = bearer_authorization_header commenter_user
 209
 210       assert_difference "ChangesetComment.count", 1 do
 211         assert_difference "ActionMailer::Base.deliveries.size", 1 do
 212           perform_enqueued_jobs do
 213             post api_changeset_changeset_comments_path(changeset, :text => "This is a comment"), :headers => auth_header
 214             assert_response :success
 215           end
 216         end
 217       end
 218
 219       email = ActionMailer::Base.deliveries.first
 220       assert_equal 1, email.to.length
 221       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on one of your changesets", email.subject
 222       assert_equal creator_user.email, email.to.first
 223     end
 224
 225     def test_create_on_changeset_with_changeset_creator_and_other_user_subscribers
 226       creator_user = create(:user)
 227       changeset = create(:changeset, :closed, :user => creator_user)
 228       changeset.subscribers << creator_user
 229       other_user = create(:user)
 230       changeset.subscribers << other_user
 231       commenter_user = create(:user)
 232       auth_header = bearer_authorization_header commenter_user
 233
 234       assert_difference "ChangesetComment.count", 1 do
 235         assert_difference "ActionMailer::Base.deliveries.size", 2 do
 236           perform_enqueued_jobs do
 237             post api_changeset_changeset_comments_path(changeset, :text => "This is a comment"), :headers => auth_header
 238             assert_response :success
 239           end
 240         end
 241       end
 242
 243       email = ActionMailer::Base.deliveries.find { |e| e.to.first == creator_user.email }
 244       assert_not_nil email
 245       assert_equal 1, email.to.length
 246       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on one of your changesets", email.subject
 247
 248       email = ActionMailer::Base.deliveries.find { |e| e.to.first == other_user.email }
 249       assert_not_nil email
 250       assert_equal 1, email.to.length
 251       assert_equal "[OpenStreetMap] #{commenter_user.display_name} has commented on a changeset you are interested in", email.subject
 252     end
 253
 254     ##
 255     # create comment rate limit for new users
 256     def test_create_by_new_user_with_rate_limit
 257       changeset = create(:changeset, :closed)
 258       user = create(:user)
 259
 260       auth_header = bearer_authorization_header user
 261
 262       assert_difference "ChangesetComment.count", Settings.initial_changeset_comments_per_hour do
 263         1.upto(Settings.initial_changeset_comments_per_hour) do |count|
 264           post api_changeset_changeset_comments_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 265           assert_response :success
 266         end
 267       end
 268
 269       assert_no_difference "ChangesetComment.count" do
 270         post api_changeset_changeset_comments_path(changeset, :text => "One comment too many"), :headers => auth_header
 271         assert_response :too_many_requests
 272       end
 273     end
 274
 275     ##
 276     # create comment rate limit for experienced users
 277     def test_create_by_experienced_user_with_rate_limit
 278       changeset = create(:changeset, :closed)
 279       user = create(:user)
 280       create_list(:changeset_comment, Settings.comments_to_max_changeset_comments, :author_id => user.id, :created_at => Time.now.utc - 1.day)
 281
 282       auth_header = bearer_authorization_header user
 283
 284       assert_difference "ChangesetComment.count", Settings.max_changeset_comments_per_hour do
 285         1.upto(Settings.max_changeset_comments_per_hour) do |count|
 286           post api_changeset_changeset_comments_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 287           assert_response :success
 288         end
 289       end
 290
 291       assert_no_difference "ChangesetComment.count" do
 292         post api_changeset_changeset_comments_path(changeset, :text => "One comment too many"), :headers => auth_header
 293         assert_response :too_many_requests
 294       end
 295     end
 296
 297     ##
 298     # create comment rate limit for reported users
 299     def test_create_by_reported_user_with_rate_limit
 300       changeset = create(:changeset, :closed)
 301       user = create(:user)
 302       create(:issue_with_reports, :reportable => user, :reported_user => user)
 303
 304       auth_header = bearer_authorization_header user
 305
 306       assert_difference "ChangesetComment.count", Settings.initial_changeset_comments_per_hour / 2 do
 307         1.upto(Settings.initial_changeset_comments_per_hour / 2) do |count|
 308           post api_changeset_changeset_comments_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 309           assert_response :success
 310         end
 311       end
 312
 313       assert_no_difference "ChangesetComment.count" do
 314         post api_changeset_changeset_comments_path(changeset, :text => "One comment too many"), :headers => auth_header
 315         assert_response :too_many_requests
 316       end
 317     end
 318
 319     ##
 320     # create comment rate limit for moderator users
 321     def test_create_by_moderator_user_with_rate_limit
 322       changeset = create(:changeset, :closed)
 323       user = create(:moderator_user)
 324
 325       auth_header = bearer_authorization_header user
 326
 327       assert_difference "ChangesetComment.count", Settings.moderator_changeset_comments_per_hour do
 328         1.upto(Settings.moderator_changeset_comments_per_hour) do |count|
 329           post api_changeset_changeset_comments_path(changeset, :text => "Comment #{count}"), :headers => auth_header
 330           assert_response :success
 331         end
 332       end
 333
 334       assert_no_difference "ChangesetComment.count" do
 335         post api_changeset_changeset_comments_path(changeset, :text => "One comment too many"), :headers => auth_header
 336         assert_response :too_many_requests
 337       end
 338     end
 339
 340     private
 341
 342     ##
 343     # check that certain comments exist in the output in the specified order
 344     def assert_comments_in_order(comments)
 345       assert_dom "osm > comment", comments.size do |dom_comments|
 346         comments.zip(dom_comments).each do |comment, dom_comment|
 347           assert_dom dom_comment, "> @id", comment.id.to_s
 348           assert_dom dom_comment, "> @uid", comment.author.id.to_s
 349           assert_dom dom_comment, "> @user", comment.author.display_name
 350           assert_dom dom_comment, "> text", comment.body
 351         end
 352       end
 353     end
 354   end
 355 end