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_node
 197         user = create(:user)
 198         changeset = create(:changeset, :user => user)
 199
 200         diff = <<~CHANGESET
 201           <osmChange>
 202             <create>
 203               <node id='-1' lon='30' lat='60' changeset='#{changeset.id}'>
 204                 <tag k='amenity' v='bar'/>
 205                 <tag k='name' v='Foo'/>
 206               </node>
 207             </create>
 208           </osmChange>
 209         CHANGESET
 210
 211         auth_header = bearer_authorization_header user
 212
 213         assert_difference "Node.count" => 1,
 214                           "OldNode.count" => 1,
 215                           "NodeTag.count" => 2,
 216                           "OldNodeTag.count" => 2 do
 217           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 218
 219           assert_response :success
 220         end
 221
 222         node = nil
 223         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 224           assert_dom "> node", 1 do |(node_el)|
 225             node = Node.find(node_el["new_id"].to_i)
 226             assert_dom "> @old_id", "-1"
 227             assert_dom "> @new_version", "1"
 228           end
 229         end
 230
 231         assert_equal 1, node.version
 232         assert_equal changeset, node.changeset
 233         assert_predicate node, :visible?
 234         assert_equal({ "name" => "Foo", "amenity" => "bar" }, node.tags)
 235         assert_equal 60, node.lat
 236         assert_equal 30, node.lon
 237       end
 238
 239       def test_upload_create_way
 240         node1 = create(:node)
 241         node2 = create(:node)
 242         user = create(:user)
 243         changeset = create(:changeset, :user => user)
 244
 245         diff = <<~CHANGESET
 246           <osmChange>
 247             <create>
 248               <way id='-1' changeset='#{changeset.id}'>
 249                 <tag k='highway' v='primary'/>
 250                 <tag k='name' v='Foo'/>
 251                 <nd ref='#{node1.id}'/>
 252                 <nd ref='#{node2.id}'/>
 253               </way>
 254             </create>
 255           </osmChange>
 256         CHANGESET
 257
 258         auth_header = bearer_authorization_header user
 259
 260         assert_difference "Way.count" => 1,
 261                           "OldWay.count" => 1,
 262                           "WayTag.count" => 2,
 263                           "OldWayTag.count" => 2,
 264                           "WayNode.count" => 2,
 265                           "OldWayNode.count" => 2 do
 266           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 267
 268           assert_response :success
 269         end
 270
 271         way = nil
 272         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 273           assert_dom "> way", 1 do |(way_el)|
 274             way = Way.find(way_el["new_id"].to_i)
 275             assert_dom "> @old_id", "-1"
 276             assert_dom "> @new_version", "1"
 277           end
 278         end
 279
 280         assert_equal 1, way.version
 281         assert_equal changeset, way.changeset
 282         assert_predicate way, :visible?
 283         assert_equal({ "name" => "Foo", "highway" => "primary" }, way.tags)
 284         assert_equal [node1, node2], way.nodes
 285       end
 286
 287       def test_upload_create_relation
 288         node1 = create(:node)
 289         way1 = create(:way_with_nodes)
 290         relation1 = create(:relation)
 291         user = create(:user)
 292         changeset = create(:changeset, :user => user)
 293
 294         diff = <<~CHANGESET
 295           <osmChange>
 296             <create>
 297               <relation id='-1' changeset='#{changeset.id}'>
 298                 <member type='node' role='n_role' ref='#{node1.id}'/>
 299                 <member type='way' role='w_role' ref='#{way1.id}'/>
 300                 <member type='relation' role='r_role' ref='#{relation1.id}'/>
 301                 <tag k='type' v='collection'/>
 302               </relation>
 303             </create>
 304           </osmChange>
 305         CHANGESET
 306
 307         auth_header = bearer_authorization_header user
 308
 309         assert_difference "Relation.count" => 1,
 310                           "OldRelation.count" => 1,
 311                           "RelationTag.count" => 1,
 312                           "OldRelationTag.count" => 1,
 313                           "RelationMember.count" => 3,
 314                           "OldRelationMember.count" => 3 do
 315           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 316
 317           assert_response :success
 318         end
 319
 320         relation = nil
 321         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 322           assert_dom "> relation", 1 do |(relation_el)|
 323             relation = Relation.find(relation_el["new_id"].to_i)
 324             assert_dom "> @old_id", "-1"
 325             assert_dom "> @new_version", "1"
 326           end
 327         end
 328
 329         assert_equal 1, relation.version
 330         assert_equal changeset, relation.changeset
 331         assert_predicate relation, :visible?
 332         assert_equal({ "type" => "collection" }, relation.tags)
 333         assert_equal [["Node", node1.id, "n_role"],
 334                       ["Way", way1.id, "w_role"],
 335                       ["Relation", relation1.id, "r_role"]], relation.members
 336       end
 337
 338       def test_upload_create_elements
 339         user = create(:user)
 340         changeset = create(:changeset, :user => user)
 341         node = create(:node)
 342         way = create(:way_with_nodes, :nodes_count => 2)
 343         relation = create(:relation)
 344
 345         diff = <<~CHANGESET
 346           <osmChange>
 347             <create>
 348               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 349                 <tag k='foo' v='bar'/>
 350                 <tag k='baz' v='bat'/>
 351               </node>
 352               <way id='-1' changeset='#{changeset.id}'>
 353                 <nd ref='#{node.id}'/>
 354               </way>
 355             </create>
 356             <create>
 357               <relation id='-1' changeset='#{changeset.id}'>
 358                 <member type='way' role='some' ref='#{way.id}'/>
 359                 <member type='node' role='some' ref='#{node.id}'/>
 360                 <member type='relation' role='some' ref='#{relation.id}'/>
 361               </relation>
 362             </create>
 363           </osmChange>
 364         CHANGESET
 365
 366         auth_header = bearer_authorization_header user
 367
 368         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 369
 370         assert_response :success
 371
 372         new_node_id, new_way_id, new_rel_id = nil
 373         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 374           # inspect the response to find out what the new element IDs are
 375           # check the old IDs are all present and negative one
 376           # check the versions are present and equal one
 377           assert_dom "> node", 1 do |(node_el)|
 378             new_node_id = node_el["new_id"].to_i
 379             assert_dom "> @old_id", "-1"
 380             assert_dom "> @new_version", "1"
 381           end
 382           assert_dom "> way", 1 do |(way_el)|
 383             new_way_id = way_el["new_id"].to_i
 384             assert_dom "> @old_id", "-1"
 385             assert_dom "> @new_version", "1"
 386           end
 387           assert_dom "> relation", 1 do |(rel_el)|
 388             new_rel_id = rel_el["new_id"].to_i
 389             assert_dom "> @old_id", "-1"
 390             assert_dom "> @new_version", "1"
 391           end
 392         end
 393
 394         assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
 395         assert_equal 0, Way.find(new_way_id).tags.size, "new way should have no tags"
 396         assert_equal 0, Relation.find(new_rel_id).tags.size, "new relation should have no tags"
 397       end
 398
 399       ##
 400       # upload an element with a really long tag value
 401       def test_upload_create_node_with_tag_too_long
 402         changeset = create(:changeset)
 403
 404         diff = <<~CHANGESET
 405           <osmChange>
 406             <create>
 407               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 408                 <tag k='foo' v='#{'x' * 256}'/>
 409               </node>
 410             </create>
 411           </osmChange>
 412         CHANGESET
 413
 414         auth_header = bearer_authorization_header changeset.user
 415
 416         assert_no_difference "Node.count" do
 417           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 418
 419           assert_response :bad_request
 420         end
 421       end
 422
 423       def test_upload_create_nodes_with_invalid_placeholder_reuse_in_one_action_block
 424         changeset = create(:changeset)
 425
 426         diff = <<~CHANGESET
 427           <osmChange>
 428             <create>
 429               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
 430               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 431             </create>
 432           </osmChange>
 433         CHANGESET
 434
 435         auth_header = bearer_authorization_header changeset.user
 436
 437         assert_no_difference "Node.count" do
 438           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 439
 440           assert_response :bad_request
 441         end
 442       end
 443
 444       def test_upload_create_nodes_with_invalid_placeholder_reuse_in_two_action_blocks
 445         changeset = create(:changeset)
 446
 447         diff = <<~CHANGESET
 448           <osmChange>
 449             <create>
 450               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/>
 451             </create>
 452             <create>
 453               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 454             </create>
 455           </osmChange>
 456         CHANGESET
 457
 458         auth_header = bearer_authorization_header changeset.user
 459
 460         assert_no_difference "Node.count" do
 461           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 462
 463           assert_response :bad_request
 464         end
 465       end
 466
 467       def test_upload_create_way_referring_node_placeholder_defined_later
 468         changeset = create(:changeset)
 469
 470         diff = <<~CHANGESET
 471           <osmChange>
 472             <create>
 473               <way id="-1" changeset="#{changeset.id}">
 474                 <nd ref="-1"/>
 475               </way>
 476               <node id="-1" lat="1" lon="2" changeset="#{changeset.id}"/>
 477             </create>
 478           </osmChange>
 479         CHANGESET
 480
 481         auth_header = bearer_authorization_header changeset.user
 482
 483         assert_no_difference "Node.count" do
 484           assert_no_difference "Way.count" do
 485             post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 486
 487             assert_response :bad_request
 488           end
 489         end
 490         assert_equal "Placeholder node not found for reference -1 in way -1", @response.body
 491       end
 492
 493       def test_upload_create_way_referring_undefined_node_placeholder
 494         changeset = create(:changeset)
 495
 496         diff = <<~CHANGESET
 497           <osmChange>
 498             <create>
 499               <way id="-1" changeset="#{changeset.id}">
 500                 <nd ref="-1"/>
 501               </way>
 502             </create>
 503           </osmChange>
 504         CHANGESET
 505
 506         auth_header = bearer_authorization_header changeset.user
 507
 508         assert_no_difference "Way.count" do
 509           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 510
 511           assert_response :bad_request
 512         end
 513         assert_equal "Placeholder node not found for reference -1 in way -1", @response.body
 514       end
 515
 516       def test_upload_create_existing_way_referring_undefined_node_placeholder
 517         changeset = create(:changeset)
 518         way = create(:way)
 519
 520         diff = <<~CHANGESET
 521           <osmChange>
 522             <create>
 523               <way id="#{way.id}" changeset="#{changeset.id}" version="1">
 524                 <nd ref="-1"/>
 525               </way>
 526             </create>
 527           </osmChange>
 528         CHANGESET
 529
 530         auth_header = bearer_authorization_header changeset.user
 531
 532         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 533
 534         assert_response :bad_request
 535         assert_equal "Placeholder node not found for reference -1 in way #{way.id}", @response.body
 536
 537         way.reload
 538         assert_equal 1, way.version
 539       end
 540
 541       def test_upload_create_relation_referring_undefined_node_placeholder
 542         changeset = create(:changeset)
 543
 544         diff = <<~CHANGESET
 545           <osmChange>
 546             <create>
 547               <relation id="-1" changeset="#{changeset.id}" version="1">
 548                 <member type="node" role="foo" ref="-1"/>
 549               </relation>
 550             </create>
 551           </osmChange>
 552         CHANGESET
 553
 554         auth_header = bearer_authorization_header changeset.user
 555
 556         assert_no_difference "Relation.count" do
 557           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 558
 559           assert_response :bad_request
 560         end
 561         assert_equal "Placeholder Node not found for reference -1 in relation -1.", @response.body
 562       end
 563
 564       def test_upload_create_existing_relation_referring_undefined_way_placeholder
 565         changeset = create(:changeset)
 566         relation = create(:relation)
 567
 568         diff = <<~CHANGESET
 569           <osmChange>
 570             <create>
 571               <relation id="#{relation.id}" changeset="#{changeset.id}" version="1">
 572                 <member type="way" role="bar" ref="-1"/>
 573               </relation>
 574             </create>
 575           </osmChange>
 576         CHANGESET
 577
 578         auth_header = bearer_authorization_header changeset.user
 579
 580         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 581
 582         assert_response :bad_request
 583         assert_equal "Placeholder Way not found for reference -1 in relation #{relation.id}.", @response.body
 584
 585         relation.reload
 586         assert_equal 1, relation.version
 587       end
 588
 589       def test_upload_create_relations_with_circular_references
 590         changeset = create(:changeset)
 591
 592         diff = <<~CHANGESET
 593           <osmChange version='0.6'>
 594             <create>
 595               <relation id='-2' version='0' changeset='#{changeset.id}'>
 596                 <member type='relation' role='' ref='-4' />
 597                 <tag k='type' v='route' />
 598                 <tag k='name' v='AtoB' />
 599               </relation>
 600               <relation id='-3' version='0' changeset='#{changeset.id}'>
 601                 <tag k='type' v='route' />
 602                 <tag k='name' v='BtoA' />
 603               </relation>
 604               <relation id='-4' version='0' changeset='#{changeset.id}'>
 605                 <member type='relation' role='' ref='-2' />
 606                 <member type='relation' role='' ref='-3' />
 607                 <tag k='type' v='route_master' />
 608                 <tag k='name' v='master' />
 609               </relation>
 610             </create>
 611           </osmChange>
 612         CHANGESET
 613
 614         auth_header = bearer_authorization_header changeset.user
 615
 616         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 617
 618         assert_response :bad_request
 619         assert_equal "Placeholder Relation not found for reference -4 in relation -2.", @response.body
 620       end
 621
 622       # -------------------------------------
 623       # Test modifying elements.
 624       # -------------------------------------
 625
 626       def test_upload_modify_node
 627         user = create(:user)
 628         changeset = create(:changeset, :user => user)
 629         node = create(:node, :latitude => 0, :longitude => 0)
 630         create(:node_tag, :node => node)
 631
 632         diff = <<~CHANGESET
 633           <osmChange>
 634             <modify>
 635               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
 636             </modify>
 637           </osmChange>
 638         CHANGESET
 639
 640         auth_header = bearer_authorization_header user
 641
 642         assert_difference "Node.count" => 0,
 643                           "OldNode.count" => 1,
 644                           "NodeTag.count" => -1,
 645                           "OldNodeTag.count" => 0 do
 646           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 647
 648           assert_response :success
 649         end
 650
 651         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 652           assert_dom "> node", 1 do
 653             assert_dom "> @old_id", node.id.to_s
 654             assert_dom "> @new_id", node.id.to_s
 655             assert_dom "> @new_version", "2"
 656           end
 657         end
 658
 659         changeset.reload
 660         assert_equal 1, changeset.num_changes
 661         node.reload
 662         assert_equal 2, node.version
 663         assert_equal 2 * GeoRecord::SCALE, node.latitude
 664         assert_equal 1 * GeoRecord::SCALE, node.longitude
 665         assert_equal 0, node.tags.size, "node #{node.id} should now have no tags"
 666       end
 667
 668       def test_upload_modify_way
 669         user = create(:user)
 670         changeset = create(:changeset, :user => user)
 671         node = create(:node)
 672         way = create(:way_with_nodes, :nodes_count => 3)
 673         create(:way_tag, :way => way)
 674
 675         diff = <<~CHANGESET
 676           <osmChange>
 677             <modify>
 678               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 679                 <nd ref='#{node.id}'/>
 680               </way>
 681             </modify>
 682           </osmChange>
 683         CHANGESET
 684
 685         auth_header = bearer_authorization_header user
 686
 687         assert_difference "Way.count" => 0,
 688                           "OldWay.count" => 1,
 689                           "WayTag.count" => -1,
 690                           "OldWayTag.count" => 0,
 691                           "WayNode.count" => -2,
 692                           "OldWayNode.count" => 1 do
 693           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 694
 695           assert_response :success
 696         end
 697
 698         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 699           assert_dom "> way", 1 do
 700             assert_dom "> @old_id", way.id.to_s
 701             assert_dom "> @new_id", way.id.to_s
 702             assert_dom "> @new_version", "2"
 703           end
 704         end
 705
 706         changeset.reload
 707         assert_equal 1, changeset.num_changes
 708         way.reload
 709         assert_equal 2, way.version
 710         assert_equal 0, way.tags.size, "way #{way.id} should now have no tags"
 711         assert_equal [node], way.nodes
 712       end
 713
 714       def test_upload_modify_relation
 715         user = create(:user)
 716         changeset = create(:changeset, :user => user)
 717         node = create(:node)
 718         way = create(:way_with_nodes)
 719         relation = create(:relation)
 720         other_relation = create(:relation)
 721         create(:relation_tag, :relation => relation)
 722
 723         diff = <<~CHANGESET
 724           <osmChange>
 725             <modify>
 726               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 727                 <member type='way' role='some' ref='#{way.id}'/>
 728                 <member type='node' role='some' ref='#{node.id}'/>
 729                 <member type='relation' role='some' ref='#{other_relation.id}'/>
 730               </relation>
 731             </modify>
 732           </osmChange>
 733         CHANGESET
 734
 735         auth_header = bearer_authorization_header user
 736
 737         assert_difference "Relation.count" => 0,
 738                           "OldRelation.count" => 1,
 739                           "RelationTag.count" => -1,
 740                           "OldRelationTag.count" => 0,
 741                           "RelationMember.count" => 3,
 742                           "OldRelationMember.count" => 3 do
 743           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 744
 745           assert_response :success
 746         end
 747
 748         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 749           assert_dom "> relation", 1 do
 750             assert_dom "> @old_id", relation.id.to_s
 751             assert_dom "> @new_id", relation.id.to_s
 752             assert_dom "> @new_version", "2"
 753           end
 754         end
 755
 756         changeset.reload
 757         assert_equal 1, changeset.num_changes
 758         relation.reload
 759         assert_equal 2, relation.version
 760         assert_equal 0, relation.tags.size, "relation #{relation.id} should now have no tags"
 761         assert_equal [["Way", way.id, "some"], ["Node", node.id, "some"], ["Relation", other_relation.id, "some"]], relation.members
 762       end
 763
 764       def test_upload_modify_elements
 765         user = create(:user)
 766         changeset = create(:changeset, :user => user)
 767         node = create(:node, :latitude => 0, :longitude => 0)
 768         way = create(:way)
 769         relation = create(:relation)
 770         other_relation = create(:relation)
 771
 772         # create some tags, since we test that they are removed later
 773         create(:node_tag, :node => node)
 774         create(:way_tag, :way => way)
 775         create(:relation_tag, :relation => relation)
 776
 777         # simple diff to change a node, way and relation by removing their tags
 778         diff = <<~CHANGESET
 779           <osmChange>
 780             <modify>
 781               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
 782               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 783                 <nd ref='#{node.id}'/>
 784               </way>
 785             </modify>
 786             <modify>
 787               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 788                 <member type='way' role='some' ref='#{way.id}'/>
 789                 <member type='node' role='some' ref='#{node.id}'/>
 790                 <member type='relation' role='some' ref='#{other_relation.id}'/>
 791               </relation>
 792             </modify>
 793           </osmChange>
 794         CHANGESET
 795
 796         auth_header = bearer_authorization_header user
 797
 798         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 799
 800         assert_response :success
 801
 802         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 803           assert_dom "> node", 1 do
 804             assert_dom "> @old_id", node.id.to_s
 805             assert_dom "> @new_id", node.id.to_s
 806             assert_dom "> @new_version", "2"
 807           end
 808           assert_dom "> way", 1 do
 809             assert_dom "> @old_id", way.id.to_s
 810             assert_dom "> @new_id", way.id.to_s
 811             assert_dom "> @new_version", "2"
 812           end
 813           assert_dom "> relation", 1 do
 814             assert_dom "> @old_id", relation.id.to_s
 815             assert_dom "> @new_id", relation.id.to_s
 816             assert_dom "> @new_version", "2"
 817           end
 818         end
 819
 820         changeset.reload
 821         assert_equal 3, changeset.num_changes
 822         node.reload
 823         assert_equal 2, node.version
 824         assert_equal 2 * GeoRecord::SCALE, node.latitude
 825         assert_equal 1 * GeoRecord::SCALE, node.longitude
 826         assert_equal 0, node.tags.size, "node #{node.id} should now have no tags"
 827         way.reload
 828         assert_equal 2, way.version
 829         assert_equal 0, way.tags.size, "way #{way.id} should now have no tags"
 830         assert_equal [node], way.nodes
 831         relation.reload
 832         assert_equal 2, relation.version
 833         assert_equal 0, relation.tags.size, "relation #{relation.id} should now have no tags"
 834         assert_equal [["Way", way.id, "some"], ["Node", node.id, "some"], ["Relation", other_relation.id, "some"]], relation.members
 835       end
 836
 837       ##
 838       # upload multiple versions of the same element in the same diff.
 839       def test_upload_modify_multiple_node_versions
 840         node = create(:node)
 841         changeset = create(:changeset)
 842
 843         # change the location of a node multiple times, each time referencing
 844         # the last version. doesn't this depend on version numbers being
 845         # sequential?
 846         diff = <<~CHANGESET
 847           <osmChange>
 848             <modify>
 849               <node id='#{node.id}' lon='0.0' lat='0.0' changeset='#{changeset.id}' version='1'/>
 850               <node id='#{node.id}' lon='0.1' lat='0.0' changeset='#{changeset.id}' version='2'/>
 851               <node id='#{node.id}' lon='0.1' lat='0.1' changeset='#{changeset.id}' version='3'/>
 852               <node id='#{node.id}' lon='0.1' lat='0.2' changeset='#{changeset.id}' version='4'/>
 853               <node id='#{node.id}' lon='0.2' lat='0.2' changeset='#{changeset.id}' version='5'/>
 854               <node id='#{node.id}' lon='0.3' lat='0.2' changeset='#{changeset.id}' version='6'/>
 855               <node id='#{node.id}' lon='0.3' lat='0.3' changeset='#{changeset.id}' version='7'/>
 856               <node id='#{node.id}' lon='0.9' lat='0.9' changeset='#{changeset.id}' version='8'/>
 857             </modify>
 858           </osmChange>
 859         CHANGESET
 860
 861         auth_header = bearer_authorization_header changeset.user
 862
 863         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 864
 865         assert_response :success
 866
 867         assert_dom "diffResult>node", 8
 868
 869         node.reload
 870         assert_equal 9, node.version
 871         assert_equal 0.9 * GeoRecord::SCALE, node.latitude
 872         assert_equal 0.9 * GeoRecord::SCALE, node.longitude
 873       end
 874
 875       ##
 876       # upload multiple versions of the same element in the same diff, but
 877       # keep the version numbers the same.
 878       def test_upload_modify_duplicate_node_versions
 879         node = create(:node, :latitude => 0, :longitude => 0)
 880         changeset = create(:changeset)
 881
 882         diff = <<~CHANGESET
 883           <osmChange>
 884             <modify>
 885               <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 886               <node id='#{node.id}' lon='2' lat='2' changeset='#{changeset.id}' version='1'/>
 887             </modify>
 888           </osmChange>
 889         CHANGESET
 890
 891         auth_header = bearer_authorization_header changeset.user
 892
 893         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 894
 895         assert_response :conflict
 896
 897         node.reload
 898         assert_equal 1, node.version
 899         assert_equal 0, node.latitude
 900         assert_equal 0, node.longitude
 901       end
 902
 903       ##
 904       # try to upload some elements without specifying the version
 905       def test_upload_modify_missing_node_version
 906         node = create(:node, :latitude => 0, :longitude => 0)
 907         changeset = create(:changeset)
 908
 909         diff = <<~CHANGESET
 910           <osmChange>
 911             <modify>
 912               <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}'/>
 913             </modify>
 914           </osmChange>
 915         CHANGESET
 916
 917         auth_header = bearer_authorization_header changeset.user
 918
 919         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 920
 921         assert_response :bad_request
 922
 923         node.reload
 924         assert_equal 1, node.version
 925         assert_equal 0, node.latitude
 926         assert_equal 0, node.longitude
 927       end
 928
 929       ##
 930       # create a diff which references several changesets, which should cause
 931       # a rollback and none of the diff gets committed
 932       def test_upload_modify_with_references_to_different_changesets
 933         changeset1 = create(:changeset)
 934         changeset2 = create(:changeset, :user => changeset1.user)
 935         node1 = create(:node)
 936         node2 = create(:node)
 937
 938         # simple diff to create a node way and relation using placeholders
 939         diff = <<~CHANGESET
 940           <osmChange>
 941             <modify>
 942               <node id='#{node1.id}' lon='0' lat='0' changeset='#{changeset1.id}' version='1'/>
 943             </modify>
 944             <modify>
 945               <node id='#{node2.id}' lon='0' lat='0' changeset='#{changeset2.id}' version='1'/>
 946             </modify>
 947           </osmChange>
 948         CHANGESET
 949
 950         auth_header = bearer_authorization_header changeset1.user
 951
 952         post api_changeset_upload_path(changeset1), :params => diff, :headers => auth_header
 953
 954         assert_response :conflict
 955
 956         assert_nodes_are_equal(node1, Node.find(node1.id))
 957         assert_nodes_are_equal(node2, Node.find(node2.id))
 958       end
 959
 960       ##
 961       # upload a valid changeset which has a mixture of whitespace
 962       # to check a bug https://github.com/openstreetmap/trac-tickets/issues/1565
 963       def test_upload_modify_with_mixed_whitespace
 964         changeset = create(:changeset)
 965         node = create(:node)
 966         way = create(:way_with_nodes, :nodes_count => 2)
 967         relation = create(:relation)
 968         other_relation = create(:relation)
 969         create(:relation_tag, :relation => relation)
 970
 971         diff = <<~CHANGESET
 972           <osmChange>
 973           <modify><node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}'
 974             version='1'></node>
 975             <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='2'><tag k='k' v='v'/></node></modify>
 976           <modify>
 977           <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'><member
 978             type='way' role='some' ref='#{way.id}'/><member
 979               type='node' role='some' ref='#{node.id}'/>
 980             <member type='relation' role='some' ref='#{other_relation.id}'/>
 981             </relation>
 982           </modify></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         assert_dom "diffResult>node", 2
 992         assert_dom "diffResult>relation", 1
 993
 994         assert_equal 1, Node.find(node.id).tags.size, "node #{node.id} should now have one tag"
 995         assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
 996       end
 997
 998       def test_upload_modify_unknown_node_placeholder
 999         check_upload_results_in_not_found do |changeset|
1000           "<modify><node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/></modify>"
1001         end
1002       end
1003
1004       def test_upload_modify_unknown_way_placeholder
1005         check_upload_results_in_not_found do |changeset|
1006           "<modify><way id='-1' changeset='#{changeset.id}' version='1'/></modify>"
1007         end
1008       end
1009
1010       def test_upload_modify_unknown_relation_placeholder
1011         check_upload_results_in_not_found do |changeset|
1012           "<modify><relation id='-1' changeset='#{changeset.id}' version='1'/></modify>"
1013         end
1014       end
1015
1016       # -------------------------------------
1017       # Test deleting elements.
1018       # -------------------------------------
1019
1020       def test_upload_delete_node
1021         changeset = create(:changeset)
1022         node = create(:node, :lat => 0, :lon => 0)
1023         create(:node_tag, :node => node)
1024
1025         diff = <<~CHANGESET
1026           <osmChange>
1027             <delete>
1028               <node id='#{node.id}' changeset='#{changeset.id}' version='1' lat='0' lon='0'/>
1029             </delete>
1030           </osmChange>
1031         CHANGESET
1032
1033         auth_header = bearer_authorization_header changeset.user
1034
1035         assert_difference "Node.count" => 0,
1036                           "OldNode.count" => 1,
1037                           "NodeTag.count" => -1,
1038                           "OldNodeTag.count" => 0 do
1039           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1040
1041           assert_response :success
1042         end
1043
1044         assert_dom "diffResult", 1 do
1045           assert_dom "> node", 1 do
1046             assert_dom "> @old_id", node.id.to_s
1047           end
1048         end
1049
1050         node.reload
1051         assert_not_predicate node, :visible?
1052       end
1053
1054       def test_upload_delete_way
1055         changeset = create(:changeset)
1056         way = create(:way_with_nodes, :nodes_count => 3)
1057         create(:way_tag, :way => way)
1058
1059         diff = <<~CHANGESET
1060           <osmChange>
1061             <delete>
1062               <way id='#{way.id}' changeset='#{changeset.id}' version='1'/>
1063             </delete>
1064           </osmChange>
1065         CHANGESET
1066
1067         auth_header = bearer_authorization_header changeset.user
1068
1069         assert_difference "Way.count" => 0,
1070                           "OldWay.count" => 1,
1071                           "WayTag.count" => -1,
1072                           "OldWayTag.count" => 0,
1073                           "WayNode.count" => -3,
1074                           "OldWayNode.count" => 0 do
1075           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1076
1077           assert_response :success
1078         end
1079
1080         assert_dom "diffResult", 1 do
1081           assert_dom "> way", 1 do
1082             assert_dom "> @old_id", way.id.to_s
1083           end
1084         end
1085
1086         way.reload
1087         assert_not_predicate way, :visible?
1088       end
1089
1090       def test_upload_delete_relation
1091         changeset = create(:changeset)
1092         relation = create(:relation)
1093         create(:relation_member, :relation => relation, :member => create(:node))
1094         create(:relation_tag, :relation => relation)
1095
1096         diff = <<~CHANGESET
1097           <osmChange>
1098             <delete>
1099               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'/>
1100             </delete>
1101           </osmChange>
1102         CHANGESET
1103
1104         auth_header = bearer_authorization_header changeset.user
1105
1106         assert_difference "Relation.count" => 0,
1107                           "OldRelation.count" => 1,
1108                           "RelationTag.count" => -1,
1109                           "OldRelationTag.count" => 0,
1110                           "RelationMember.count" => -1,
1111                           "OldRelationMember.count" => 0 do
1112           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1113
1114           assert_response :success
1115         end
1116
1117         assert_dom "diffResult", 1 do
1118           assert_dom "> relation", 1 do
1119             assert_dom "> @old_id", relation.id.to_s
1120           end
1121         end
1122
1123         relation.reload
1124         assert_not_predicate relation, :visible?
1125       end
1126
1127       ##
1128       # test a complex delete where we delete elements which rely on each other
1129       # in the same transaction.
1130       def test_upload_delete_elements
1131         changeset = create(:changeset)
1132         super_relation = create(:relation)
1133         used_relation = create(:relation)
1134         used_way = create(:way)
1135         used_node = create(:node)
1136         create(:relation_member, :relation => super_relation, :member => used_relation)
1137         create(:relation_member, :relation => super_relation, :member => used_way)
1138         create(:relation_member, :relation => super_relation, :member => used_node)
1139
1140         diff = XML::Document.new
1141         diff.root = XML::Node.new "osmChange"
1142         delete = XML::Node.new "delete"
1143         diff.root << delete
1144         delete << xml_node_for_relation(super_relation)
1145         delete << xml_node_for_relation(used_relation)
1146         delete << xml_node_for_way(used_way)
1147         delete << xml_node_for_node(used_node)
1148         %w[node way relation].each do |type|
1149           delete.find("//osmChange/delete/#{type}").each do |n|
1150             n["changeset"] = changeset.id.to_s
1151           end
1152         end
1153
1154         auth_header = bearer_authorization_header changeset.user
1155
1156         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1157
1158         assert_response :success
1159
1160         assert_dom "diffResult", 1 do
1161           assert_dom "> node", 1
1162           assert_dom "> way", 1
1163           assert_dom "> relation", 2
1164         end
1165
1166         assert_not Node.find(used_node.id).visible
1167         assert_not Way.find(used_way.id).visible
1168         assert_not Relation.find(super_relation.id).visible
1169         assert_not Relation.find(used_relation.id).visible
1170       end
1171
1172       ##
1173       # test uploading a delete with no lat/lon, as they are optional in the osmChange spec.
1174       def test_upload_delete_node_without_latlon
1175         node = create(:node)
1176         changeset = create(:changeset)
1177
1178         diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
1179
1180         auth_header = bearer_authorization_header changeset.user
1181
1182         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1183
1184         assert_response :success
1185
1186         assert_dom "diffResult", 1 do
1187           assert_dom "> node", 1 do
1188             assert_dom "> @old_id", node.id.to_s
1189             assert_dom "> @new_id", 0
1190             assert_dom "> @new_version", 0
1191           end
1192         end
1193
1194         node.reload
1195         assert_not node.visible
1196       end
1197
1198       ##
1199       # test that deleting stuff in a transaction doesn't bypass the checks
1200       # to ensure that used elements are not deleted.
1201       def test_upload_delete_referenced_elements
1202         changeset = create(:changeset)
1203         relation = create(:relation)
1204         other_relation = create(:relation)
1205         used_way = create(:way)
1206         used_node = create(:node)
1207         create(:relation_member, :relation => relation, :member => used_way)
1208         create(:relation_member, :relation => relation, :member => used_node)
1209
1210         diff = XML::Document.new
1211         diff.root = XML::Node.new "osmChange"
1212         delete = XML::Node.new "delete"
1213         diff.root << delete
1214         delete << xml_node_for_relation(other_relation)
1215         delete << xml_node_for_way(used_way)
1216         delete << xml_node_for_node(used_node)
1217         %w[node way relation].each do |type|
1218           delete.find("//osmChange/delete/#{type}").each do |n|
1219             n["changeset"] = changeset.id.to_s
1220           end
1221         end
1222
1223         auth_header = bearer_authorization_header changeset.user
1224
1225         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1226
1227         assert_response :precondition_failed
1228         assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
1229
1230         assert Node.find(used_node.id).visible
1231         assert Way.find(used_way.id).visible
1232         assert Relation.find(relation.id).visible
1233         assert Relation.find(other_relation.id).visible
1234       end
1235
1236       ##
1237       # test that a conditional delete of an in use object works.
1238       def test_upload_delete_if_unused
1239         changeset = create(:changeset)
1240         super_relation = create(:relation)
1241         used_relation = create(:relation)
1242         used_way = create(:way)
1243         used_node = create(:node)
1244         create(:relation_member, :relation => super_relation, :member => used_relation)
1245         create(:relation_member, :relation => super_relation, :member => used_way)
1246         create(:relation_member, :relation => super_relation, :member => used_node)
1247
1248         diff = XML::Document.new
1249         diff.root = XML::Node.new "osmChange"
1250         delete = XML::Node.new "delete"
1251         diff.root << delete
1252         delete["if-unused"] = ""
1253         delete << xml_node_for_relation(used_relation)
1254         delete << xml_node_for_way(used_way)
1255         delete << xml_node_for_node(used_node)
1256         %w[node way relation].each do |type|
1257           delete.find("//osmChange/delete/#{type}").each do |n|
1258             n["changeset"] = changeset.id.to_s
1259           end
1260         end
1261
1262         auth_header = bearer_authorization_header changeset.user
1263
1264         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1265
1266         assert_response :success
1267
1268         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
1269           assert_dom "> node", 1 do
1270             assert_dom "> @old_id", used_node.id.to_s
1271             assert_dom "> @new_id", used_node.id.to_s
1272             assert_dom "> @new_version", used_node.version.to_s
1273           end
1274           assert_dom "> way", 1 do
1275             assert_dom "> @old_id", used_way.id.to_s
1276             assert_dom "> @new_id", used_way.id.to_s
1277             assert_dom "> @new_version", used_way.version.to_s
1278           end
1279           assert_dom "> relation", 1 do
1280             assert_dom "> @old_id", used_relation.id.to_s
1281             assert_dom "> @new_id", used_relation.id.to_s
1282             assert_dom "> @new_version", used_relation.version.to_s
1283           end
1284         end
1285
1286         assert Node.find(used_node.id).visible
1287         assert Way.find(used_way.id).visible
1288         assert Relation.find(used_relation.id).visible
1289       end
1290
1291       def test_upload_delete_with_multiple_blocks_and_if_unused
1292         changeset = create(:changeset)
1293         node = create(:node)
1294         way = create(:way)
1295         create(:way_node, :way => way, :node => node)
1296         alone_node = create(:node)
1297
1298         diff = <<~CHANGESET
1299           <osmChange version='0.6'>
1300             <delete version="0.6">
1301               <node id="#{node.id}" version="#{node.version}" changeset="#{changeset.id}"/>
1302             </delete>
1303             <delete version="0.6" if-unused="true">
1304               <node id="#{alone_node.id}" version="#{alone_node.version}" changeset="#{changeset.id}"/>
1305             </delete>
1306           </osmChange>
1307         CHANGESET
1308
1309         auth_header = bearer_authorization_header changeset.user
1310
1311         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1312
1313         assert_response :precondition_failed
1314
1315         assert_equal "Precondition failed: Node #{node.id} is still used by ways #{way.id}.", @response.body
1316       end
1317
1318       def test_upload_delete_unknown_node_placeholder
1319         check_upload_results_in_not_found do |changeset|
1320           "<delete><node id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1321         end
1322       end
1323
1324       def test_upload_delete_unknown_way_placeholder
1325         check_upload_results_in_not_found do |changeset|
1326           "<delete><way id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1327         end
1328       end
1329
1330       def test_upload_delete_unknown_relation_placeholder
1331         check_upload_results_in_not_found do |changeset|
1332           "<delete><relation id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1333         end
1334       end
1335
1336       # -------------------------------------
1337       # Test combined element changes.
1338       # -------------------------------------
1339
1340       ##
1341       # upload something which creates new objects and inserts them into
1342       # existing containers using placeholders.
1343       def test_upload_create_and_insert_elements
1344         way = create(:way)
1345         node = create(:node)
1346         relation = create(:relation)
1347         create(:way_node, :way => way, :node => node)
1348         changeset = create(:changeset)
1349
1350         diff = <<~CHANGESET
1351           <osmChange>
1352             <create>
1353               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1354                 <tag k='foo' v='bar'/>
1355                 <tag k='baz' v='bat'/>
1356               </node>
1357             </create>
1358             <modify>
1359               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
1360                 <nd ref='-1'/>
1361                 <nd ref='#{node.id}'/>
1362               </way>
1363               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
1364                 <member type='way' role='some' ref='#{way.id}'/>
1365                 <member type='node' role='some' ref='-1'/>
1366                 <member type='relation' role='some' ref='#{relation.id}'/>
1367               </relation>
1368             </modify>
1369           </osmChange>
1370         CHANGESET
1371
1372         auth_header = bearer_authorization_header changeset.user
1373
1374         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1375
1376         assert_response :success
1377
1378         new_node_id = nil
1379         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
1380           assert_dom "> node", 1 do |(node_el)|
1381             new_node_id = node_el["new_id"].to_i
1382           end
1383           assert_dom "> way", 1
1384           assert_dom "> relation", 1
1385         end
1386
1387         assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
1388         assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
1389         Relation.find(relation.id).members.each do |type, id, _role|
1390           assert_equal new_node_id, id, "relation should contain new node" if type == "node"
1391         end
1392       end
1393
1394       ##
1395       # test that a placeholder can be reused within the same upload.
1396       def test_upload_create_modify_delete_node_reusing_placeholder
1397         changeset = create(:changeset)
1398
1399         diff = <<~CHANGESET
1400           <osmChange>
1401             <create>
1402               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1403                 <tag k="foo" v="bar"/>
1404               </node>
1405             </create>
1406             <modify>
1407               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
1408             </modify>
1409             <delete>
1410               <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
1411             </delete>
1412           </osmChange>
1413         CHANGESET
1414
1415         auth_header = bearer_authorization_header changeset.user
1416
1417         assert_difference "Node.count", 1 do
1418           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1419
1420           assert_response :success
1421         end
1422
1423         assert_dom "diffResult>node", 3
1424         assert_dom "diffResult>node[old_id='-1']", 3
1425
1426         node = Node.last
1427         assert_equal 3, node.version
1428         assert_not node.visible
1429       end
1430
1431       def test_upload_create_and_duplicate_delete
1432         changeset = create(:changeset)
1433
1434         diff = <<~CHANGESET
1435           <osmChange>
1436             <create>
1437               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1438             </create>
1439             <delete>
1440               <node id="-1" version="1" changeset="#{changeset.id}" />
1441               <node id="-1" version="1" changeset="#{changeset.id}" />
1442             </delete>
1443           </osmChange>
1444         CHANGESET
1445
1446         auth_header = bearer_authorization_header changeset.user
1447
1448         assert_no_difference "Node.count" do
1449           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1450
1451           assert_response :gone
1452         end
1453       end
1454
1455       def test_upload_create_and_duplicate_delete_if_unused
1456         changeset = create(:changeset)
1457
1458         diff = <<~CHANGESET
1459           <osmChange>
1460             <create>
1461               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1462             </create>
1463             <delete if-unused="true">
1464               <node id="-1" version="1" changeset="#{changeset.id}" />
1465               <node id="-1" version="1" changeset="#{changeset.id}" />
1466             </delete>
1467           </osmChange>
1468         CHANGESET
1469
1470         auth_header = bearer_authorization_header changeset.user
1471
1472         assert_difference "Node.count", 1 do
1473           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1474
1475           assert_response :success
1476         end
1477
1478         assert_dom "diffResult>node", 3
1479         assert_dom "diffResult>node[old_id='-1']", 3
1480         assert_dom "diffResult>node[new_version='1']", 1
1481         assert_dom "diffResult>node[new_version='2']", 1
1482
1483         node = Node.last
1484         assert_equal 2, node.version
1485         assert_not node.visible
1486       end
1487
1488       # -------------------------------------
1489       # Test bounding boxes.
1490       # -------------------------------------
1491
1492       def test_upload_bbox_of_widely_spaced_nodes
1493         user = create(:user)
1494
1495         # create an old changeset to ensure we have the maximum rate limit
1496         create(:changeset, :user => user, :created_at => Time.now.utc - 28.days)
1497
1498         changeset = create(:changeset, :user => user)
1499
1500         # upload some widely-spaced nodes, spiralling positive and negative
1501         diff = <<~CHANGESET
1502           <osmChange>
1503             <create>
1504               <node id='-1' lon='-20' lat='-10' changeset='#{changeset.id}'/>
1505               <node id='-10' lon='20'  lat='10' changeset='#{changeset.id}'/>
1506               <node id='-2' lon='-40' lat='-20' changeset='#{changeset.id}'/>
1507               <node id='-11' lon='40'  lat='20' changeset='#{changeset.id}'/>
1508               <node id='-3' lon='-60' lat='-30' changeset='#{changeset.id}'/>
1509               <node id='-12' lon='60'  lat='30' changeset='#{changeset.id}'/>
1510               <node id='-4' lon='-80' lat='-40' changeset='#{changeset.id}'/>
1511               <node id='-13' lon='80'  lat='40' changeset='#{changeset.id}'/>
1512               <node id='-5' lon='-100' lat='-50' changeset='#{changeset.id}'/>
1513               <node id='-14' lon='100'  lat='50' changeset='#{changeset.id}'/>
1514               <node id='-6' lon='-120' lat='-60' changeset='#{changeset.id}'/>
1515               <node id='-15' lon='120'  lat='60' changeset='#{changeset.id}'/>
1516               <node id='-7' lon='-140' lat='-70' changeset='#{changeset.id}'/>
1517               <node id='-16' lon='140'  lat='70' changeset='#{changeset.id}'/>
1518               <node id='-8' lon='-160' lat='-80' changeset='#{changeset.id}'/>
1519               <node id='-17' lon='160'  lat='80' changeset='#{changeset.id}'/>
1520               <node id='-9' lon='-179.9' lat='-89.9' changeset='#{changeset.id}'/>
1521               <node id='-18' lon='179.9'  lat='89.9' changeset='#{changeset.id}'/>
1522             </create>
1523           </osmChange>
1524         CHANGESET
1525
1526         auth_header = bearer_authorization_header user
1527
1528         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1529
1530         assert_response :success
1531
1532         # check that the changeset bbox is within bounds
1533         changeset.reload
1534         assert_operator changeset.min_lon, :>=, -180 * GeoRecord::SCALE, "Minimum longitude (#{changeset.min_lon / GeoRecord::SCALE}) should be >= -180 to be valid."
1535         assert_operator changeset.max_lon, :<=, 180 * GeoRecord::SCALE, "Maximum longitude (#{changeset.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
1536         assert_operator changeset.min_lat, :>=, -90 * GeoRecord::SCALE, "Minimum latitude (#{changeset.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
1537         assert_operator changeset.max_lat, :<=, 90 * GeoRecord::SCALE, "Maximum latitude (#{changeset.max_lat / GeoRecord::SCALE}) should be <= 90 to be valid."
1538       end
1539
1540       def test_upload_bbox_of_moved_node
1541         changeset = create(:changeset)
1542         node = create(:node, :lat => 1.0, :lon => 2.0)
1543
1544         diff = <<~CHANGESET
1545           <osmChange>
1546             <modify>
1547               <node id='#{node.id}' lat='1.1' lon='2.1' changeset='#{changeset.id}' version='1'/>
1548             </modify>
1549           </osmChange>
1550         CHANGESET
1551
1552         auth_header = bearer_authorization_header changeset.user
1553
1554         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1555
1556         assert_response :success
1557
1558         # check the bbox
1559         changeset.reload
1560         assert_equal 1.0 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.0 degrees"
1561         assert_equal 2.0 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.0 degrees"
1562         assert_equal 1.1 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.1 degrees"
1563         assert_equal 2.1 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.1 degrees"
1564       end
1565
1566       def test_upload_bbox_of_extended_way
1567         way = create(:way)
1568         initial_node = create(:node, :lat => 1.1, :lon => 2.1)
1569         create(:way_node, :way => way, :node => initial_node)
1570         added_node = create(:node, :lat => 1.3, :lon => 2.3)
1571         changeset = create(:changeset)
1572
1573         diff = <<~CHANGESET
1574           <osmChange>
1575             <modify>
1576               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
1577                 <nd ref='#{initial_node.id}'/>
1578                 <nd ref='#{added_node.id}'/>
1579               </way>
1580             </modify>
1581           </osmChange>
1582         CHANGESET
1583
1584         auth_header = bearer_authorization_header changeset.user
1585
1586         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1587
1588         assert_response :success
1589
1590         # check the bbox
1591         changeset.reload
1592         assert_equal 1.1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.1 degrees"
1593         assert_equal 2.1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.1 degrees"
1594         assert_equal 1.3 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.3 degrees"
1595         assert_equal 2.3 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.3 degrees"
1596       end
1597
1598       # -------------------------------------
1599       # Test upload rate/size limits.
1600       # -------------------------------------
1601
1602       def test_upload_initial_rate_limit
1603         user = create(:user)
1604         node = create(:node)
1605         way = create(:way_with_nodes, :nodes_count => 2)
1606         relation = create(:relation)
1607
1608         # create a changeset that puts us near the initial rate limit
1609         changeset = create(:changeset, :user => user,
1610                                        :created_at => Time.now.utc - 5.minutes,
1611                                        :num_changes => Settings.initial_changes_per_hour - 2)
1612
1613         diff = <<~CHANGESET
1614           <osmChange>
1615             <create>
1616               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1617                 <tag k='foo' v='bar'/>
1618                 <tag k='baz' v='bat'/>
1619               </node>
1620               <way id='-1' changeset='#{changeset.id}'>
1621                 <nd ref='#{node.id}'/>
1622               </way>
1623             </create>
1624             <create>
1625               <relation id='-1' changeset='#{changeset.id}'>
1626                 <member type='way' role='some' ref='#{way.id}'/>
1627                 <member type='node' role='some' ref='#{node.id}'/>
1628                 <member type='relation' role='some' ref='#{relation.id}'/>
1629               </relation>
1630             </create>
1631           </osmChange>
1632         CHANGESET
1633
1634         auth_header = bearer_authorization_header user
1635
1636         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1637
1638         assert_response :too_many_requests, "upload did not hit rate limit"
1639       end
1640
1641       def test_upload_maximum_rate_limit
1642         user = create(:user)
1643         node = create(:node)
1644         way = create(:way_with_nodes, :nodes_count => 2)
1645         relation = create(:relation)
1646
1647         # create a changeset to establish our initial edit time
1648         changeset = create(:changeset, :user => user,
1649                                        :created_at => Time.now.utc - 28.days)
1650
1651         # create changeset to put us near the maximum rate limit
1652         total_changes = Settings.max_changes_per_hour - 2
1653         while total_changes.positive?
1654           changes = [total_changes, Changeset::MAX_ELEMENTS].min
1655           changeset = create(:changeset, :user => user,
1656                                          :created_at => Time.now.utc - 5.minutes,
1657                                          :num_changes => changes)
1658           total_changes -= changes
1659         end
1660
1661         diff = <<~CHANGESET
1662           <osmChange>
1663             <create>
1664               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1665                 <tag k='foo' v='bar'/>
1666                 <tag k='baz' v='bat'/>
1667               </node>
1668               <way id='-1' changeset='#{changeset.id}'>
1669                 <nd ref='#{node.id}'/>
1670               </way>
1671             </create>
1672             <create>
1673               <relation id='-1' changeset='#{changeset.id}'>
1674                 <member type='way' role='some' ref='#{way.id}'/>
1675                 <member type='node' role='some' ref='#{node.id}'/>
1676                 <member type='relation' role='some' ref='#{relation.id}'/>
1677               </relation>
1678             </create>
1679           </osmChange>
1680         CHANGESET
1681
1682         auth_header = bearer_authorization_header user
1683
1684         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1685
1686         assert_response :too_many_requests, "upload did not hit rate limit"
1687       end
1688
1689       def test_upload_initial_size_limit
1690         user = create(:user)
1691
1692         # create a changeset that puts us near the initial size limit
1693         changeset = create(:changeset, :user => user,
1694                                        :min_lat => (-0.5 * GeoRecord::SCALE).round, :min_lon => (0.5 * GeoRecord::SCALE).round,
1695                                        :max_lat => (0.5 * GeoRecord::SCALE).round, :max_lon => (2.5 * GeoRecord::SCALE).round)
1696
1697         diff = <<~CHANGESET
1698           <osmChange>
1699             <create>
1700               <node id='-1' lon='0.9' lat='2.9' changeset='#{changeset.id}'>
1701                 <tag k='foo' v='bar'/>
1702                 <tag k='baz' v='bat'/>
1703               </node>
1704             </create>
1705           </osmChange>
1706         CHANGESET
1707
1708         auth_header = bearer_authorization_header user
1709
1710         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1711
1712         assert_response :payload_too_large, "upload did not hit size limit"
1713       end
1714
1715       def test_upload_size_limit_after_one_week
1716         user = create(:user)
1717
1718         # create a changeset to establish our initial edit time
1719         create(:changeset, :user => user, :created_at => Time.now.utc - 7.days)
1720
1721         # create a changeset that puts us near the initial size limit
1722         changeset = create(:changeset, :user => user, :bbox => [0.5, -0.5, 2.5, 0.5])
1723
1724         diff = <<~CHANGESET
1725           <osmChange>
1726             <create>
1727               <node id='-1' lon='35' lat='35' changeset='#{changeset.id}'>
1728                 <tag k='foo' v='bar'/>
1729                 <tag k='baz' v='bat'/>
1730               </node>
1731             </create>
1732           </osmChange>
1733         CHANGESET
1734
1735         auth_header = bearer_authorization_header user
1736
1737         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1738
1739         assert_response :payload_too_large, "upload did not hit size limit"
1740       end
1741
1742       private
1743
1744       def check_upload_results_in_not_found(&)
1745         changeset = create(:changeset)
1746         diff = "<osmChange>#{yield changeset}</osmChange>"
1747         auth_header = bearer_authorization_header changeset.user
1748
1749         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1750
1751         assert_response :not_found
1752         changeset.reload
1753         assert_equal 0, changeset.num_changes
1754       end
1755     end
1756   end
1757 end