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       ##
1021       # test a complex delete where we delete elements which rely on each other
1022       # in the same transaction.
1023       def test_upload_delete_elements
1024         changeset = create(:changeset)
1025         super_relation = create(:relation)
1026         used_relation = create(:relation)
1027         used_way = create(:way)
1028         used_node = create(:node)
1029         create(:relation_member, :relation => super_relation, :member => used_relation)
1030         create(:relation_member, :relation => super_relation, :member => used_way)
1031         create(:relation_member, :relation => super_relation, :member => used_node)
1032
1033         diff = XML::Document.new
1034         diff.root = XML::Node.new "osmChange"
1035         delete = XML::Node.new "delete"
1036         diff.root << delete
1037         delete << xml_node_for_relation(super_relation)
1038         delete << xml_node_for_relation(used_relation)
1039         delete << xml_node_for_way(used_way)
1040         delete << xml_node_for_node(used_node)
1041         %w[node way relation].each do |type|
1042           delete.find("//osmChange/delete/#{type}").each do |n|
1043             n["changeset"] = changeset.id.to_s
1044           end
1045         end
1046
1047         auth_header = bearer_authorization_header changeset.user
1048
1049         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1050
1051         assert_response :success
1052
1053         assert_dom "diffResult", 1 do
1054           assert_dom "> node", 1
1055           assert_dom "> way", 1
1056           assert_dom "> relation", 2
1057         end
1058
1059         assert_not Node.find(used_node.id).visible
1060         assert_not Way.find(used_way.id).visible
1061         assert_not Relation.find(super_relation.id).visible
1062         assert_not Relation.find(used_relation.id).visible
1063       end
1064
1065       ##
1066       # test uploading a delete with no lat/lon, as they are optional in the osmChange spec.
1067       def test_upload_delete_node_without_latlon
1068         node = create(:node)
1069         changeset = create(:changeset)
1070
1071         diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
1072
1073         auth_header = bearer_authorization_header changeset.user
1074
1075         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1076
1077         assert_response :success
1078
1079         assert_dom "diffResult", 1 do
1080           assert_dom "> node", 1 do
1081             assert_dom "> @old_id", node.id.to_s
1082             assert_dom "> @new_id", 0
1083             assert_dom "> @new_version", 0
1084           end
1085         end
1086
1087         node.reload
1088         assert_not node.visible
1089       end
1090
1091       ##
1092       # test that deleting stuff in a transaction doesn't bypass the checks
1093       # to ensure that used elements are not deleted.
1094       def test_upload_delete_referenced_elements
1095         changeset = create(:changeset)
1096         relation = create(:relation)
1097         other_relation = create(:relation)
1098         used_way = create(:way)
1099         used_node = create(:node)
1100         create(:relation_member, :relation => relation, :member => used_way)
1101         create(:relation_member, :relation => relation, :member => used_node)
1102
1103         diff = XML::Document.new
1104         diff.root = XML::Node.new "osmChange"
1105         delete = XML::Node.new "delete"
1106         diff.root << delete
1107         delete << xml_node_for_relation(other_relation)
1108         delete << xml_node_for_way(used_way)
1109         delete << xml_node_for_node(used_node)
1110         %w[node way relation].each do |type|
1111           delete.find("//osmChange/delete/#{type}").each do |n|
1112             n["changeset"] = changeset.id.to_s
1113           end
1114         end
1115
1116         auth_header = bearer_authorization_header changeset.user
1117
1118         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1119
1120         assert_response :precondition_failed
1121         assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
1122
1123         assert Node.find(used_node.id).visible
1124         assert Way.find(used_way.id).visible
1125         assert Relation.find(relation.id).visible
1126         assert Relation.find(other_relation.id).visible
1127       end
1128
1129       ##
1130       # test that a conditional delete of an in use object works.
1131       def test_upload_delete_if_unused
1132         changeset = create(:changeset)
1133         super_relation = create(:relation)
1134         used_relation = create(:relation)
1135         used_way = create(:way)
1136         used_node = create(:node)
1137         create(:relation_member, :relation => super_relation, :member => used_relation)
1138         create(:relation_member, :relation => super_relation, :member => used_way)
1139         create(:relation_member, :relation => super_relation, :member => used_node)
1140
1141         diff = XML::Document.new
1142         diff.root = XML::Node.new "osmChange"
1143         delete = XML::Node.new "delete"
1144         diff.root << delete
1145         delete["if-unused"] = ""
1146         delete << xml_node_for_relation(used_relation)
1147         delete << xml_node_for_way(used_way)
1148         delete << xml_node_for_node(used_node)
1149         %w[node way relation].each do |type|
1150           delete.find("//osmChange/delete/#{type}").each do |n|
1151             n["changeset"] = changeset.id.to_s
1152           end
1153         end
1154
1155         auth_header = bearer_authorization_header changeset.user
1156
1157         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1158
1159         assert_response :success
1160
1161         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
1162           assert_dom "> node", 1 do
1163             assert_dom "> @old_id", used_node.id.to_s
1164             assert_dom "> @new_id", used_node.id.to_s
1165             assert_dom "> @new_version", used_node.version.to_s
1166           end
1167           assert_dom "> way", 1 do
1168             assert_dom "> @old_id", used_way.id.to_s
1169             assert_dom "> @new_id", used_way.id.to_s
1170             assert_dom "> @new_version", used_way.version.to_s
1171           end
1172           assert_dom "> relation", 1 do
1173             assert_dom "> @old_id", used_relation.id.to_s
1174             assert_dom "> @new_id", used_relation.id.to_s
1175             assert_dom "> @new_version", used_relation.version.to_s
1176           end
1177         end
1178
1179         assert Node.find(used_node.id).visible
1180         assert Way.find(used_way.id).visible
1181         assert Relation.find(used_relation.id).visible
1182       end
1183
1184       def test_upload_delete_with_multiple_blocks_and_if_unused
1185         changeset = create(:changeset)
1186         node = create(:node)
1187         way = create(:way)
1188         create(:way_node, :way => way, :node => node)
1189         alone_node = create(:node)
1190
1191         diff = <<~CHANGESET
1192           <osmChange version='0.6'>
1193             <delete version="0.6">
1194               <node id="#{node.id}" version="#{node.version}" changeset="#{changeset.id}"/>
1195             </delete>
1196             <delete version="0.6" if-unused="true">
1197               <node id="#{alone_node.id}" version="#{alone_node.version}" changeset="#{changeset.id}"/>
1198             </delete>
1199           </osmChange>
1200         CHANGESET
1201
1202         auth_header = bearer_authorization_header changeset.user
1203
1204         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1205
1206         assert_response :precondition_failed
1207
1208         assert_equal "Precondition failed: Node #{node.id} is still used by ways #{way.id}.", @response.body
1209       end
1210
1211       def test_upload_delete_unknown_node_placeholder
1212         check_upload_results_in_not_found do |changeset|
1213           "<delete><node id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1214         end
1215       end
1216
1217       def test_upload_delete_unknown_way_placeholder
1218         check_upload_results_in_not_found do |changeset|
1219           "<delete><way id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1220         end
1221       end
1222
1223       def test_upload_delete_unknown_relation_placeholder
1224         check_upload_results_in_not_found do |changeset|
1225           "<delete><relation id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1226         end
1227       end
1228
1229       # -------------------------------------
1230       # Test combined element changes.
1231       # -------------------------------------
1232
1233       ##
1234       # upload something which creates new objects and inserts them into
1235       # existing containers using placeholders.
1236       def test_upload_create_and_insert_elements
1237         way = create(:way)
1238         node = create(:node)
1239         relation = create(:relation)
1240         create(:way_node, :way => way, :node => node)
1241         changeset = create(:changeset)
1242
1243         diff = <<~CHANGESET
1244           <osmChange>
1245             <create>
1246               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1247                 <tag k='foo' v='bar'/>
1248                 <tag k='baz' v='bat'/>
1249               </node>
1250             </create>
1251             <modify>
1252               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
1253                 <nd ref='-1'/>
1254                 <nd ref='#{node.id}'/>
1255               </way>
1256               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
1257                 <member type='way' role='some' ref='#{way.id}'/>
1258                 <member type='node' role='some' ref='-1'/>
1259                 <member type='relation' role='some' ref='#{relation.id}'/>
1260               </relation>
1261             </modify>
1262           </osmChange>
1263         CHANGESET
1264
1265         auth_header = bearer_authorization_header changeset.user
1266
1267         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1268
1269         assert_response :success
1270
1271         new_node_id = nil
1272         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
1273           assert_dom "> node", 1 do |(node_el)|
1274             new_node_id = node_el["new_id"].to_i
1275           end
1276           assert_dom "> way", 1
1277           assert_dom "> relation", 1
1278         end
1279
1280         assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
1281         assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
1282         Relation.find(relation.id).members.each do |type, id, _role|
1283           assert_equal new_node_id, id, "relation should contain new node" if type == "node"
1284         end
1285       end
1286
1287       ##
1288       # test that a placeholder can be reused within the same upload.
1289       def test_upload_create_modify_delete_node_reusing_placeholder
1290         changeset = create(:changeset)
1291
1292         diff = <<~CHANGESET
1293           <osmChange>
1294             <create>
1295               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1296                 <tag k="foo" v="bar"/>
1297               </node>
1298             </create>
1299             <modify>
1300               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
1301             </modify>
1302             <delete>
1303               <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
1304             </delete>
1305           </osmChange>
1306         CHANGESET
1307
1308         auth_header = bearer_authorization_header changeset.user
1309
1310         assert_difference "Node.count", 1 do
1311           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1312
1313           assert_response :success
1314         end
1315
1316         assert_dom "diffResult>node", 3
1317         assert_dom "diffResult>node[old_id='-1']", 3
1318
1319         node = Node.last
1320         assert_equal 3, node.version
1321         assert_not node.visible
1322       end
1323
1324       def test_upload_create_and_duplicate_delete
1325         changeset = create(:changeset)
1326
1327         diff = <<~CHANGESET
1328           <osmChange>
1329             <create>
1330               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1331             </create>
1332             <delete>
1333               <node id="-1" version="1" changeset="#{changeset.id}" />
1334               <node id="-1" version="1" changeset="#{changeset.id}" />
1335             </delete>
1336           </osmChange>
1337         CHANGESET
1338
1339         auth_header = bearer_authorization_header changeset.user
1340
1341         assert_no_difference "Node.count" do
1342           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1343
1344           assert_response :gone
1345         end
1346       end
1347
1348       def test_upload_create_and_duplicate_delete_if_unused
1349         changeset = create(:changeset)
1350
1351         diff = <<~CHANGESET
1352           <osmChange>
1353             <create>
1354               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1355             </create>
1356             <delete if-unused="true">
1357               <node id="-1" version="1" changeset="#{changeset.id}" />
1358               <node id="-1" version="1" changeset="#{changeset.id}" />
1359             </delete>
1360           </osmChange>
1361         CHANGESET
1362
1363         auth_header = bearer_authorization_header changeset.user
1364
1365         assert_difference "Node.count", 1 do
1366           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1367
1368           assert_response :success
1369         end
1370
1371         assert_dom "diffResult>node", 3
1372         assert_dom "diffResult>node[old_id='-1']", 3
1373         assert_dom "diffResult>node[new_version='1']", 1
1374         assert_dom "diffResult>node[new_version='2']", 1
1375
1376         node = Node.last
1377         assert_equal 2, node.version
1378         assert_not node.visible
1379       end
1380
1381       # -------------------------------------
1382       # Test bounding boxes.
1383       # -------------------------------------
1384
1385       def test_upload_bbox_of_widely_spaced_nodes
1386         user = create(:user)
1387
1388         # create an old changeset to ensure we have the maximum rate limit
1389         create(:changeset, :user => user, :created_at => Time.now.utc - 28.days)
1390
1391         changeset = create(:changeset, :user => user)
1392
1393         # upload some widely-spaced nodes, spiralling positive and negative
1394         diff = <<~CHANGESET
1395           <osmChange>
1396             <create>
1397               <node id='-1' lon='-20' lat='-10' changeset='#{changeset.id}'/>
1398               <node id='-10' lon='20'  lat='10' changeset='#{changeset.id}'/>
1399               <node id='-2' lon='-40' lat='-20' changeset='#{changeset.id}'/>
1400               <node id='-11' lon='40'  lat='20' changeset='#{changeset.id}'/>
1401               <node id='-3' lon='-60' lat='-30' changeset='#{changeset.id}'/>
1402               <node id='-12' lon='60'  lat='30' changeset='#{changeset.id}'/>
1403               <node id='-4' lon='-80' lat='-40' changeset='#{changeset.id}'/>
1404               <node id='-13' lon='80'  lat='40' changeset='#{changeset.id}'/>
1405               <node id='-5' lon='-100' lat='-50' changeset='#{changeset.id}'/>
1406               <node id='-14' lon='100'  lat='50' changeset='#{changeset.id}'/>
1407               <node id='-6' lon='-120' lat='-60' changeset='#{changeset.id}'/>
1408               <node id='-15' lon='120'  lat='60' changeset='#{changeset.id}'/>
1409               <node id='-7' lon='-140' lat='-70' changeset='#{changeset.id}'/>
1410               <node id='-16' lon='140'  lat='70' changeset='#{changeset.id}'/>
1411               <node id='-8' lon='-160' lat='-80' changeset='#{changeset.id}'/>
1412               <node id='-17' lon='160'  lat='80' changeset='#{changeset.id}'/>
1413               <node id='-9' lon='-179.9' lat='-89.9' changeset='#{changeset.id}'/>
1414               <node id='-18' lon='179.9'  lat='89.9' changeset='#{changeset.id}'/>
1415             </create>
1416           </osmChange>
1417         CHANGESET
1418
1419         auth_header = bearer_authorization_header user
1420
1421         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1422
1423         assert_response :success
1424
1425         # check that the changeset bbox is within bounds
1426         changeset.reload
1427         assert_operator changeset.min_lon, :>=, -180 * GeoRecord::SCALE, "Minimum longitude (#{changeset.min_lon / GeoRecord::SCALE}) should be >= -180 to be valid."
1428         assert_operator changeset.max_lon, :<=, 180 * GeoRecord::SCALE, "Maximum longitude (#{changeset.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
1429         assert_operator changeset.min_lat, :>=, -90 * GeoRecord::SCALE, "Minimum latitude (#{changeset.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
1430         assert_operator changeset.max_lat, :<=, 90 * GeoRecord::SCALE, "Maximum latitude (#{changeset.max_lat / GeoRecord::SCALE}) should be <= 90 to be valid."
1431       end
1432
1433       def test_upload_bbox_of_moved_node
1434         changeset = create(:changeset)
1435         node = create(:node, :lat => 1.0, :lon => 2.0)
1436
1437         diff = <<~CHANGESET
1438           <osmChange>
1439             <modify>
1440               <node id='#{node.id}' lat='1.1' lon='2.1' changeset='#{changeset.id}' version='1'/>
1441             </modify>
1442           </osmChange>
1443         CHANGESET
1444
1445         auth_header = bearer_authorization_header changeset.user
1446
1447         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1448
1449         assert_response :success
1450
1451         # check the bbox
1452         changeset.reload
1453         assert_equal 1.0 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.0 degrees"
1454         assert_equal 2.0 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.0 degrees"
1455         assert_equal 1.1 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.1 degrees"
1456         assert_equal 2.1 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.1 degrees"
1457       end
1458
1459       def test_upload_bbox_of_extended_way
1460         way = create(:way)
1461         initial_node = create(:node, :lat => 1.1, :lon => 2.1)
1462         create(:way_node, :way => way, :node => initial_node)
1463         added_node = create(:node, :lat => 1.3, :lon => 2.3)
1464         changeset = create(:changeset)
1465
1466         diff = <<~CHANGESET
1467           <osmChange>
1468             <modify>
1469               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
1470                 <nd ref='#{initial_node.id}'/>
1471                 <nd ref='#{added_node.id}'/>
1472               </way>
1473             </modify>
1474           </osmChange>
1475         CHANGESET
1476
1477         auth_header = bearer_authorization_header changeset.user
1478
1479         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1480
1481         assert_response :success
1482
1483         # check the bbox
1484         changeset.reload
1485         assert_equal 1.1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.1 degrees"
1486         assert_equal 2.1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.1 degrees"
1487         assert_equal 1.3 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.3 degrees"
1488         assert_equal 2.3 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.3 degrees"
1489       end
1490
1491       # -------------------------------------
1492       # Test upload rate/size limits.
1493       # -------------------------------------
1494
1495       def test_upload_initial_rate_limit
1496         user = create(:user)
1497         node = create(:node)
1498         way = create(:way_with_nodes, :nodes_count => 2)
1499         relation = create(:relation)
1500
1501         # create a changeset that puts us near the initial rate limit
1502         changeset = create(:changeset, :user => user,
1503                                        :created_at => Time.now.utc - 5.minutes,
1504                                        :num_changes => Settings.initial_changes_per_hour - 2)
1505
1506         diff = <<~CHANGESET
1507           <osmChange>
1508             <create>
1509               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1510                 <tag k='foo' v='bar'/>
1511                 <tag k='baz' v='bat'/>
1512               </node>
1513               <way id='-1' changeset='#{changeset.id}'>
1514                 <nd ref='#{node.id}'/>
1515               </way>
1516             </create>
1517             <create>
1518               <relation id='-1' changeset='#{changeset.id}'>
1519                 <member type='way' role='some' ref='#{way.id}'/>
1520                 <member type='node' role='some' ref='#{node.id}'/>
1521                 <member type='relation' role='some' ref='#{relation.id}'/>
1522               </relation>
1523             </create>
1524           </osmChange>
1525         CHANGESET
1526
1527         auth_header = bearer_authorization_header user
1528
1529         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1530
1531         assert_response :too_many_requests, "upload did not hit rate limit"
1532       end
1533
1534       def test_upload_maximum_rate_limit
1535         user = create(:user)
1536         node = create(:node)
1537         way = create(:way_with_nodes, :nodes_count => 2)
1538         relation = create(:relation)
1539
1540         # create a changeset to establish our initial edit time
1541         changeset = create(:changeset, :user => user,
1542                                        :created_at => Time.now.utc - 28.days)
1543
1544         # create changeset to put us near the maximum rate limit
1545         total_changes = Settings.max_changes_per_hour - 2
1546         while total_changes.positive?
1547           changes = [total_changes, Changeset::MAX_ELEMENTS].min
1548           changeset = create(:changeset, :user => user,
1549                                          :created_at => Time.now.utc - 5.minutes,
1550                                          :num_changes => changes)
1551           total_changes -= changes
1552         end
1553
1554         diff = <<~CHANGESET
1555           <osmChange>
1556             <create>
1557               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1558                 <tag k='foo' v='bar'/>
1559                 <tag k='baz' v='bat'/>
1560               </node>
1561               <way id='-1' changeset='#{changeset.id}'>
1562                 <nd ref='#{node.id}'/>
1563               </way>
1564             </create>
1565             <create>
1566               <relation id='-1' changeset='#{changeset.id}'>
1567                 <member type='way' role='some' ref='#{way.id}'/>
1568                 <member type='node' role='some' ref='#{node.id}'/>
1569                 <member type='relation' role='some' ref='#{relation.id}'/>
1570               </relation>
1571             </create>
1572           </osmChange>
1573         CHANGESET
1574
1575         auth_header = bearer_authorization_header user
1576
1577         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1578
1579         assert_response :too_many_requests, "upload did not hit rate limit"
1580       end
1581
1582       def test_upload_initial_size_limit
1583         user = create(:user)
1584
1585         # create a changeset that puts us near the initial size limit
1586         changeset = create(:changeset, :user => user,
1587                                        :min_lat => (-0.5 * GeoRecord::SCALE).round, :min_lon => (0.5 * GeoRecord::SCALE).round,
1588                                        :max_lat => (0.5 * GeoRecord::SCALE).round, :max_lon => (2.5 * GeoRecord::SCALE).round)
1589
1590         diff = <<~CHANGESET
1591           <osmChange>
1592             <create>
1593               <node id='-1' lon='0.9' lat='2.9' changeset='#{changeset.id}'>
1594                 <tag k='foo' v='bar'/>
1595                 <tag k='baz' v='bat'/>
1596               </node>
1597             </create>
1598           </osmChange>
1599         CHANGESET
1600
1601         auth_header = bearer_authorization_header user
1602
1603         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1604
1605         assert_response :payload_too_large, "upload did not hit size limit"
1606       end
1607
1608       def test_upload_size_limit_after_one_week
1609         user = create(:user)
1610
1611         # create a changeset to establish our initial edit time
1612         create(:changeset, :user => user, :created_at => Time.now.utc - 7.days)
1613
1614         # create a changeset that puts us near the initial size limit
1615         changeset = create(:changeset, :user => user, :bbox => [0.5, -0.5, 2.5, 0.5])
1616
1617         diff = <<~CHANGESET
1618           <osmChange>
1619             <create>
1620               <node id='-1' lon='35' lat='35' changeset='#{changeset.id}'>
1621                 <tag k='foo' v='bar'/>
1622                 <tag k='baz' v='bat'/>
1623               </node>
1624             </create>
1625           </osmChange>
1626         CHANGESET
1627
1628         auth_header = bearer_authorization_header user
1629
1630         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1631
1632         assert_response :payload_too_large, "upload did not hit size limit"
1633       end
1634
1635       private
1636
1637       def check_upload_results_in_not_found(&)
1638         changeset = create(:changeset)
1639         diff = "<osmChange>#{yield changeset}</osmChange>"
1640         auth_header = bearer_authorization_header changeset.user
1641
1642         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1643
1644         assert_response :not_found
1645         changeset.reload
1646         assert_equal 0, changeset.num_changes
1647       end
1648     end
1649   end
1650 end