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_elements
 627         user = create(:user)
 628         changeset = create(:changeset, :user => user)
 629         node = create(:node, :latitude => 0, :longitude => 0)
 630         way = create(:way)
 631         relation = create(:relation)
 632         other_relation = create(:relation)
 633
 634         # create some tags, since we test that they are removed later
 635         create(:node_tag, :node => node)
 636         create(:way_tag, :way => way)
 637         create(:relation_tag, :relation => relation)
 638
 639         # simple diff to change a node, way and relation by removing their tags
 640         diff = <<~CHANGESET
 641           <osmChange>
 642             <modify>
 643               <node id='#{node.id}' lon='1' lat='2' changeset='#{changeset.id}' version='1'/>
 644               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
 645                 <nd ref='#{node.id}'/>
 646               </way>
 647             </modify>
 648             <modify>
 649               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
 650                 <member type='way' role='some' ref='#{way.id}'/>
 651                 <member type='node' role='some' ref='#{node.id}'/>
 652                 <member type='relation' role='some' ref='#{other_relation.id}'/>
 653               </relation>
 654             </modify>
 655           </osmChange>
 656         CHANGESET
 657
 658         auth_header = bearer_authorization_header user
 659
 660         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 661
 662         assert_response :success
 663
 664         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
 665           assert_dom "> node", 1 do
 666             assert_dom "> @old_id", node.id.to_s
 667             assert_dom "> @new_id", node.id.to_s
 668             assert_dom "> @new_version", "2"
 669           end
 670           assert_dom "> way", 1 do
 671             assert_dom "> @old_id", way.id.to_s
 672             assert_dom "> @new_id", way.id.to_s
 673             assert_dom "> @new_version", "2"
 674           end
 675           assert_dom "> relation", 1 do
 676             assert_dom "> @old_id", relation.id.to_s
 677             assert_dom "> @new_id", relation.id.to_s
 678             assert_dom "> @new_version", "2"
 679           end
 680         end
 681
 682         changeset.reload
 683         assert_equal 3, changeset.num_changes
 684         node.reload
 685         assert_equal 2, node.version
 686         assert_equal 2 * GeoRecord::SCALE, node.latitude
 687         assert_equal 1 * GeoRecord::SCALE, node.longitude
 688         assert_equal 0, node.tags.size, "node #{node.id} should now have no tags"
 689         way.reload
 690         assert_equal 2, way.version
 691         assert_equal 0, way.tags.size, "way #{way.id} should now have no tags"
 692         assert_equal [node], way.nodes
 693         relation.reload
 694         assert_equal 2, relation.version
 695         assert_equal 0, relation.tags.size, "relation #{relation.id} should now have no tags"
 696         assert_equal [["Way", way.id, "some"], ["Node", node.id, "some"], ["Relation", other_relation.id, "some"]], relation.members
 697       end
 698
 699       ##
 700       # upload multiple versions of the same element in the same diff.
 701       def test_upload_modify_multiple_node_versions
 702         node = create(:node)
 703         changeset = create(:changeset)
 704
 705         # change the location of a node multiple times, each time referencing
 706         # the last version. doesn't this depend on version numbers being
 707         # sequential?
 708         diff = <<~CHANGESET
 709           <osmChange>
 710             <modify>
 711               <node id='#{node.id}' lon='0.0' lat='0.0' changeset='#{changeset.id}' version='1'/>
 712               <node id='#{node.id}' lon='0.1' lat='0.0' changeset='#{changeset.id}' version='2'/>
 713               <node id='#{node.id}' lon='0.1' lat='0.1' changeset='#{changeset.id}' version='3'/>
 714               <node id='#{node.id}' lon='0.1' lat='0.2' changeset='#{changeset.id}' version='4'/>
 715               <node id='#{node.id}' lon='0.2' lat='0.2' changeset='#{changeset.id}' version='5'/>
 716               <node id='#{node.id}' lon='0.3' lat='0.2' changeset='#{changeset.id}' version='6'/>
 717               <node id='#{node.id}' lon='0.3' lat='0.3' changeset='#{changeset.id}' version='7'/>
 718               <node id='#{node.id}' lon='0.9' lat='0.9' changeset='#{changeset.id}' version='8'/>
 719             </modify>
 720           </osmChange>
 721         CHANGESET
 722
 723         auth_header = bearer_authorization_header changeset.user
 724
 725         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 726
 727         assert_response :success
 728
 729         assert_dom "diffResult>node", 8
 730
 731         node.reload
 732         assert_equal 9, node.version
 733         assert_equal 0.9 * GeoRecord::SCALE, node.latitude
 734         assert_equal 0.9 * GeoRecord::SCALE, node.longitude
 735       end
 736
 737       ##
 738       # upload multiple versions of the same element in the same diff, but
 739       # keep the version numbers the same.
 740       def test_upload_modify_duplicate_node_versions
 741         node = create(:node, :latitude => 0, :longitude => 0)
 742         changeset = create(:changeset)
 743
 744         diff = <<~CHANGESET
 745           <osmChange>
 746             <modify>
 747               <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
 748               <node id='#{node.id}' lon='2' lat='2' changeset='#{changeset.id}' version='1'/>
 749             </modify>
 750           </osmChange>
 751         CHANGESET
 752
 753         auth_header = bearer_authorization_header changeset.user
 754
 755         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 756
 757         assert_response :conflict
 758
 759         node.reload
 760         assert_equal 1, node.version
 761         assert_equal 0, node.latitude
 762         assert_equal 0, node.longitude
 763       end
 764
 765       ##
 766       # try to upload some elements without specifying the version
 767       def test_upload_modify_missing_node_version
 768         node = create(:node, :latitude => 0, :longitude => 0)
 769         changeset = create(:changeset)
 770
 771         diff = <<~CHANGESET
 772           <osmChange>
 773             <modify>
 774               <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}'/>
 775             </modify>
 776           </osmChange>
 777         CHANGESET
 778
 779         auth_header = bearer_authorization_header changeset.user
 780
 781         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 782
 783         assert_response :bad_request
 784
 785         node.reload
 786         assert_equal 1, node.version
 787         assert_equal 0, node.latitude
 788         assert_equal 0, node.longitude
 789       end
 790
 791       ##
 792       # create a diff which references several changesets, which should cause
 793       # a rollback and none of the diff gets committed
 794       def test_upload_modify_with_references_to_different_changesets
 795         changeset1 = create(:changeset)
 796         changeset2 = create(:changeset, :user => changeset1.user)
 797         node1 = create(:node)
 798         node2 = create(:node)
 799
 800         # simple diff to create a node way and relation using placeholders
 801         diff = <<~CHANGESET
 802           <osmChange>
 803             <modify>
 804               <node id='#{node1.id}' lon='0' lat='0' changeset='#{changeset1.id}' version='1'/>
 805             </modify>
 806             <modify>
 807               <node id='#{node2.id}' lon='0' lat='0' changeset='#{changeset2.id}' version='1'/>
 808             </modify>
 809           </osmChange>
 810         CHANGESET
 811
 812         auth_header = bearer_authorization_header changeset1.user
 813
 814         post api_changeset_upload_path(changeset1), :params => diff, :headers => auth_header
 815
 816         assert_response :conflict
 817
 818         assert_nodes_are_equal(node1, Node.find(node1.id))
 819         assert_nodes_are_equal(node2, Node.find(node2.id))
 820       end
 821
 822       ##
 823       # upload a valid changeset which has a mixture of whitespace
 824       # to check a bug https://github.com/openstreetmap/trac-tickets/issues/1565
 825       def test_upload_modify_with_mixed_whitespace
 826         changeset = create(:changeset)
 827         node = create(:node)
 828         way = create(:way_with_nodes, :nodes_count => 2)
 829         relation = create(:relation)
 830         other_relation = create(:relation)
 831         create(:relation_tag, :relation => relation)
 832
 833         diff = <<~CHANGESET
 834           <osmChange>
 835           <modify><node id='#{node.id}' lon='0' lat='0' changeset='#{changeset.id}'
 836             version='1'></node>
 837             <node id='#{node.id}' lon='1' lat='1' changeset='#{changeset.id}' version='2'><tag k='k' v='v'/></node></modify>
 838           <modify>
 839           <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'><member
 840             type='way' role='some' ref='#{way.id}'/><member
 841               type='node' role='some' ref='#{node.id}'/>
 842             <member type='relation' role='some' ref='#{other_relation.id}'/>
 843             </relation>
 844           </modify></osmChange>
 845         CHANGESET
 846
 847         auth_header = bearer_authorization_header changeset.user
 848
 849         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 850
 851         assert_response :success
 852
 853         assert_dom "diffResult>node", 2
 854         assert_dom "diffResult>relation", 1
 855
 856         assert_equal 1, Node.find(node.id).tags.size, "node #{node.id} should now have one tag"
 857         assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
 858       end
 859
 860       def test_upload_modify_unknown_node_placeholder
 861         check_upload_results_in_not_found do |changeset|
 862           "<modify><node id='-1' lon='0' lat='0' changeset='#{changeset.id}' version='1'/></modify>"
 863         end
 864       end
 865
 866       def test_upload_modify_unknown_way_placeholder
 867         check_upload_results_in_not_found do |changeset|
 868           "<modify><way id='-1' changeset='#{changeset.id}' version='1'/></modify>"
 869         end
 870       end
 871
 872       def test_upload_modify_unknown_relation_placeholder
 873         check_upload_results_in_not_found do |changeset|
 874           "<modify><relation id='-1' changeset='#{changeset.id}' version='1'/></modify>"
 875         end
 876       end
 877
 878       # -------------------------------------
 879       # Test deleting elements.
 880       # -------------------------------------
 881
 882       ##
 883       # test a complex delete where we delete elements which rely on each other
 884       # in the same transaction.
 885       def test_upload_delete_elements
 886         changeset = create(:changeset)
 887         super_relation = create(:relation)
 888         used_relation = create(:relation)
 889         used_way = create(:way)
 890         used_node = create(:node)
 891         create(:relation_member, :relation => super_relation, :member => used_relation)
 892         create(:relation_member, :relation => super_relation, :member => used_way)
 893         create(:relation_member, :relation => super_relation, :member => used_node)
 894
 895         diff = XML::Document.new
 896         diff.root = XML::Node.new "osmChange"
 897         delete = XML::Node.new "delete"
 898         diff.root << delete
 899         delete << xml_node_for_relation(super_relation)
 900         delete << xml_node_for_relation(used_relation)
 901         delete << xml_node_for_way(used_way)
 902         delete << xml_node_for_node(used_node)
 903         %w[node way relation].each do |type|
 904           delete.find("//osmChange/delete/#{type}").each do |n|
 905             n["changeset"] = changeset.id.to_s
 906           end
 907         end
 908
 909         auth_header = bearer_authorization_header changeset.user
 910
 911         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 912
 913         assert_response :success
 914
 915         assert_dom "diffResult", 1 do
 916           assert_dom "> node", 1
 917           assert_dom "> way", 1
 918           assert_dom "> relation", 2
 919         end
 920
 921         assert_not Node.find(used_node.id).visible
 922         assert_not Way.find(used_way.id).visible
 923         assert_not Relation.find(super_relation.id).visible
 924         assert_not Relation.find(used_relation.id).visible
 925       end
 926
 927       ##
 928       # test uploading a delete with no lat/lon, as they are optional in the osmChange spec.
 929       def test_upload_delete_node_without_latlon
 930         node = create(:node)
 931         changeset = create(:changeset)
 932
 933         diff = "<osmChange><delete><node id='#{node.id}' version='#{node.version}' changeset='#{changeset.id}'/></delete></osmChange>"
 934
 935         auth_header = bearer_authorization_header changeset.user
 936
 937         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
 938
 939         assert_response :success
 940
 941         assert_dom "diffResult", 1 do
 942           assert_dom "> node", 1 do
 943             assert_dom "> @old_id", node.id.to_s
 944             assert_dom "> @new_id", 0
 945             assert_dom "> @new_version", 0
 946           end
 947         end
 948
 949         node.reload
 950         assert_not node.visible
 951       end
 952
 953       ##
 954       # test that deleting stuff in a transaction doesn't bypass the checks
 955       # to ensure that used elements are not deleted.
 956       def test_upload_delete_referenced_elements
 957         changeset = create(:changeset)
 958         relation = create(:relation)
 959         other_relation = create(:relation)
 960         used_way = create(:way)
 961         used_node = create(:node)
 962         create(:relation_member, :relation => relation, :member => used_way)
 963         create(:relation_member, :relation => relation, :member => used_node)
 964
 965         diff = XML::Document.new
 966         diff.root = XML::Node.new "osmChange"
 967         delete = XML::Node.new "delete"
 968         diff.root << delete
 969         delete << xml_node_for_relation(other_relation)
 970         delete << xml_node_for_way(used_way)
 971         delete << xml_node_for_node(used_node)
 972         %w[node way relation].each do |type|
 973           delete.find("//osmChange/delete/#{type}").each do |n|
 974             n["changeset"] = changeset.id.to_s
 975           end
 976         end
 977
 978         auth_header = bearer_authorization_header changeset.user
 979
 980         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
 981
 982         assert_response :precondition_failed
 983         assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
 984
 985         assert Node.find(used_node.id).visible
 986         assert Way.find(used_way.id).visible
 987         assert Relation.find(relation.id).visible
 988         assert Relation.find(other_relation.id).visible
 989       end
 990
 991       ##
 992       # test that a conditional delete of an in use object works.
 993       def test_upload_delete_if_unused
 994         changeset = create(:changeset)
 995         super_relation = create(:relation)
 996         used_relation = create(:relation)
 997         used_way = create(:way)
 998         used_node = create(:node)
 999         create(:relation_member, :relation => super_relation, :member => used_relation)
1000         create(:relation_member, :relation => super_relation, :member => used_way)
1001         create(:relation_member, :relation => super_relation, :member => used_node)
1002
1003         diff = XML::Document.new
1004         diff.root = XML::Node.new "osmChange"
1005         delete = XML::Node.new "delete"
1006         diff.root << delete
1007         delete["if-unused"] = ""
1008         delete << xml_node_for_relation(used_relation)
1009         delete << xml_node_for_way(used_way)
1010         delete << xml_node_for_node(used_node)
1011         %w[node way relation].each do |type|
1012           delete.find("//osmChange/delete/#{type}").each do |n|
1013             n["changeset"] = changeset.id.to_s
1014           end
1015         end
1016
1017         auth_header = bearer_authorization_header changeset.user
1018
1019         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1020
1021         assert_response :success
1022
1023         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
1024           assert_dom "> node", 1 do
1025             assert_dom "> @old_id", used_node.id.to_s
1026             assert_dom "> @new_id", used_node.id.to_s
1027             assert_dom "> @new_version", used_node.version.to_s
1028           end
1029           assert_dom "> way", 1 do
1030             assert_dom "> @old_id", used_way.id.to_s
1031             assert_dom "> @new_id", used_way.id.to_s
1032             assert_dom "> @new_version", used_way.version.to_s
1033           end
1034           assert_dom "> relation", 1 do
1035             assert_dom "> @old_id", used_relation.id.to_s
1036             assert_dom "> @new_id", used_relation.id.to_s
1037             assert_dom "> @new_version", used_relation.version.to_s
1038           end
1039         end
1040
1041         assert Node.find(used_node.id).visible
1042         assert Way.find(used_way.id).visible
1043         assert Relation.find(used_relation.id).visible
1044       end
1045
1046       def test_upload_delete_with_multiple_blocks_and_if_unused
1047         changeset = create(:changeset)
1048         node = create(:node)
1049         way = create(:way)
1050         create(:way_node, :way => way, :node => node)
1051         alone_node = create(:node)
1052
1053         diff = <<~CHANGESET
1054           <osmChange version='0.6'>
1055             <delete version="0.6">
1056               <node id="#{node.id}" version="#{node.version}" changeset="#{changeset.id}"/>
1057             </delete>
1058             <delete version="0.6" if-unused="true">
1059               <node id="#{alone_node.id}" version="#{alone_node.version}" changeset="#{changeset.id}"/>
1060             </delete>
1061           </osmChange>
1062         CHANGESET
1063
1064         auth_header = bearer_authorization_header changeset.user
1065
1066         post api_changeset_upload_path(changeset), :params => diff.to_s, :headers => auth_header
1067
1068         assert_response :precondition_failed
1069
1070         assert_equal "Precondition failed: Node #{node.id} is still used by ways #{way.id}.", @response.body
1071       end
1072
1073       def test_upload_delete_unknown_node_placeholder
1074         check_upload_results_in_not_found do |changeset|
1075           "<delete><node id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1076         end
1077       end
1078
1079       def test_upload_delete_unknown_way_placeholder
1080         check_upload_results_in_not_found do |changeset|
1081           "<delete><way id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1082         end
1083       end
1084
1085       def test_upload_delete_unknown_relation_placeholder
1086         check_upload_results_in_not_found do |changeset|
1087           "<delete><relation id='-1' changeset='#{changeset.id}' version='1'/></delete>"
1088         end
1089       end
1090
1091       # -------------------------------------
1092       # Test combined element changes.
1093       # -------------------------------------
1094
1095       ##
1096       # upload something which creates new objects and inserts them into
1097       # existing containers using placeholders.
1098       def test_upload_create_and_insert_elements
1099         way = create(:way)
1100         node = create(:node)
1101         relation = create(:relation)
1102         create(:way_node, :way => way, :node => node)
1103         changeset = create(:changeset)
1104
1105         diff = <<~CHANGESET
1106           <osmChange>
1107             <create>
1108               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1109                 <tag k='foo' v='bar'/>
1110                 <tag k='baz' v='bat'/>
1111               </node>
1112             </create>
1113             <modify>
1114               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
1115                 <nd ref='-1'/>
1116                 <nd ref='#{node.id}'/>
1117               </way>
1118               <relation id='#{relation.id}' changeset='#{changeset.id}' version='1'>
1119                 <member type='way' role='some' ref='#{way.id}'/>
1120                 <member type='node' role='some' ref='-1'/>
1121                 <member type='relation' role='some' ref='#{relation.id}'/>
1122               </relation>
1123             </modify>
1124           </osmChange>
1125         CHANGESET
1126
1127         auth_header = bearer_authorization_header changeset.user
1128
1129         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1130
1131         assert_response :success
1132
1133         new_node_id = nil
1134         assert_dom "diffResult[version='#{Settings.api_version}'][generator='#{Settings.generator}']", 1 do
1135           assert_dom "> node", 1 do |(node_el)|
1136             new_node_id = node_el["new_id"].to_i
1137           end
1138           assert_dom "> way", 1
1139           assert_dom "> relation", 1
1140         end
1141
1142         assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags"
1143         assert_equal [new_node_id, node.id], Way.find(way.id).nds, "way nodes should match"
1144         Relation.find(relation.id).members.each do |type, id, _role|
1145           assert_equal new_node_id, id, "relation should contain new node" if type == "node"
1146         end
1147       end
1148
1149       ##
1150       # test that a placeholder can be reused within the same upload.
1151       def test_upload_create_modify_delete_node_reusing_placeholder
1152         changeset = create(:changeset)
1153
1154         diff = <<~CHANGESET
1155           <osmChange>
1156             <create>
1157               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1158                 <tag k="foo" v="bar"/>
1159               </node>
1160             </create>
1161             <modify>
1162               <node id='-1' lon='1' lat='1' changeset='#{changeset.id}' version='1'/>
1163             </modify>
1164             <delete>
1165               <node id='-1' lon='2' lat='2' changeset='#{changeset.id}' version='2'/>
1166             </delete>
1167           </osmChange>
1168         CHANGESET
1169
1170         auth_header = bearer_authorization_header changeset.user
1171
1172         assert_difference "Node.count", 1 do
1173           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1174
1175           assert_response :success
1176         end
1177
1178         assert_dom "diffResult>node", 3
1179         assert_dom "diffResult>node[old_id='-1']", 3
1180
1181         node = Node.last
1182         assert_equal 3, node.version
1183         assert_not node.visible
1184       end
1185
1186       def test_upload_create_and_duplicate_delete
1187         changeset = create(:changeset)
1188
1189         diff = <<~CHANGESET
1190           <osmChange>
1191             <create>
1192               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1193             </create>
1194             <delete>
1195               <node id="-1" version="1" changeset="#{changeset.id}" />
1196               <node id="-1" version="1" changeset="#{changeset.id}" />
1197             </delete>
1198           </osmChange>
1199         CHANGESET
1200
1201         auth_header = bearer_authorization_header changeset.user
1202
1203         assert_no_difference "Node.count" do
1204           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1205
1206           assert_response :gone
1207         end
1208       end
1209
1210       def test_upload_create_and_duplicate_delete_if_unused
1211         changeset = create(:changeset)
1212
1213         diff = <<~CHANGESET
1214           <osmChange>
1215             <create>
1216               <node id="-1" lat="39" lon="116" changeset="#{changeset.id}" />
1217             </create>
1218             <delete if-unused="true">
1219               <node id="-1" version="1" changeset="#{changeset.id}" />
1220               <node id="-1" version="1" changeset="#{changeset.id}" />
1221             </delete>
1222           </osmChange>
1223         CHANGESET
1224
1225         auth_header = bearer_authorization_header changeset.user
1226
1227         assert_difference "Node.count", 1 do
1228           post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1229
1230           assert_response :success
1231         end
1232
1233         assert_dom "diffResult>node", 3
1234         assert_dom "diffResult>node[old_id='-1']", 3
1235         assert_dom "diffResult>node[new_version='1']", 1
1236         assert_dom "diffResult>node[new_version='2']", 1
1237
1238         node = Node.last
1239         assert_equal 2, node.version
1240         assert_not node.visible
1241       end
1242
1243       # -------------------------------------
1244       # Test bounding boxes.
1245       # -------------------------------------
1246
1247       def test_upload_bbox_of_widely_spaced_nodes
1248         user = create(:user)
1249
1250         # create an old changeset to ensure we have the maximum rate limit
1251         create(:changeset, :user => user, :created_at => Time.now.utc - 28.days)
1252
1253         changeset = create(:changeset, :user => user)
1254
1255         # upload some widely-spaced nodes, spiralling positive and negative
1256         diff = <<~CHANGESET
1257           <osmChange>
1258             <create>
1259               <node id='-1' lon='-20' lat='-10' changeset='#{changeset.id}'/>
1260               <node id='-10' lon='20'  lat='10' changeset='#{changeset.id}'/>
1261               <node id='-2' lon='-40' lat='-20' changeset='#{changeset.id}'/>
1262               <node id='-11' lon='40'  lat='20' changeset='#{changeset.id}'/>
1263               <node id='-3' lon='-60' lat='-30' changeset='#{changeset.id}'/>
1264               <node id='-12' lon='60'  lat='30' changeset='#{changeset.id}'/>
1265               <node id='-4' lon='-80' lat='-40' changeset='#{changeset.id}'/>
1266               <node id='-13' lon='80'  lat='40' changeset='#{changeset.id}'/>
1267               <node id='-5' lon='-100' lat='-50' changeset='#{changeset.id}'/>
1268               <node id='-14' lon='100'  lat='50' changeset='#{changeset.id}'/>
1269               <node id='-6' lon='-120' lat='-60' changeset='#{changeset.id}'/>
1270               <node id='-15' lon='120'  lat='60' changeset='#{changeset.id}'/>
1271               <node id='-7' lon='-140' lat='-70' changeset='#{changeset.id}'/>
1272               <node id='-16' lon='140'  lat='70' changeset='#{changeset.id}'/>
1273               <node id='-8' lon='-160' lat='-80' changeset='#{changeset.id}'/>
1274               <node id='-17' lon='160'  lat='80' changeset='#{changeset.id}'/>
1275               <node id='-9' lon='-179.9' lat='-89.9' changeset='#{changeset.id}'/>
1276               <node id='-18' lon='179.9'  lat='89.9' changeset='#{changeset.id}'/>
1277             </create>
1278           </osmChange>
1279         CHANGESET
1280
1281         auth_header = bearer_authorization_header user
1282
1283         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1284
1285         assert_response :success
1286
1287         # check that the changeset bbox is within bounds
1288         changeset.reload
1289         assert_operator changeset.min_lon, :>=, -180 * GeoRecord::SCALE, "Minimum longitude (#{changeset.min_lon / GeoRecord::SCALE}) should be >= -180 to be valid."
1290         assert_operator changeset.max_lon, :<=, 180 * GeoRecord::SCALE, "Maximum longitude (#{changeset.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
1291         assert_operator changeset.min_lat, :>=, -90 * GeoRecord::SCALE, "Minimum latitude (#{changeset.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
1292         assert_operator changeset.max_lat, :<=, 90 * GeoRecord::SCALE, "Maximum latitude (#{changeset.max_lat / GeoRecord::SCALE}) should be <= 90 to be valid."
1293       end
1294
1295       def test_upload_bbox_of_moved_node
1296         changeset = create(:changeset)
1297         node = create(:node, :lat => 1.0, :lon => 2.0)
1298
1299         diff = <<~CHANGESET
1300           <osmChange>
1301             <modify>
1302               <node id='#{node.id}' lat='1.1' lon='2.1' changeset='#{changeset.id}' version='1'/>
1303             </modify>
1304           </osmChange>
1305         CHANGESET
1306
1307         auth_header = bearer_authorization_header changeset.user
1308
1309         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1310
1311         assert_response :success
1312
1313         # check the bbox
1314         changeset.reload
1315         assert_equal 1.0 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.0 degrees"
1316         assert_equal 2.0 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.0 degrees"
1317         assert_equal 1.1 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.1 degrees"
1318         assert_equal 2.1 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.1 degrees"
1319       end
1320
1321       def test_upload_bbox_of_extended_way
1322         way = create(:way)
1323         initial_node = create(:node, :lat => 1.1, :lon => 2.1)
1324         create(:way_node, :way => way, :node => initial_node)
1325         added_node = create(:node, :lat => 1.3, :lon => 2.3)
1326         changeset = create(:changeset)
1327
1328         diff = <<~CHANGESET
1329           <osmChange>
1330             <modify>
1331               <way id='#{way.id}' changeset='#{changeset.id}' version='1'>
1332                 <nd ref='#{initial_node.id}'/>
1333                 <nd ref='#{added_node.id}'/>
1334               </way>
1335             </modify>
1336           </osmChange>
1337         CHANGESET
1338
1339         auth_header = bearer_authorization_header changeset.user
1340
1341         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1342
1343         assert_response :success
1344
1345         # check the bbox
1346         changeset.reload
1347         assert_equal 1.1 * GeoRecord::SCALE, changeset.min_lat, "min_lat should be 1.1 degrees"
1348         assert_equal 2.1 * GeoRecord::SCALE, changeset.min_lon, "min_lon should be 2.1 degrees"
1349         assert_equal 1.3 * GeoRecord::SCALE, changeset.max_lat, "max_lat should be 1.3 degrees"
1350         assert_equal 2.3 * GeoRecord::SCALE, changeset.max_lon, "max_lon should be 2.3 degrees"
1351       end
1352
1353       # -------------------------------------
1354       # Test upload rate/size limits.
1355       # -------------------------------------
1356
1357       def test_upload_initial_rate_limit
1358         user = create(:user)
1359         node = create(:node)
1360         way = create(:way_with_nodes, :nodes_count => 2)
1361         relation = create(:relation)
1362
1363         # create a changeset that puts us near the initial rate limit
1364         changeset = create(:changeset, :user => user,
1365                                        :created_at => Time.now.utc - 5.minutes,
1366                                        :num_changes => Settings.initial_changes_per_hour - 2)
1367
1368         diff = <<~CHANGESET
1369           <osmChange>
1370             <create>
1371               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1372                 <tag k='foo' v='bar'/>
1373                 <tag k='baz' v='bat'/>
1374               </node>
1375               <way id='-1' changeset='#{changeset.id}'>
1376                 <nd ref='#{node.id}'/>
1377               </way>
1378             </create>
1379             <create>
1380               <relation id='-1' changeset='#{changeset.id}'>
1381                 <member type='way' role='some' ref='#{way.id}'/>
1382                 <member type='node' role='some' ref='#{node.id}'/>
1383                 <member type='relation' role='some' ref='#{relation.id}'/>
1384               </relation>
1385             </create>
1386           </osmChange>
1387         CHANGESET
1388
1389         auth_header = bearer_authorization_header user
1390
1391         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1392
1393         assert_response :too_many_requests, "upload did not hit rate limit"
1394       end
1395
1396       def test_upload_maximum_rate_limit
1397         user = create(:user)
1398         node = create(:node)
1399         way = create(:way_with_nodes, :nodes_count => 2)
1400         relation = create(:relation)
1401
1402         # create a changeset to establish our initial edit time
1403         changeset = create(:changeset, :user => user,
1404                                        :created_at => Time.now.utc - 28.days)
1405
1406         # create changeset to put us near the maximum rate limit
1407         total_changes = Settings.max_changes_per_hour - 2
1408         while total_changes.positive?
1409           changes = [total_changes, Changeset::MAX_ELEMENTS].min
1410           changeset = create(:changeset, :user => user,
1411                                          :created_at => Time.now.utc - 5.minutes,
1412                                          :num_changes => changes)
1413           total_changes -= changes
1414         end
1415
1416         diff = <<~CHANGESET
1417           <osmChange>
1418             <create>
1419               <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
1420                 <tag k='foo' v='bar'/>
1421                 <tag k='baz' v='bat'/>
1422               </node>
1423               <way id='-1' changeset='#{changeset.id}'>
1424                 <nd ref='#{node.id}'/>
1425               </way>
1426             </create>
1427             <create>
1428               <relation id='-1' changeset='#{changeset.id}'>
1429                 <member type='way' role='some' ref='#{way.id}'/>
1430                 <member type='node' role='some' ref='#{node.id}'/>
1431                 <member type='relation' role='some' ref='#{relation.id}'/>
1432               </relation>
1433             </create>
1434           </osmChange>
1435         CHANGESET
1436
1437         auth_header = bearer_authorization_header user
1438
1439         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1440
1441         assert_response :too_many_requests, "upload did not hit rate limit"
1442       end
1443
1444       def test_upload_initial_size_limit
1445         user = create(:user)
1446
1447         # create a changeset that puts us near the initial size limit
1448         changeset = create(:changeset, :user => user,
1449                                        :min_lat => (-0.5 * GeoRecord::SCALE).round, :min_lon => (0.5 * GeoRecord::SCALE).round,
1450                                        :max_lat => (0.5 * GeoRecord::SCALE).round, :max_lon => (2.5 * GeoRecord::SCALE).round)
1451
1452         diff = <<~CHANGESET
1453           <osmChange>
1454             <create>
1455               <node id='-1' lon='0.9' lat='2.9' changeset='#{changeset.id}'>
1456                 <tag k='foo' v='bar'/>
1457                 <tag k='baz' v='bat'/>
1458               </node>
1459             </create>
1460           </osmChange>
1461         CHANGESET
1462
1463         auth_header = bearer_authorization_header user
1464
1465         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1466
1467         assert_response :payload_too_large, "upload did not hit size limit"
1468       end
1469
1470       def test_upload_size_limit_after_one_week
1471         user = create(:user)
1472
1473         # create a changeset to establish our initial edit time
1474         create(:changeset, :user => user, :created_at => Time.now.utc - 7.days)
1475
1476         # create a changeset that puts us near the initial size limit
1477         changeset = create(:changeset, :user => user, :bbox => [0.5, -0.5, 2.5, 0.5])
1478
1479         diff = <<~CHANGESET
1480           <osmChange>
1481             <create>
1482               <node id='-1' lon='35' lat='35' changeset='#{changeset.id}'>
1483                 <tag k='foo' v='bar'/>
1484                 <tag k='baz' v='bat'/>
1485               </node>
1486             </create>
1487           </osmChange>
1488         CHANGESET
1489
1490         auth_header = bearer_authorization_header user
1491
1492         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1493
1494         assert_response :payload_too_large, "upload did not hit size limit"
1495       end
1496
1497       private
1498
1499       def check_upload_results_in_not_found(&)
1500         changeset = create(:changeset)
1501         diff = "<osmChange>#{yield changeset}</osmChange>"
1502         auth_header = bearer_authorization_header changeset.user
1503
1504         post api_changeset_upload_path(changeset), :params => diff, :headers => auth_header
1505
1506         assert_response :not_found
1507         changeset.reload
1508         assert_equal 0, changeset.num_changes
1509       end
1510     end
1511   end
1512 end