test/controllers/api/changesets/uploads_controller_test.rb

   1 require "test_helper"
   2
   3 module Api
   4   module Changesets
   5     class UploadsControllerTest < ActionDispatch::IntegrationTest
   6       ##
   7       # test all routes which lead to this controller
   8       def test_routes
   9         assert_routing(
  10           { :path => "/api/0.6/changeset/1/upload", :method => :post },
  11           { :controller => "api/changesets/uploads", :action => "create", :changeset_id => "1" }
  12         )
  13       end
  14
  15       def test_upload_when_unauthorized
  16         changeset = create(:changeset)
  17         node = create(:node, :latitude => 0, :longitude => 0)
  18
  19         diff = <<~CHANGESET
  20           <osmChange>
  21             <modify>
  22               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
  23             </modify>
  24           </osmChange>
  25         CHANGESET
  26
  27         post api_changeset_upload_path(changeset), :params => diff
  28
  29         assert_response :unauthorized
  30
  31         changeset.reload
  32         assert_equal 0, changeset.num_changes
  33         node.reload
  34         assert_equal 1, node.version
  35         assert_equal 0, node.latitude
  36         assert_equal 0, node.longitude
  37       end
  38
  39       def test_upload_by_private_user
  40         user = create(:user, :data_public => false)
  41         changeset = create(:changeset, :user => user)
  42         node = create(:node, :latitude => 0, :longitude => 0)
  43
  44         diff = <<~CHANGESET
  45           <osmChange>
  46             <modify>
  47               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
  48             </modify>
  49           </osmChange>
  50         CHANGESET
  51
  52         auth_header = bearer_authorization_header user
  53
  54         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
  55
  56         assert_response :forbidden
  57
  58         changeset.reload
  59         assert_equal 0, changeset.num_changes
  60         node.reload
  61         assert_equal 1, node.version
  62         assert_equal 0, node.latitude
  63         assert_equal 0, node.longitude
  64       end
  65
  66       def test_upload_without_required_scope
  67         user = create(:user)
  68         changeset = create(:changeset, :user => user)
  69         node = create(:node, :latitude => 0, :longitude => 0)
  70
  71         diff = <<~CHANGESET
  72           <osmChange>
  73             <modify>
  74               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
  75             </modify>
  76           </osmChange>
  77         CHANGESET
  78
  79         auth_header = bearer_authorization_header user, :scopes => %w[read_prefs]
  80
  81         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
  82
  83         assert_response :forbidden
  84
  85         changeset.reload
  86         assert_equal 0, changeset.num_changes
  87         node.reload
  88         assert_equal 1, node.version
  89         assert_equal 0, node.latitude
  90         assert_equal 0, node.longitude
  91       end
  92
  93       def test_upload_with_required_scope
  94         user = create(:user)
  95         changeset = create(:changeset, :user => user)
  96         node = create(:node, :latitude => 0, :longitude => 0)
  97
  98         diff = <<~CHANGESET
  99           <osmChange>
 100             <modify>
 101               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
 102             </modify>
 103           </osmChange>
 104         CHANGESET
 105
 106         auth_header = bearer_authorization_header user, :scopes => %w[write_api]
 107
 108         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 109
 110         assert_response :success
 111
 112         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 113           assert_dom "> node", 1 do
 114             assert_dom "> @old_id", node.id.to_s
 115             assert_dom "> @new_id", node.id.to_s
 116             assert_dom "> @new_version", "2"
 117           end
 118         end
 119
 120         changeset.reload
 121         assert_equal 1, changeset.num_changes
 122         node.reload
 123         assert_equal 2, node.version
 124         assert_equal 2 * GeoRecord::SCALE, node.latitude
 125         assert_equal 1 * GeoRecord::SCALE, node.longitude
 126       end
 127
 128       ##
 129       # try to upload with commands other than create, modify, or delete
 130       def test_upload_unknown_action
 131         changeset = create(:changeset)
 132
 133         diff = <<~CHANGESET
 134           <osmChange>
 135             <ping>
 136               <node id='1' lon='1' lat='1' changeset='#{changeset.id}' />
 137             </ping>
 138           </osmChange>
 139         CHANGESET
 140
 141         auth_header = bearer_authorization_header changeset.user
 142
 143         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 144
 145         assert_response :bad_request
 146         assert_equal "Unknown action ping, choices are create, modify, delete", @response.body
 147       end
 148
 149       ##
 150       # test for issues in https://github.com/openstreetmap/trac-tickets/issues/1568
 151       def test_upload_empty_changeset
 152         changeset = create(:changeset)
 153
 154         auth_header = bearer_authorization_header changeset.user
 155
 156         ["<osmChange/>",
 157          "<osmChange></osmChange>",
 158          "<osmChange><modify/></osmChange>",
 159          "<osmChange><modify></modify></osmChange>"].each do |diff|
 160           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 161
 162           assert_response :success
 163         end
 164       end
 165
 166       ##
 167       # test that the X-Error-Format header works to request XML errors
 168       def test_upload_xml_errors
 169         changeset = create(:changeset)
 170         node = create(:node)
 171         create(:relation_member, :member => node)
 172
 173         # try and delete a node that is in use
 174         diff = XML::Document.new
 175         diff.root = XML::Node.new "osmChange"
 176         delete = XML::Node.new "delete"
 177         diff.root << delete
 178         delete << xml_node_for_node(node)
 179
 180         auth_header = bearer_authorization_header changeset.user
 181         error_header = error_format_header "xml"
 182
 183         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header.merge(error_header)
 184
 185         assert_response :success
 186
 187         assert_dom "osmError[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1
 188         assert_dom "osmError>status", 1
 189         assert_dom "osmError>message", 1
 190       end
 191
 192       # -------------------------------------
 193       # Test creating elements.
 194       # -------------------------------------
 195
 196       def test_upload_create_elements
 197         user = create(:user)
 198         changeset = create(:changeset, :user => user)
 199         node = create(:node)
 200         way = create(:way_with_nodes, :nodes_count => 2)
 201         relation = create(:relation)
 202
 203         diff = <<~CHANGESET
 204           <osmChange>
 205             <create>
 206               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 207                 <tag k='foo' v='bar'/>
 208                 <tag k='baz' v='bat'/>
 209               </node>
 210               <way id='-1' changeset='#{changeset.id}'>
 211                 <nd ref='#{node.id}'/>
 212               </way>
 213             </create>
 214             <create>
 215               <relation id='-1' changeset='#{changeset.id}'>
 216                 <member type='way' role='some' ref='#{way.id}'/>
 217                 <member type='node' role='some' ref='#{node.id}'/>
 218                 <member type='relation' role='some' ref='#{relation.id}'/>
 219               </relation>
 220             </create>
 221           </osmChange>
 222         CHANGESET
 223
 224         auth_header = bearer_authorization_header user
 225
 226         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 227
 228         assert_response :success
 229
 230         new_node_id, new_way_id, new_rel_id = nil
 231         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 232           # inspect the response to find out what the new element IDs are
 233           # check the old IDs are all present and negative one
 234           # check the versions are present and equal one
 235           assert_dom "> node", 1 do |(node_el)|
 236             new_node_id = node_el["new_id"].to_i
 237             assert_dom "> @old_id", "-1"
 238             assert_dom "> @new_version", "1"
 239           end
 240           assert_dom "> way", 1 do |(way_el)|
 241             new_way_id = way_el["new_id"].to_i
 242             assert_dom "> @old_id", "-1"
 243             assert_dom "> @new_version", "1"
 244           end
 245           assert_dom "> relation", 1 do |(rel_el)|
 246             new_rel_id = rel_el["new_id"].to_i
 247             assert_dom "> @old_id", "-1"
 248             assert_dom "> @new_version", "1"
 249           end
 250         end
 251
 252         assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
 253         assert_equal 0, Way.find(new_way_id).tags.size, "new way should have no tags"
 254         assert_equal 0, Relation.find(new_rel_id).tags.size, "new relation should have no tags"
 255       end
 256
 257       ##
 258       # upload an element with a really long tag value
 259       def test_upload_create_node_with_tag_too_long
 260         changeset = create(:changeset)
 261
 262         diff = <<~CHANGESET
 263           <osmChange>
 264             <create>
 265               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 266                 <tag k='foo' v='#{'x' * 256}'/>
 267               </node>
 268             </create>
 269           </osmChange>
 270         CHANGESET
 271
 272         auth_header = bearer_authorization_header changeset.user
 273
 274         assert_no_difference "Node.count" do
 275           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 276
 277           assert_response :bad_request
 278         end
 279       end
 280
 281       def test_upload_create_nodes_with_invalid_placeholder_reuse_in_one_action_block
 282         changeset = create(:changeset)
 283
 284         diff = <<~CHANGESET
 285           <osmChange>
 286             <create>
 287               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
 288               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 289             </create>
 290           </osmChange>
 291         CHANGESET
 292
 293         auth_header = bearer_authorization_header changeset.user
 294
 295         assert_no_difference "Node.count" do
 296           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 297
 298           assert_response :bad_request
 299         end
 300       end
 301
 302       def test_upload_create_nodes_with_invalid_placeholder_reuse_in_two_action_blocks
 303         changeset = create(:changeset)
 304
 305         diff = <<~CHANGESET
 306           <osmChange>
 307             <create>
 308               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
 309             </create>
 310             <create>
 311               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 312             </create>
 313           </osmChange>
 314         CHANGESET
 315
 316         auth_header = bearer_authorization_header changeset.user
 317
 318         assert_no_difference "Node.count" do
 319           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 320
 321           assert_response :bad_request
 322         end
 323       end
 324
 325       def test_upload_create_way_referring_node_placeholder_defined_later
 326         changeset = create(:changeset)
 327
 328         diff = <<~CHANGESET
 329           <osmChange>
 330             <create>
 331               <way id="-1" changeset="#{changeset.id}">
 332                 <nd ref="-1"/>
 333               </way>
 334               <node id="-1" lat="1" lon="2" changeset="#{changeset.id}"/>
 335             </create>
 336           </osmChange>
 337         CHANGESET
 338
 339         auth_header = bearer_authorization_header changeset.user
 340
 341         assert_no_difference "Node.count" do
 342           assert_no_difference "Way.count" do
 343             post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 344
 345             assert_response :bad_request
 346           end
 347         end
 348         assert_equal "Placeholder node not found for reference -1 in way -1", @response.body
 349       end
 350
 351       def test_upload_create_way_referring_undefined_node_placeholder
 352         changeset = create(:changeset)
 353
 354         diff = <<~CHANGESET
 355           <osmChange>
 356             <create>
 357               <way id="-1" changeset="#{changeset.id}">
 358                 <nd ref="-1"/>
 359               </way>
 360             </create>
 361           </osmChange>
 362         CHANGESET
 363
 364         auth_header = bearer_authorization_header changeset.user
 365
 366         assert_no_difference "Way.count" do
 367           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 368
 369           assert_response :bad_request
 370         end
 371         assert_equal "Placeholder node not found for reference -1 in way -1", @response.body
 372       end
 373
 374       def test_upload_create_existing_way_referring_undefined_node_placeholder
 375         changeset = create(:changeset)
 376         way = create(:way)
 377
 378         diff = <<~CHANGESET
 379           <osmChange>
 380             <create>
 381               <way id="#{way.id}" changeset="#{changeset.id}" version="1">
 382                 <nd ref="-1"/>
 383               </way>
 384             </create>
 385           </osmChange>
 386         CHANGESET
 387
 388         auth_header = bearer_authorization_header changeset.user
 389
 390         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 391
 392         assert_response :bad_request
 393         assert_equal "Placeholder node not found for reference -1 in way #{way.id}", @response.body
 394
 395         way.reload
 396         assert_equal 1, way.version
 397       end
 398
 399       def test_upload_create_relation_referring_undefined_node_placeholder
 400         changeset = create(:changeset)
 401
 402         diff = <<~CHANGESET
 403           <osmChange>
 404             <create>
 405               <relation id="-1" changeset="#{changeset.id}" version="1">
 406                 <member type="node" role="foo" ref="-1"/>
 407               </relation>
 408             </create>
 409           </osmChange>
 410         CHANGESET
 411
 412         auth_header = bearer_authorization_header changeset.user
 413
 414         assert_no_difference "Relation.count" do
 415           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 416
 417           assert_response :bad_request
 418         end
 419         assert_equal "Placeholder Node not found for reference -1 in relation -1.", @response.body
 420       end
 421
 422       def test_upload_create_existing_relation_referring_undefined_way_placeholder
 423         changeset = create(:changeset)
 424         relation = create(:relation)
 425
 426         diff = <<~CHANGESET
 427           <osmChange>
 428             <create>
 429               <relation id="#{relation.id}" changeset="#{changeset.id}" version="1">
 430                 <member type="way" role="bar" ref="-1"/>
 431               </relation>
 432             </create>
 433           </osmChange>
 434         CHANGESET
 435
 436         auth_header = bearer_authorization_header changeset.user
 437
 438         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 439
 440         assert_response :bad_request
 441         assert_equal "Placeholder Way not found for reference -1 in relation #{relation.id}.", @response.body
 442
 443         relation.reload
 444         assert_equal 1, relation.version
 445       end
 446
 447       def test_upload_create_relations_with_circular_references
 448         changeset = create(:changeset)
 449
 450         diff = <<~CHANGESET
 451           <osmChange version='0.6'>
 452             <create>
 453               <relation id='-2' version='0' changeset='#{changeset.id}'>
 454                 <member type='relation' role='' ref='-4' />
 455                 <tag k='type' v='route' />
 456                 <tag k='name' v='AtoB' />
 457               </relation>
 458               <relation id='-3' version='0' changeset='#{changeset.id}'>
 459                 <tag k='type' v='route' />
 460                 <tag k='name' v='BtoA' />
 461               </relation>
 462               <relation id='-4' version='0' changeset='#{changeset.id}'>
 463                 <member type='relation' role='' ref='-2' />
 464                 <member type='relation' role='' ref='-3' />
 465                 <tag k='type' v='route_master' />
 466                 <tag k='name' v='master' />
 467               </relation>
 468             </create>
 469           </osmChange>
 470         CHANGESET
 471
 472         auth_header = bearer_authorization_header changeset.user
 473
 474         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 475
 476         assert_response :bad_request
 477         assert_equal "Placeholder Relation not found for reference -4 in relation -2.", @response.body
 478       end
 479
 480       # -------------------------------------
 481       # Test modifying elements.
 482       # -------------------------------------
 483
 484       def test_upload_modify_elements
 485         user = create(:user)
 486         changeset = create(:changeset, :user => user)
 487         node = create(:node, :latitude => 0, :longitude => 0)
 488         way = create(:way)
 489         relation = create(:relation)
 490         other_relation = create(:relation)
 491
 492         # create some tags, since we test that they are removed later
 493         create(:node_tag, :node => node)
 494         create(:way_tag, :way => way)
 495         create(:relation_tag, :relation => relation)
 496
 497         # simple diff to change a node, way and relation by removing their tags
 498         diff = <<~CHANGESET
 499           <osmChange>
 500             <modify>
 501               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
 502               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 503                 <nd ref='#{node.id}'/>
 504               </way>
 505             </modify>
 506             <modify>
 507               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 508                 <member type='way' role='some' ref='#{way.id}'/>
 509                 <member type='node' role='some' ref='#{node.id}'/>
 510                 <member type='relation' role='some' ref='#{other_relation.id}'/>
 511               </relation>
 512             </modify>
 513           </osmChange>
 514         CHANGESET
 515
 516         auth_header = bearer_authorization_header user
 517
 518         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 519
 520         assert_response :success
 521
 522         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 523           assert_dom "> node", 1 do
 524             assert_dom "> @old_id", node.id.to_s
 525             assert_dom "> @new_id", node.id.to_s
 526             assert_dom "> @new_version", "2"
 527           end
 528           assert_dom "> way", 1 do
 529             assert_dom "> @old_id", way.id.to_s
 530             assert_dom "> @new_id", way.id.to_s
 531             assert_dom "> @new_version", "2"
 532           end
 533           assert_dom "> relation", 1 do
 534             assert_dom "> @old_id", relation.id.to_s
 535             assert_dom "> @new_id", relation.id.to_s
 536             assert_dom "> @new_version", "2"
 537           end
 538         end
 539
 540         changeset.reload
 541         assert_equal 3, changeset.num_changes
 542         node.reload
 543         assert_equal 2, node.version
 544         assert_equal 2 * GeoRecord::SCALE, node.latitude
 545         assert_equal 1 * GeoRecord::SCALE, node.longitude
 546         assert_equal 0, node.tags.size, "node #{node.id} should now have no tags"
 547         way.reload
 548         assert_equal 2, way.version
 549         assert_equal 0, way.tags.size, "way #{way.id} should now have no tags"
 550         assert_equal [node], way.nodes
 551         relation.reload
 552         assert_equal 2, relation.version
 553         assert_equal 0, relation.tags.size, "relation #{relation.id} should now have no tags"
 554         assert_equal [["Way", way.id, "some"], ["Node", node.id, "some"], ["Relation", other_relation.id, "some"]], relation.members
 555       end
 556
 557       ##
 558       # upload multiple versions of the same element in the same diff.
 559       def test_upload_modify_multiple_node_versions
 560         node = create(:node)
 561         changeset = create(:changeset)
 562
 563         # change the location of a node multiple times, each time referencing
 564         # the last version. doesn't this depend on version numbers being
 565         # sequential?
 566         diff = <<~CHANGESET
 567           <osmChange>
 568             <modify>
 569               <node id='#{node.id}' lon='0.0' lat='0.0' changeset='#{changeset.id}' version='1'/>
 570               <node id='#{node.id}' lon='0.1' lat='0.0' changeset='#{changeset.id}' version='2'/>
 571               <node id='#{node.id}' lon='0.1' lat='0.1' changeset='#{changeset.id}' version='3'/>
 572               <node id='#{node.id}' lon='0.1' lat='0.2' changeset='#{changeset.id}' version='4'/>
 573               <node id='#{node.id}' lon='0.2' lat='0.2' changeset='#{changeset.id}' version='5'/>
 574               <node id='#{node.id}' lon='0.3' lat='0.2' changeset='#{changeset.id}' version='6'/>
 575               <node id='#{node.id}' lon='0.3' lat='0.3' changeset='#{changeset.id}' version='7'/>
 576               <node id='#{node.id}' lon='0.9' lat='0.9' changeset='#{changeset.id}' version='8'/>
 577             </modify>
 578           </osmChange>
 579         CHANGESET
 580
 581         auth_header = bearer_authorization_header changeset.user
 582
 583         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 584
 585         assert_response :success
 586
 587         assert_dom "diffResult>node", 8
 588
 589         node.reload
 590         assert_equal 9, node.version
 591         assert_equal 0.9 * GeoRecord::SCALE, node.latitude
 592         assert_equal 0.9 * GeoRecord::SCALE, node.longitude
 593       end
 594
 595       ##
 596       # upload multiple versions of the same element in the same diff, but
 597       # keep the version numbers the same.
 598       def test_upload_modify_duplicate_node_versions
 599         node = create(:node, :latitude => 0, :longitude => 0)
 600         changeset = create(:changeset)
 601
 602         diff = <<~CHANGESET
 603           <osmChange>
 604             <modify>
 605               <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 606               <node id='#{node.id}' lon='2' lat='2' changeset='#{changeset.id}' version='1'/>
 607             </modify>
 608           </osmChange>
 609         CHANGESET
 610
 611         auth_header = bearer_authorization_header changeset.user
 612
 613         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 614
 615         assert_response :conflict
 616
 617         node.reload
 618         assert_equal 1, node.version
 619         assert_equal 0, node.latitude
 620         assert_equal 0, node.longitude
 621       end
 622
 623       ##
 624       # try to upload some elements without specifying the version
 625       def test_upload_modify_missing_node_version
 626         node = create(:node, :latitude => 0, :longitude => 0)
 627         changeset = create(:changeset)
 628
 629         diff = <<~CHANGESET
 630           <osmChange>
 631             <modify>
 632               <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}'/>
 633             </modify>
 634           </osmChange>
 635         CHANGESET
 636
 637         auth_header = bearer_authorization_header changeset.user
 638
 639         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 640
 641         assert_response :bad_request
 642
 643         node.reload
 644         assert_equal 1, node.version
 645         assert_equal 0, node.latitude
 646         assert_equal 0, node.longitude
 647       end
 648
 649       ##
 650       # create a diff which references several changesets, which should cause
 651       # a rollback and none of the diff gets committed
 652       def test_upload_modify_with_references_to_different_changesets
 653         changeset1 = create(:changeset)
 654         changeset2 = create(:changeset, :user => changeset1.user)
 655         node1 = create(:node)
 656         node2 = create(:node)
 657
 658         # simple diff to create a node way and relation using placeholders
 659         diff = <<~CHANGESET
 660           <osmChange>
 661             <modify>
 662               <node id='#{node1.id}' lon='0' lat='0' changeset='#{changeset1.id}' version='1'/>
 663             </modify>
 664             <modify>
 665               <node id='#{node2.id}' lon='0' lat='0' changeset='#{changeset2.id}' version='1'/>
 666             </modify>
 667           </osmChange>
 668         CHANGESET
 669
 670         auth_header = bearer_authorization_header changeset1.user
 671
 672         post api_changeset_upload_path(changeset1), :params => diff, :headers => auth_header
 673
 674         assert_response :conflict
 675
 676         assert_nodes_are_equal(node1, Node.find(node1.id))
 677         assert_nodes_are_equal(node2, Node.find(node2.id))
 678       end
 679
 680       ##
 681       # upload a valid changeset which has a mixture of whitespace
 682       # to check a bug https://github.com/openstreetmap/trac-tickets/issues/1565
 683       def test_upload_modify_with_mixed_whitespace
 684         changeset = create(:changeset)
 685         node = create(:node)
 686         way = create(:way_with_nodes, :nodes_count => 2)
 687         relation = create(:relation)
 688         other_relation = create(:relation)
 689         create(:relation_tag, :relation => relation)
 690
 691         diff = <<~CHANGESET
 692           <osmChange>
 693           <modify><node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}'
 694             version='1'></node>
 695             <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='2'><tag k='k' v='v'/></node></modify>
 696           <modify>
 697           <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'><member
 698             type='way' role='some' ref='#{way.id}'/><member
 699               type='node' role='some' ref='#{node.id}'/>
 700             <member type='relation' role='some' ref='#{other_relation.id}'/>
 701             </relation>
 702           </modify></osmChange>
 703         CHANGESET
 704
 705         auth_header = bearer_authorization_header changeset.user
 706
 707         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 708
 709         assert_response :success
 710
 711         assert_dom "diffResult>node", 2
 712         assert_dom "diffResult>relation", 1
 713
 714         assert_equal 1, Node.find(node.id).tags.size, "node #{node.id} should now have one tag"
 715         assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
 716       end
 717
 718       def test_upload_modify_unknown_node_placeholder
 719         check_upload_results_in_not_found do |changeset|
 720           "<modify><node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/></modify>"
 721         end
 722       end
 723
 724       def test_upload_modify_unknown_way_placeholder
 725         check_upload_results_in_not_found do |changeset|
 726           "<modify><way id='-1' changeset='#{changeset.id}' version='1'/></modify>"
 727         end
 728       end
 729
 730       def test_upload_modify_unknown_relation_placeholder
 731         check_upload_results_in_not_found do |changeset|
 732           "<modify><relation id='-1' changeset='#{changeset.id}' version='1'/></modify>"
 733         end
 734       end
 735
 736       # -------------------------------------
 737       # Test deleting elements.
 738       # -------------------------------------
 739
 740       ##
 741       # test a complex delete where we delete elements which rely on each other
 742       # in the same transaction.
 743       def test_upload_delete_elements
 744         changeset = create(:changeset)
 745         super_relation = create(:relation)
 746         used_relation = create(:relation)
 747         used_way = create(:way)
 748         used_node = create(:node)
 749         create(:relation_member, :relation => super_relation, :member => used_relation)
 750         create(:relation_member, :relation => super_relation, :member => used_way)
 751         create(:relation_member, :relation => super_relation, :member => used_node)
 752
 753         diff = XML::Document.new
 754         diff.root = XML::Node.new "osmChange"
 755         delete = XML::Node.new "delete"
 756         diff.root << delete
 757         delete << xml_node_for_relation(super_relation)
 758         delete << xml_node_for_relation(used_relation)
 759         delete << xml_node_for_way(used_way)
 760         delete << xml_node_for_node(used_node)
 761         %w[node way relation].each do |type|
 762           delete.find("//osmChange/delete/#{type}").each do |n|
 763             n["changeset"] = changeset.id.to_s
 764           end
 765         end
 766
 767         auth_header = bearer_authorization_header changeset.user
 768
 769         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 770
 771         assert_response :success
 772
 773         assert_dom "diffResult", 1 do
 774           assert_dom "> node", 1
 775           assert_dom "> way", 1
 776           assert_dom "> relation", 2
 777         end
 778
 779         assert_not Node.find(used_node.id).visible
 780         assert_not Way.find(used_way.id).visible
 781         assert_not Relation.find(super_relation.id).visible
 782         assert_not Relation.find(used_relation.id).visible
 783       end
 784
 785       ##
 786       # test uploading a delete with no lat/lon, as they are optional in the osmChange spec.
 787       def test_upload_delete_node_without_latlon
 788         node = create(:node)
 789         changeset = create(:changeset)
 790
 791         diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
 792
 793         auth_header = bearer_authorization_header changeset.user
 794
 795         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 796
 797         assert_response :success
 798
 799         assert_dom "diffResult", 1 do
 800           assert_dom "> node", 1 do
 801             assert_dom "> @old_id", node.id.to_s
 802             assert_dom "> @new_id", 0
 803             assert_dom "> @new_version", 0
 804           end
 805         end
 806
 807         node.reload
 808         assert_not node.visible
 809       end
 810
 811       ##
 812       # test that deleting stuff in a transaction doesn't bypass the checks
 813       # to ensure that used elements are not deleted.
 814       def test_upload_delete_referenced_elements
 815         changeset = create(:changeset)
 816         relation = create(:relation)
 817         other_relation = create(:relation)
 818         used_way = create(:way)
 819         used_node = create(:node)
 820         create(:relation_member, :relation => relation, :member => used_way)
 821         create(:relation_member, :relation => relation, :member => used_node)
 822
 823         diff = XML::Document.new
 824         diff.root = XML::Node.new "osmChange"
 825         delete = XML::Node.new "delete"
 826         diff.root << delete
 827         delete << xml_node_for_relation(other_relation)
 828         delete << xml_node_for_way(used_way)
 829         delete << xml_node_for_node(used_node)
 830         %w[node way relation].each do |type|
 831           delete.find("//osmChange/delete/#{type}").each do |n|
 832             n["changeset"] = changeset.id.to_s
 833           end
 834         end
 835
 836         auth_header = bearer_authorization_header changeset.user
 837
 838         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 839
 840         assert_response :precondition_failed
 841         assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
 842
 843         assert Node.find(used_node.id).visible
 844         assert Way.find(used_way.id).visible
 845         assert Relation.find(relation.id).visible
 846         assert Relation.find(other_relation.id).visible
 847       end
 848
 849       ##
 850       # test that a conditional delete of an in use object works.
 851       def test_upload_delete_if_unused
 852         changeset = create(:changeset)
 853         super_relation = create(:relation)
 854         used_relation = create(:relation)
 855         used_way = create(:way)
 856         used_node = create(:node)
 857         create(:relation_member, :relation => super_relation, :member => used_relation)
 858         create(:relation_member, :relation => super_relation, :member => used_way)
 859         create(:relation_member, :relation => super_relation, :member => used_node)
 860
 861         diff = XML::Document.new
 862         diff.root = XML::Node.new "osmChange"
 863         delete = XML::Node.new "delete"
 864         diff.root << delete
 865         delete["if-unused"] = ""
 866         delete << xml_node_for_relation(used_relation)
 867         delete << xml_node_for_way(used_way)
 868         delete << xml_node_for_node(used_node)
 869         %w[node way relation].each do |type|
 870           delete.find("//osmChange/delete/#{type}").each do |n|
 871             n["changeset"] = changeset.id.to_s
 872           end
 873         end
 874
 875         auth_header = bearer_authorization_header changeset.user
 876
 877         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 878
 879         assert_response :success
 880
 881         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 882           assert_dom "> node", 1 do
 883             assert_dom "> @old_id", used_node.id.to_s
 884             assert_dom "> @new_id", used_node.id.to_s
 885             assert_dom "> @new_version", used_node.version.to_s
 886           end
 887           assert_dom "> way", 1 do
 888             assert_dom "> @old_id", used_way.id.to_s
 889             assert_dom "> @new_id", used_way.id.to_s
 890             assert_dom "> @new_version", used_way.version.to_s
 891           end
 892           assert_dom "> relation", 1 do
 893             assert_dom "> @old_id", used_relation.id.to_s
 894             assert_dom "> @new_id", used_relation.id.to_s
 895             assert_dom "> @new_version", used_relation.version.to_s
 896           end
 897         end
 898
 899         assert Node.find(used_node.id).visible
 900         assert Way.find(used_way.id).visible
 901         assert Relation.find(used_relation.id).visible
 902       end
 903
 904       def test_upload_delete_with_multiple_blocks_and_if_unused
 905         changeset = create(:changeset)
 906         node = create(:node)
 907         way = create(:way)
 908         create(:way_node, :way => way, :node => node)
 909         alone_node = create(:node)
 910
 911         diff = <<~CHANGESET
 912           <osmChange version='0.6'>
 913             <delete version="0.6">
 914               <node id="#{node.id}" version="#{node.version}" changeset="#{changeset.id}"/>
 915             </delete>
 916             <delete version="0.6" if-unused="true">
 917               <node id="#{alone_node.id}" version="#{alone_node.version}" changeset="#{changeset.id}"/>
 918             </delete>
 919           </osmChange>
 920         CHANGESET
 921
 922         auth_header = bearer_authorization_header changeset.user
 923
 924         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 925
 926         assert_response :precondition_failed
 927
 928         assert_equal "Precondition failed: Node #{node.id} is still used by ways #{way.id}.", @response.body
 929       end
 930
 931       def test_upload_delete_unknown_node_placeholder
 932         check_upload_results_in_not_found do |changeset|
 933           "<delete><node id='-1' changeset='#{changeset.id}' version='1'/></delete>"
 934         end
 935       end
 936
 937       def test_upload_delete_unknown_way_placeholder
 938         check_upload_results_in_not_found do |changeset|
 939           "<delete><way id='-1' changeset='#{changeset.id}' version='1'/></delete>"
 940         end
 941       end
 942
 943       def test_upload_delete_unknown_relation_placeholder
 944         check_upload_results_in_not_found do |changeset|
 945           "<delete><relation id='-1' changeset='#{changeset.id}' version='1'/></delete>"
 946         end
 947       end
 948
 949       # -------------------------------------
 950       # Test combined element changes.
 951       # -------------------------------------
 952
 953       ##
 954       # upload something which creates new objects and inserts them into
 955       # existing containers using placeholders.
 956       def test_upload_create_and_insert_elements
 957         way = create(:way)
 958         node = create(:node)
 959         relation = create(:relation)
 960         create(:way_node, :way => way, :node => node)
 961         changeset = create(:changeset)
 962
 963         diff = <<~CHANGESET
 964           <osmChange>
 965             <create>
 966               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 967                 <tag k='foo' v='bar'/>
 968                 <tag k='baz' v='bat'/>
 969               </node>
 970             </create>
 971             <modify>
 972               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 973                 <nd ref='-1'/>
 974                 <nd ref='#{node.id}'/>
 975               </way>
 976               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 977                 <member type='way' role='some' ref='#{way.id}'/>
 978                 <member type='node' role='some' ref='-1'/>
 979                 <member type='relation' role='some' ref='#{relation.id}'/>
 980               </relation>
 981             </modify>
 982           </osmChange>
 983         CHANGESET
 984
 985         auth_header = bearer_authorization_header changeset.user
 986
 987         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 988
 989         assert_response :success
 990
 991         new_node_id = nil
 992         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 993           assert_dom "> node", 1 do |(node_el)|
 994             new_node_id = node_el["new_id"].to_i
 995           end
 996           assert_dom "> way", 1
 997           assert_dom "> relation", 1
 998         end
 999
1000         assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
1001         assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
1002         Relation.find(relation.id).members.each do |type, id, _role|
1003           assert_equal new_node_id, id, "relation should contain new node" if type == "node"
1004         end
1005       end
1006
1007       ##
1008       # test that a placeholder can be reused within the same upload.
1009       def test_upload_create_modify_delete_node_reusing_placeholder
1010         changeset = create(:changeset)
1011
1012         diff = <<~CHANGESET
1013           <osmChange>
1014             <create>
1015               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1016                 <tag k="foo" v="bar"/>
1017               </node>
1018             </create>
1019             <modify>
1020               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
1021             </modify>
1022             <delete>
1023               <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
1024             </delete>
1025           </osmChange>
1026         CHANGESET
1027
1028         auth_header = bearer_authorization_header changeset.user
1029
1030         assert_difference "Node.count", 1 do
1031           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1032
1033           assert_response :success
1034         end
1035
1036         assert_dom "diffResult>node", 3
1037         assert_dom "diffResult>node[old_id='-1']", 3
1038
1039         node = Node.last
1040         assert_equal 3, node.version
1041         assert_not node.visible
1042       end
1043
1044       def test_upload_create_and_duplicate_delete
1045         changeset = create(:changeset)
1046
1047         diff = <<~CHANGESET
1048           <osmChange>
1049             <create>
1050               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1051             </create>
1052             <delete>
1053               <node id="-1" version="1" changeset="#{changeset.id}" />
1054               <node id="-1" version="1" changeset="#{changeset.id}" />
1055             </delete>
1056           </osmChange>
1057         CHANGESET
1058
1059         auth_header = bearer_authorization_header changeset.user
1060
1061         assert_no_difference "Node.count" do
1062           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1063
1064           assert_response :gone
1065         end
1066       end
1067
1068       def test_upload_create_and_duplicate_delete_if_unused
1069         changeset = create(:changeset)
1070
1071         diff = <<~CHANGESET
1072           <osmChange>
1073             <create>
1074               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1075             </create>
1076             <delete if-unused="true">
1077               <node id="-1" version="1" changeset="#{changeset.id}" />
1078               <node id="-1" version="1" changeset="#{changeset.id}" />
1079             </delete>
1080           </osmChange>
1081         CHANGESET
1082
1083         auth_header = bearer_authorization_header changeset.user
1084
1085         assert_difference "Node.count", 1 do
1086           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1087
1088           assert_response :success
1089         end
1090
1091         assert_dom "diffResult>node", 3
1092         assert_dom "diffResult>node[old_id='-1']", 3
1093         assert_dom "diffResult>node[new_version='1']", 1
1094         assert_dom "diffResult>node[new_version='2']", 1
1095
1096         node = Node.last
1097         assert_equal 2, node.version
1098         assert_not node.visible
1099       end
1100
1101       # -------------------------------------
1102       # Test bounding boxes.
1103       # -------------------------------------
1104
1105       def test_upload_bbox_of_widely_spaced_nodes
1106         user = create(:user)
1107
1108         # create an old changeset to ensure we have the maximum rate limit
1109         create(:changeset, :user => user, :created_at => Time.now.utc - 28.days)
1110
1111         changeset = create(:changeset, :user => user)
1112
1113         # upload some widely-spaced nodes, spiralling positive and negative
1114         diff = <<~CHANGESET
1115           <osmChange>
1116             <create>
1117               <node id='-1' lon='-20' lat='-10' changeset='#{changeset.id}'/>
1118               <node id='-10' lon='20'  lat='10' changeset='#{changeset.id}'/>
1119               <node id='-2' lon='-40' lat='-20' changeset='#{changeset.id}'/>
1120               <node id='-11' lon='40'  lat='20' changeset='#{changeset.id}'/>
1121               <node id='-3' lon='-60' lat='-30' changeset='#{changeset.id}'/>
1122               <node id='-12' lon='60'  lat='30' changeset='#{changeset.id}'/>
1123               <node id='-4' lon='-80' lat='-40' changeset='#{changeset.id}'/>
1124               <node id='-13' lon='80'  lat='40' changeset='#{changeset.id}'/>
1125               <node id='-5' lon='-100' lat='-50' changeset='#{changeset.id}'/>
1126               <node id='-14' lon='100'  lat='50' changeset='#{changeset.id}'/>
1127               <node id='-6' lon='-120' lat='-60' changeset='#{changeset.id}'/>
1128               <node id='-15' lon='120'  lat='60' changeset='#{changeset.id}'/>
1129               <node id='-7' lon='-140' lat='-70' changeset='#{changeset.id}'/>
1130               <node id='-16' lon='140'  lat='70' changeset='#{changeset.id}'/>
1131               <node id='-8' lon='-160' lat='-80' changeset='#{changeset.id}'/>
1132               <node id='-17' lon='160'  lat='80' changeset='#{changeset.id}'/>
1133               <node id='-9' lon='-179.9' lat='-89.9' changeset='#{changeset.id}'/>
1134               <node id='-18' lon='179.9'  lat='89.9' changeset='#{changeset.id}'/>
1135             </create>
1136           </osmChange>
1137         CHANGESET
1138
1139         auth_header = bearer_authorization_header user
1140
1141         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1142
1143         assert_response :success
1144
1145         # check that the changeset bbox is within bounds
1146         changeset.reload
1147         assert_operator changeset.min_lon, :>=, -180 * GeoRecord::SCALE, "Minimum longitude (#{changeset.min_lon / GeoRecord::SCALE}) should be >= -180 to be valid."
1148         assert_operator changeset.max_lon, :<=, 180 * GeoRecord::SCALE, "Maximum longitude (#{changeset.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
1149         assert_operator changeset.min_lat, :>=, -90 * GeoRecord::SCALE, "Minimum latitude (#{changeset.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
1150         assert_operator changeset.max_lat, :<=, 90 * GeoRecord::SCALE, "Maximum latitude (#{changeset.max_lat / GeoRecord::SCALE}) should be <= 90 to be valid."
1151       end
1152
1153       def test_upload_bbox_of_moved_node
1154         changeset = create(:changeset)
1155         node = create(:node, :lat => 1.0, :lon => 2.0)
1156
1157         diff = <<~CHANGESET
1158           <osmChange>
1159             <modify>
1160               <node id='#{node.id}' lat='1.1' lon='2.1' changeset='#{changeset.id}' version='1'/>
1161             </modify>
1162           </osmChange>
1163         CHANGESET
1164
1165         auth_header = bearer_authorization_header changeset.user
1166
1167         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1168
1169         assert_response :success
1170
1171         # check the bbox
1172         changeset.reload
1173         assert_equal 1.0 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.0 degrees"
1174         assert_equal 2.0 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.0 degrees"
1175         assert_equal 1.1 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.1 degrees"
1176         assert_equal 2.1 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.1 degrees"
1177       end
1178
1179       def test_upload_bbox_of_extended_way
1180         way = create(:way)
1181         initial_node = create(:node, :lat => 1.1, :lon => 2.1)
1182         create(:way_node, :way => way, :node => initial_node)
1183         added_node = create(:node, :lat => 1.3, :lon => 2.3)
1184         changeset = create(:changeset)
1185
1186         diff = <<~CHANGESET
1187           <osmChange>
1188             <modify>
1189               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
1190                 <nd ref='#{initial_node.id}'/>
1191                 <nd ref='#{added_node.id}'/>
1192               </way>
1193             </modify>
1194           </osmChange>
1195         CHANGESET
1196
1197         auth_header = bearer_authorization_header changeset.user
1198
1199         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1200
1201         assert_response :success
1202
1203         # check the bbox
1204         changeset.reload
1205         assert_equal 1.1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.1 degrees"
1206         assert_equal 2.1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.1 degrees"
1207         assert_equal 1.3 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.3 degrees"
1208         assert_equal 2.3 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.3 degrees"
1209       end
1210
1211       # -------------------------------------
1212       # Test upload rate/size limits.
1213       # -------------------------------------
1214
1215       def test_upload_initial_rate_limit
1216         user = create(:user)
1217         node = create(:node)
1218         way = create(:way_with_nodes, :nodes_count => 2)
1219         relation = create(:relation)
1220
1221         # create a changeset that puts us near the initial rate limit
1222         changeset = create(:changeset, :user => user,
1223                                        :created_at => Time.now.utc - 5.minutes,
1224                                        :num_changes => Settings.initial_changes_per_hour - 2)
1225
1226         diff = <<~CHANGESET
1227           <osmChange>
1228             <create>
1229               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1230                 <tag k='foo' v='bar'/>
1231                 <tag k='baz' v='bat'/>
1232               </node>
1233               <way id='-1' changeset='#{changeset.id}'>
1234                 <nd ref='#{node.id}'/>
1235               </way>
1236             </create>
1237             <create>
1238               <relation id='-1' changeset='#{changeset.id}'>
1239                 <member type='way' role='some' ref='#{way.id}'/>
1240                 <member type='node' role='some' ref='#{node.id}'/>
1241                 <member type='relation' role='some' ref='#{relation.id}'/>
1242               </relation>
1243             </create>
1244           </osmChange>
1245         CHANGESET
1246
1247         auth_header = bearer_authorization_header user
1248
1249         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1250
1251         assert_response :too_many_requests, "upload did not hit rate limit"
1252       end
1253
1254       def test_upload_maximum_rate_limit
1255         user = create(:user)
1256         node = create(:node)
1257         way = create(:way_with_nodes, :nodes_count => 2)
1258         relation = create(:relation)
1259
1260         # create a changeset to establish our initial edit time
1261         changeset = create(:changeset, :user => user,
1262                                        :created_at => Time.now.utc - 28.days)
1263
1264         # create changeset to put us near the maximum rate limit
1265         total_changes = Settings.max_changes_per_hour - 2
1266         while total_changes.positive?
1267           changes = [total_changes, Changeset::MAX_ELEMENTS].min
1268           changeset = create(:changeset, :user => user,
1269                                          :created_at => Time.now.utc - 5.minutes,
1270                                          :num_changes => changes)
1271           total_changes -= changes
1272         end
1273
1274         diff = <<~CHANGESET
1275           <osmChange>
1276             <create>
1277               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1278                 <tag k='foo' v='bar'/>
1279                 <tag k='baz' v='bat'/>
1280               </node>
1281               <way id='-1' changeset='#{changeset.id}'>
1282                 <nd ref='#{node.id}'/>
1283               </way>
1284             </create>
1285             <create>
1286               <relation id='-1' changeset='#{changeset.id}'>
1287                 <member type='way' role='some' ref='#{way.id}'/>
1288                 <member type='node' role='some' ref='#{node.id}'/>
1289                 <member type='relation' role='some' ref='#{relation.id}'/>
1290               </relation>
1291             </create>
1292           </osmChange>
1293         CHANGESET
1294
1295         auth_header = bearer_authorization_header user
1296
1297         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1298
1299         assert_response :too_many_requests, "upload did not hit rate limit"
1300       end
1301
1302       def test_upload_initial_size_limit
1303         user = create(:user)
1304
1305         # create a changeset that puts us near the initial size limit
1306         changeset = create(:changeset, :user => user,
1307                                        :min_lat => (-0.5 * GeoRecord::SCALE).round, :min_lon => (0.5 * GeoRecord::SCALE).round,
1308                                        :max_lat => (0.5 * GeoRecord::SCALE).round, :max_lon => (2.5 * GeoRecord::SCALE).round)
1309
1310         diff = <<~CHANGESET
1311           <osmChange>
1312             <create>
1313               <node id='-1' lon='0.9' lat='2.9' changeset='#{changeset.id}'>
1314                 <tag k='foo' v='bar'/>
1315                 <tag k='baz' v='bat'/>
1316               </node>
1317             </create>
1318           </osmChange>
1319         CHANGESET
1320
1321         auth_header = bearer_authorization_header user
1322
1323         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1324
1325         assert_response :payload_too_large, "upload did not hit size limit"
1326       end
1327
1328       def test_upload_size_limit_after_one_week
1329         user = create(:user)
1330
1331         # create a changeset to establish our initial edit time
1332         create(:changeset, :user => user, :created_at => Time.now.utc - 7.days)
1333
1334         # create a changeset that puts us near the initial size limit
1335         changeset = create(:changeset, :user => user, :bbox => [0.5, -0.5, 2.5, 0.5])
1336
1337         diff = <<~CHANGESET
1338           <osmChange>
1339             <create>
1340               <node id='-1' lon='35' lat='35' changeset='#{changeset.id}'>
1341                 <tag k='foo' v='bar'/>
1342                 <tag k='baz' v='bat'/>
1343               </node>
1344             </create>
1345           </osmChange>
1346         CHANGESET
1347
1348         auth_header = bearer_authorization_header user
1349
1350         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1351
1352         assert_response :payload_too_large, "upload did not hit size limit"
1353       end
1354
1355       private
1356
1357       def check_upload_results_in_not_found(&)
1358         changeset = create(:changeset)
1359         diff = "<osmChange>#{yield changeset}</osmChange>"
1360         auth_header = bearer_authorization_header changeset.user
1361
1362         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1363
1364         assert_response :not_found
1365         changeset.reload
1366         assert_equal 0, changeset.num_changes
1367       end
1368     end
1369   end
1370 end