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       # -------------------------------------
 719       # Test deleting elements.
 720       # -------------------------------------
 721
 722       ##
 723       # test a complex delete where we delete elements which rely on each other
 724       # in the same transaction.
 725       def test_upload_delete_elements
 726         changeset = create(:changeset)
 727         super_relation = create(:relation)
 728         used_relation = create(:relation)
 729         used_way = create(:way)
 730         used_node = create(:node)
 731         create(:relation_member, :relation => super_relation, :member => used_relation)
 732         create(:relation_member, :relation => super_relation, :member => used_way)
 733         create(:relation_member, :relation => super_relation, :member => used_node)
 734
 735         diff = XML::Document.new
 736         diff.root = XML::Node.new "osmChange"
 737         delete = XML::Node.new "delete"
 738         diff.root << delete
 739         delete << xml_node_for_relation(super_relation)
 740         delete << xml_node_for_relation(used_relation)
 741         delete << xml_node_for_way(used_way)
 742         delete << xml_node_for_node(used_node)
 743         %w[node way relation].each do |type|
 744           delete.find("//osmChange/delete/#{type}").each do |n|
 745             n["changeset"] = changeset.id.to_s
 746           end
 747         end
 748
 749         auth_header = bearer_authorization_header changeset.user
 750
 751         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 752
 753         assert_response :success
 754
 755         assert_dom "diffResult", 1 do
 756           assert_dom "> node", 1
 757           assert_dom "> way", 1
 758           assert_dom "> relation", 2
 759         end
 760
 761         assert_not Node.find(used_node.id).visible
 762         assert_not Way.find(used_way.id).visible
 763         assert_not Relation.find(super_relation.id).visible
 764         assert_not Relation.find(used_relation.id).visible
 765       end
 766
 767       ##
 768       # test uploading a delete with no lat/lon, as they are optional in the osmChange spec.
 769       def test_upload_delete_node_without_latlon
 770         node = create(:node)
 771         changeset = create(:changeset)
 772
 773         diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
 774
 775         auth_header = bearer_authorization_header changeset.user
 776
 777         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 778
 779         assert_response :success
 780
 781         assert_dom "diffResult", 1 do
 782           assert_dom "> node", 1 do
 783             assert_dom "> @old_id", node.id.to_s
 784             assert_dom "> @new_id", 0
 785             assert_dom "> @new_version", 0
 786           end
 787         end
 788
 789         node.reload
 790         assert_not node.visible
 791       end
 792
 793       ##
 794       # test that deleting stuff in a transaction doesn't bypass the checks
 795       # to ensure that used elements are not deleted.
 796       def test_upload_delete_referenced_elements
 797         changeset = create(:changeset)
 798         relation = create(:relation)
 799         other_relation = create(:relation)
 800         used_way = create(:way)
 801         used_node = create(:node)
 802         create(:relation_member, :relation => relation, :member => used_way)
 803         create(:relation_member, :relation => relation, :member => used_node)
 804
 805         diff = XML::Document.new
 806         diff.root = XML::Node.new "osmChange"
 807         delete = XML::Node.new "delete"
 808         diff.root << delete
 809         delete << xml_node_for_relation(other_relation)
 810         delete << xml_node_for_way(used_way)
 811         delete << xml_node_for_node(used_node)
 812         %w[node way relation].each do |type|
 813           delete.find("//osmChange/delete/#{type}").each do |n|
 814             n["changeset"] = changeset.id.to_s
 815           end
 816         end
 817
 818         auth_header = bearer_authorization_header changeset.user
 819
 820         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 821
 822         assert_response :precondition_failed
 823         assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
 824
 825         assert Node.find(used_node.id).visible
 826         assert Way.find(used_way.id).visible
 827         assert Relation.find(relation.id).visible
 828         assert Relation.find(other_relation.id).visible
 829       end
 830
 831       ##
 832       # test that a conditional delete of an in use object works.
 833       def test_upload_delete_if_unused
 834         changeset = create(:changeset)
 835         super_relation = create(:relation)
 836         used_relation = create(:relation)
 837         used_way = create(:way)
 838         used_node = create(:node)
 839         create(:relation_member, :relation => super_relation, :member => used_relation)
 840         create(:relation_member, :relation => super_relation, :member => used_way)
 841         create(:relation_member, :relation => super_relation, :member => used_node)
 842
 843         diff = XML::Document.new
 844         diff.root = XML::Node.new "osmChange"
 845         delete = XML::Node.new "delete"
 846         diff.root << delete
 847         delete["if-unused"] = ""
 848         delete << xml_node_for_relation(used_relation)
 849         delete << xml_node_for_way(used_way)
 850         delete << xml_node_for_node(used_node)
 851         %w[node way relation].each do |type|
 852           delete.find("//osmChange/delete/#{type}").each do |n|
 853             n["changeset"] = changeset.id.to_s
 854           end
 855         end
 856
 857         auth_header = bearer_authorization_header changeset.user
 858
 859         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 860
 861         assert_response :success
 862
 863         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 864           assert_dom "> node", 1 do
 865             assert_dom "> @old_id", used_node.id.to_s
 866             assert_dom "> @new_id", used_node.id.to_s
 867             assert_dom "> @new_version", used_node.version.to_s
 868           end
 869           assert_dom "> way", 1 do
 870             assert_dom "> @old_id", used_way.id.to_s
 871             assert_dom "> @new_id", used_way.id.to_s
 872             assert_dom "> @new_version", used_way.version.to_s
 873           end
 874           assert_dom "> relation", 1 do
 875             assert_dom "> @old_id", used_relation.id.to_s
 876             assert_dom "> @new_id", used_relation.id.to_s
 877             assert_dom "> @new_version", used_relation.version.to_s
 878           end
 879         end
 880
 881         assert Node.find(used_node.id).visible
 882         assert Way.find(used_way.id).visible
 883         assert Relation.find(used_relation.id).visible
 884       end
 885
 886       def test_upload_delete_with_multiple_blocks_and_if_unused
 887         changeset = create(:changeset)
 888         node = create(:node)
 889         way = create(:way)
 890         create(:way_node, :way => way, :node => node)
 891         alone_node = create(:node)
 892
 893         diff = <<~CHANGESET
 894           <osmChange version='0.6'>
 895             <delete version="0.6">
 896               <node id="#{node.id}" version="#{node.version}" changeset="#{changeset.id}"/>
 897             </delete>
 898             <delete version="0.6" if-unused="true">
 899               <node id="#{alone_node.id}" version="#{alone_node.version}" changeset="#{changeset.id}"/>
 900             </delete>
 901           </osmChange>
 902         CHANGESET
 903
 904         auth_header = bearer_authorization_header changeset.user
 905
 906         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 907
 908         assert_response :precondition_failed
 909
 910         assert_equal "Precondition failed: Node #{node.id} is still used by ways #{way.id}.", @response.body
 911       end
 912
 913       # -------------------------------------
 914       # Test combined element changes.
 915       # -------------------------------------
 916
 917       ##
 918       # upload something which creates new objects and inserts them into
 919       # existing containers using placeholders.
 920       def test_upload_create_and_insert_elements
 921         way = create(:way)
 922         node = create(:node)
 923         relation = create(:relation)
 924         create(:way_node, :way => way, :node => node)
 925         changeset = create(:changeset)
 926
 927         diff = <<~CHANGESET
 928           <osmChange>
 929             <create>
 930               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 931                 <tag k='foo' v='bar'/>
 932                 <tag k='baz' v='bat'/>
 933               </node>
 934             </create>
 935             <modify>
 936               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 937                 <nd ref='-1'/>
 938                 <nd ref='#{node.id}'/>
 939               </way>
 940               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 941                 <member type='way' role='some' ref='#{way.id}'/>
 942                 <member type='node' role='some' ref='-1'/>
 943                 <member type='relation' role='some' ref='#{relation.id}'/>
 944               </relation>
 945             </modify>
 946           </osmChange>
 947         CHANGESET
 948
 949         auth_header = bearer_authorization_header changeset.user
 950
 951         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 952
 953         assert_response :success
 954
 955         new_node_id = nil
 956         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 957           assert_dom "> node", 1 do |(node_el)|
 958             new_node_id = node_el["new_id"].to_i
 959           end
 960           assert_dom "> way", 1
 961           assert_dom "> relation", 1
 962         end
 963
 964         assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
 965         assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
 966         Relation.find(relation.id).members.each do |type, id, _role|
 967           assert_equal new_node_id, id, "relation should contain new node" if type == "node"
 968         end
 969       end
 970
 971       ##
 972       # test that a placeholder can be reused within the same upload.
 973       def test_upload_create_modify_delete_node_reusing_placeholder
 974         changeset = create(:changeset)
 975
 976         diff = <<~CHANGESET
 977           <osmChange>
 978             <create>
 979               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
 980                 <tag k="foo" v="bar"/>
 981               </node>
 982             </create>
 983             <modify>
 984               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 985             </modify>
 986             <delete>
 987               <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
 988             </delete>
 989           </osmChange>
 990         CHANGESET
 991
 992         auth_header = bearer_authorization_header changeset.user
 993
 994         assert_difference "Node.count", 1 do
 995           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 996
 997           assert_response :success
 998         end
 999
1000         assert_dom "diffResult>node", 3
1001         assert_dom "diffResult>node[old_id='-1']", 3
1002
1003         node = Node.last
1004         assert_equal 3, node.version
1005         assert_not node.visible
1006       end
1007
1008       def test_upload_create_and_duplicate_delete
1009         changeset = create(:changeset)
1010
1011         diff = <<~CHANGESET
1012           <osmChange>
1013             <create>
1014               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1015             </create>
1016             <delete>
1017               <node id="-1" version="1" changeset="#{changeset.id}" />
1018               <node id="-1" version="1" changeset="#{changeset.id}" />
1019             </delete>
1020           </osmChange>
1021         CHANGESET
1022
1023         auth_header = bearer_authorization_header changeset.user
1024
1025         assert_no_difference "Node.count" do
1026           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1027
1028           assert_response :gone
1029         end
1030       end
1031
1032       def test_upload_create_and_duplicate_delete_if_unused
1033         changeset = create(:changeset)
1034
1035         diff = <<~CHANGESET
1036           <osmChange>
1037             <create>
1038               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1039             </create>
1040             <delete if-unused="true">
1041               <node id="-1" version="1" changeset="#{changeset.id}" />
1042               <node id="-1" version="1" changeset="#{changeset.id}" />
1043             </delete>
1044           </osmChange>
1045         CHANGESET
1046
1047         auth_header = bearer_authorization_header changeset.user
1048
1049         assert_difference "Node.count", 1 do
1050           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1051
1052           assert_response :success
1053         end
1054
1055         assert_dom "diffResult>node", 3
1056         assert_dom "diffResult>node[old_id='-1']", 3
1057         assert_dom "diffResult>node[new_version='1']", 1
1058         assert_dom "diffResult>node[new_version='2']", 1
1059
1060         node = Node.last
1061         assert_equal 2, node.version
1062         assert_not node.visible
1063       end
1064     end
1065   end
1066 end