test/controllers/way_controller_test.rb

   1 require "test_helper"
   2 require "way_controller"
   3
   4 class WayControllerTest < ActionController::TestCase
   5   api_fixtures
   6
   7   ##
   8   # test all routes which lead to this controller
   9   def test_routes
  10     assert_routing(
  11       { :path => "/api/0.6/way/create", :method => :put },
  12       { :controller => "way", :action => "create" }
  13     )
  14     assert_routing(
  15       { :path => "/api/0.6/way/1/full", :method => :get },
  16       { :controller => "way", :action => "full", :id => "1" }
  17     )
  18     assert_routing(
  19       { :path => "/api/0.6/way/1", :method => :get },
  20       { :controller => "way", :action => "read", :id => "1" }
  21     )
  22     assert_routing(
  23       { :path => "/api/0.6/way/1", :method => :put },
  24       { :controller => "way", :action => "update", :id => "1" }
  25     )
  26     assert_routing(
  27       { :path => "/api/0.6/way/1", :method => :delete },
  28       { :controller => "way", :action => "delete", :id => "1" }
  29     )
  30     assert_routing(
  31       { :path => "/api/0.6/ways", :method => :get },
  32       { :controller => "way", :action => "ways" }
  33     )
  34   end
  35
  36   # -------------------------------------
  37   # Test reading ways.
  38   # -------------------------------------
  39
  40   def test_read
  41     # check that a visible way is returned properly
  42     get :read, :id => current_ways(:visible_way).id
  43     assert_response :success
  44
  45     # check that an invisible way is not returned
  46     get :read, :id => current_ways(:invisible_way).id
  47     assert_response :gone
  48
  49     # check chat a non-existent way is not returned
  50     get :read, :id => 0
  51     assert_response :not_found
  52   end
  53
  54   ##
  55   # check the "full" mode
  56   def test_full
  57     Way.all.each do |way|
  58       get :full, :id => way.id
  59
  60       # full call should say "gone" for non-visible ways...
  61       unless way.visible
  62         assert_response :gone
  63         next
  64       end
  65
  66       # otherwise it should say success
  67       assert_response :success
  68
  69       # Check the way is correctly returned
  70       assert_select "osm way[id='#{way.id}'][version='#{way.version}'][visible='#{way.visible}']", 1
  71
  72       # check that each node in the way appears once in the output as a
  73       # reference and as the node element.
  74       way.nodes.each do |n|
  75         count = (way.nodes - (way.nodes - [n])).length
  76         assert_select "osm way nd[ref='#{n.id}']", count
  77         assert_select "osm node[id='#{n.id}'][version='#{n.version}'][lat='#{format('%.7f', n.lat)}'][lon='#{format('%.7f', n.lon)}']", 1
  78       end
  79     end
  80   end
  81
  82   ##
  83   # test fetching multiple ways
  84   def test_ways
  85     # check error when no parameter provided
  86     get :ways
  87     assert_response :bad_request
  88
  89     # check error when no parameter value provided
  90     get :ways, :ways => ""
  91     assert_response :bad_request
  92
  93     # test a working call
  94     get :ways, :ways => "1,2,4,6"
  95     assert_response :success
  96     assert_select "osm" do
  97       assert_select "way", :count => 4
  98       assert_select "way[id='1'][visible='true']", :count => 1
  99       assert_select "way[id='2'][visible='false']", :count => 1
 100       assert_select "way[id='4'][visible='true']", :count => 1
 101       assert_select "way[id='6'][visible='true']", :count => 1
 102     end
 103
 104     # check error when a non-existent way is included
 105     get :ways, :ways => "1,2,4,6,400"
 106     assert_response :not_found
 107   end
 108
 109   # -------------------------------------
 110   # Test simple way creation.
 111   # -------------------------------------
 112
 113   def test_create
 114     node1 = create(:node)
 115     node2 = create(:node)
 116     private_user = create(:user, :data_public => false)
 117     private_changeset = create(:changeset, :user => private_user)
 118     user = create(:user)
 119     changeset = create(:changeset, :user => user)
 120
 121     ## First check that it fails when creating a way using a non-public user
 122     basic_authorization private_user.email, "test"
 123
 124     # use the first user's open changeset
 125     changeset_id = private_changeset.id
 126
 127     # create a way with pre-existing nodes
 128     content "<osm><way changeset='#{changeset_id}'>" +
 129             "<nd ref='#{node1.id}'/><nd ref='#{node2.id}'/>" +
 130             "<tag k='test' v='yes' /></way></osm>"
 131     put :create
 132     # hope for failure
 133     assert_response :forbidden,
 134                     "way upload did not return forbidden status"
 135
 136     ## Now use a public user
 137     basic_authorization user.email, "test"
 138
 139     # use the first user's open changeset
 140     changeset_id = changeset.id
 141
 142     # create a way with pre-existing nodes
 143     content "<osm><way changeset='#{changeset_id}'>" +
 144             "<nd ref='#{node1.id}'/><nd ref='#{node2.id}'/>" +
 145             "<tag k='test' v='yes' /></way></osm>"
 146     put :create
 147     # hope for success
 148     assert_response :success,
 149                     "way upload did not return success status"
 150     # read id of created way and search for it
 151     wayid = @response.body
 152     checkway = Way.find(wayid)
 153     assert_not_nil checkway,
 154                    "uploaded way not found in data base after upload"
 155     # compare values
 156     assert_equal checkway.nds.length, 2,
 157                  "saved way does not contain exactly one node"
 158     assert_equal checkway.nds[0], node1.id,
 159                  "saved way does not contain the right node on pos 0"
 160     assert_equal checkway.nds[1], node2.id,
 161                  "saved way does not contain the right node on pos 1"
 162     assert_equal checkway.changeset_id, changeset_id,
 163                  "saved way does not belong to the correct changeset"
 164     assert_equal user.id, checkway.changeset.user_id,
 165                  "saved way does not belong to user that created it"
 166     assert_equal true, checkway.visible,
 167                  "saved way is not visible"
 168   end
 169
 170   # -------------------------------------
 171   # Test creating some invalid ways.
 172   # -------------------------------------
 173
 174   def test_create_invalid
 175     node = create(:node)
 176     private_user = create(:user, :data_public => false)
 177     private_open_changeset = create(:changeset, :user => private_user)
 178     private_closed_changeset = create(:changeset, :closed, :user => private_user)
 179     user = create(:user)
 180     open_changeset = create(:changeset, :user => user)
 181     closed_changeset = create(:changeset, :closed, :user => user)
 182
 183     ## First test with a private user to make sure that they are not authorized
 184     basic_authorization private_user.email, "test"
 185
 186     # use the first user's open changeset
 187     # create a way with non-existing node
 188     content "<osm><way changeset='#{private_open_changeset.id}'>" +
 189             "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
 190     put :create
 191     # expect failure
 192     assert_response :forbidden,
 193                     "way upload with invalid node using a private user did not return 'forbidden'"
 194
 195     # create a way with no nodes
 196     content "<osm><way changeset='#{private_open_changeset.id}'>" +
 197             "<tag k='test' v='yes' /></way></osm>"
 198     put :create
 199     # expect failure
 200     assert_response :forbidden,
 201                     "way upload with no node using a private userdid not return 'forbidden'"
 202
 203     # create a way inside a closed changeset
 204     content "<osm><way changeset='#{private_closed_changeset.id}'>" +
 205             "<nd ref='#{node.id}'/></way></osm>"
 206     put :create
 207     # expect failure
 208     assert_response :forbidden,
 209                     "way upload to closed changeset with a private user did not return 'forbidden'"
 210
 211     ## Now test with a public user
 212     basic_authorization user.email, "test"
 213
 214     # use the first user's open changeset
 215     # create a way with non-existing node
 216     content "<osm><way changeset='#{open_changeset.id}'>" +
 217             "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
 218     put :create
 219     # expect failure
 220     assert_response :precondition_failed,
 221                     "way upload with invalid node did not return 'precondition failed'"
 222     assert_equal "Precondition failed: Way  requires the nodes with id in (0), which either do not exist, or are not visible.", @response.body
 223
 224     # create a way with no nodes
 225     content "<osm><way changeset='#{open_changeset.id}'>" +
 226             "<tag k='test' v='yes' /></way></osm>"
 227     put :create
 228     # expect failure
 229     assert_response :precondition_failed,
 230                     "way upload with no node did not return 'precondition failed'"
 231     assert_equal "Precondition failed: Cannot create way: data is invalid.", @response.body
 232
 233     # create a way inside a closed changeset
 234     content "<osm><way changeset='#{closed_changeset.id}'>" +
 235             "<nd ref='#{node.id}'/></way></osm>"
 236     put :create
 237     # expect failure
 238     assert_response :conflict,
 239                     "way upload to closed changeset did not return 'conflict'"
 240
 241     # create a way with a tag which is too long
 242     content "<osm><way changeset='#{open_changeset.id}'>" +
 243             "<nd ref='#{node.id}'/>" +
 244             "<tag k='foo' v='#{'x' * 256}'/>" +
 245             "</way></osm>"
 246     put :create
 247     # expect failure
 248     assert_response :bad_request,
 249                     "way upload to with too long tag did not return 'bad_request'"
 250   end
 251
 252   # -------------------------------------
 253   # Test deleting ways.
 254   # -------------------------------------
 255
 256   def test_delete
 257     private_user = create(:user, :data_public => false)
 258     private_open_changeset = create(:changeset, :user => private_user)
 259     private_closed_changeset = create(:changeset, :closed, :user => private_user)
 260     private_way = create(:way, :changeset => private_open_changeset)
 261     private_deleted_way = create(:way, :deleted, :changeset => private_open_changeset)
 262     private_used_way = create(:way, :changeset => private_open_changeset)
 263     create(:relation_member, :member => private_used_way)
 264     user = create(:user)
 265     open_changeset = create(:changeset, :user => user)
 266     closed_changeset = create(:changeset, :closed, :user => user)
 267     way = create(:way, :changeset => open_changeset)
 268     deleted_way = create(:way, :deleted, :changeset => open_changeset)
 269     used_way = create(:way, :changeset => open_changeset)
 270     relation_member = create(:relation_member, :member => used_way)
 271     relation = relation_member.relation
 272
 273     # first try to delete way without auth
 274     delete :delete, :id => way.id
 275     assert_response :unauthorized
 276
 277     # now set auth using the private user
 278     basic_authorization(private_user.email, "test")
 279
 280     # this shouldn't work as with the 0.6 api we need pay load to delete
 281     delete :delete, :id => private_way.id
 282     assert_response :forbidden
 283
 284     # Now try without having a changeset
 285     content "<osm><way id='#{private_way.id}'/></osm>"
 286     delete :delete, :id => private_way.id
 287     assert_response :forbidden
 288
 289     # try to delete with an invalid (closed) changeset
 290     content update_changeset(private_way.to_xml, private_closed_changeset.id)
 291     delete :delete, :id => private_way.id
 292     assert_response :forbidden
 293
 294     # try to delete with an invalid (non-existent) changeset
 295     content update_changeset(private_way.to_xml, 0)
 296     delete :delete, :id => private_way.id
 297     assert_response :forbidden
 298
 299     # Now try with a valid changeset
 300     content private_way.to_xml
 301     delete :delete, :id => private_way.id
 302     assert_response :forbidden
 303
 304     # check the returned value - should be the new version number
 305     # valid delete should return the new version number, which should
 306     # be greater than the old version number
 307     # assert @response.body.to_i > current_ways(:visible_way).version,
 308     #   "delete request should return a new version number for way"
 309
 310     # this won't work since the way is already deleted
 311     content private_deleted_way.to_xml
 312     delete :delete, :id => private_deleted_way.id
 313     assert_response :forbidden
 314
 315     # this shouldn't work as the way is used in a relation
 316     content private_used_way.to_xml
 317     delete :delete, :id => private_used_way.id
 318     assert_response :forbidden,
 319                     "shouldn't be able to delete a way used in a relation (#{@response.body}), when done by a private user"
 320
 321     # this won't work since the way never existed
 322     delete :delete, :id => 0
 323     assert_response :forbidden
 324
 325     ### Now check with a public user
 326     # now set auth
 327     basic_authorization(user.email, "test")
 328
 329     # this shouldn't work as with the 0.6 api we need pay load to delete
 330     delete :delete, :id => way.id
 331     assert_response :bad_request
 332
 333     # Now try without having a changeset
 334     content "<osm><way id='#{way.id}'/></osm>"
 335     delete :delete, :id => way.id
 336     assert_response :bad_request
 337
 338     # try to delete with an invalid (closed) changeset
 339     content update_changeset(way.to_xml, closed_changeset.id)
 340     delete :delete, :id => way.id
 341     assert_response :conflict
 342
 343     # try to delete with an invalid (non-existent) changeset
 344     content update_changeset(way.to_xml, 0)
 345     delete :delete, :id => way.id
 346     assert_response :conflict
 347
 348     # Now try with a valid changeset
 349     content way.to_xml
 350     delete :delete, :id => way.id
 351     assert_response :success
 352
 353     # check the returned value - should be the new version number
 354     # valid delete should return the new version number, which should
 355     # be greater than the old version number
 356     assert @response.body.to_i > way.version,
 357            "delete request should return a new version number for way"
 358
 359     # this won't work since the way is already deleted
 360     content deleted_way.to_xml
 361     delete :delete, :id => deleted_way.id
 362     assert_response :gone
 363
 364     # this shouldn't work as the way is used in a relation
 365     content used_way.to_xml
 366     delete :delete, :id => used_way.id
 367     assert_response :precondition_failed,
 368                     "shouldn't be able to delete a way used in a relation (#{@response.body})"
 369     assert_equal "Precondition failed: Way #{used_way.id} is still used by relations #{relation.id}.", @response.body
 370
 371     # this won't work since the way never existed
 372     delete :delete, :id => 0
 373     assert_response :not_found
 374   end
 375
 376   ##
 377   # tests whether the API works and prevents incorrect use while trying
 378   # to update ways.
 379   def test_update
 380     private_user = create(:user, :data_public => false)
 381     private_way = create(:way, :changeset => create(:changeset, :user => private_user))
 382     user = create(:user)
 383     way = create(:way, :changeset => create(:changeset, :user => user))
 384     node = create(:node)
 385     create(:way_node, :way => private_way, :node => node)
 386     create(:way_node, :way => way, :node => node)
 387
 388     ## First test with no user credentials
 389     # try and update a way without authorisation
 390     content way.to_xml
 391     put :update, :id => way.id
 392     assert_response :unauthorized
 393
 394     ## Second test with the private user
 395
 396     # setup auth
 397     basic_authorization(private_user.email, "test")
 398
 399     ## trying to break changesets
 400
 401     # try and update in someone else's changeset
 402     content update_changeset(private_way.to_xml,
 403                              create(:changeset).id)
 404     put :update, :id => private_way.id
 405     assert_require_public_data "update with other user's changeset should be forbidden when date isn't public"
 406
 407     # try and update in a closed changeset
 408     content update_changeset(private_way.to_xml,
 409                              create(:changeset, :closed, :user => private_user))
 410     put :update, :id => private_way.id
 411     assert_require_public_data "update with closed changeset should be forbidden, when data isn't public"
 412
 413     # try and update in a non-existant changeset
 414     content update_changeset(private_way.to_xml, 0)
 415     put :update, :id => private_way.id
 416     assert_require_public_data("update with changeset=0 should be forbidden, when data isn't public")
 417
 418     ## try and submit invalid updates
 419     content xml_replace_node(private_way.to_xml, node.id, 9999)
 420     put :update, :id => private_way.id
 421     assert_require_public_data "way with non-existent node should be forbidden, when data isn't public"
 422
 423     content xml_replace_node(private_way.to_xml, node.id, create(:node, :deleted).id)
 424     put :update, :id => private_way.id
 425     assert_require_public_data "way with deleted node should be forbidden, when data isn't public"
 426
 427     ## finally, produce a good request which will still not work
 428     content private_way.to_xml
 429     put :update, :id => private_way.id
 430     assert_require_public_data "should have failed with a forbidden when data isn't public"
 431
 432     ## Finally test with the public user
 433
 434     # setup auth
 435     basic_authorization(user.email, "test")
 436
 437     ## trying to break changesets
 438
 439     # try and update in someone else's changeset
 440     content update_changeset(way.to_xml,
 441                              create(:changeset).id)
 442     put :update, :id => way.id
 443     assert_response :conflict, "update with other user's changeset should be rejected"
 444
 445     # try and update in a closed changeset
 446     content update_changeset(way.to_xml,
 447                              changesets(:normal_user_closed_change).id)
 448     put :update, :id => way.id
 449     assert_response :conflict, "update with closed changeset should be rejected"
 450
 451     # try and update in a non-existant changeset
 452     content update_changeset(way.to_xml, 0)
 453     put :update, :id => way.id
 454     assert_response :conflict, "update with changeset=0 should be rejected"
 455
 456     ## try and submit invalid updates
 457     content xml_replace_node(way.to_xml, node.id, 9999)
 458     put :update, :id => way.id
 459     assert_response :precondition_failed, "way with non-existent node should be rejected"
 460
 461     content xml_replace_node(way.to_xml, node.id, create(:node, :deleted).id)
 462     put :update, :id => way.id
 463     assert_response :precondition_failed, "way with deleted node should be rejected"
 464
 465     ## next, attack the versioning
 466     current_way_version = way.version
 467
 468     # try and submit a version behind
 469     content xml_attr_rewrite(way.to_xml,
 470                              "version", current_way_version - 1)
 471     put :update, :id => way.id
 472     assert_response :conflict, "should have failed on old version number"
 473
 474     # try and submit a version ahead
 475     content xml_attr_rewrite(way.to_xml,
 476                              "version", current_way_version + 1)
 477     put :update, :id => way.id
 478     assert_response :conflict, "should have failed on skipped version number"
 479
 480     # try and submit total crap in the version field
 481     content xml_attr_rewrite(way.to_xml,
 482                              "version", "p1r4t3s!")
 483     put :update, :id => way.id
 484     assert_response :conflict,
 485                     "should not be able to put 'p1r4at3s!' in the version field"
 486
 487     ## try an update with the wrong ID
 488     content create(:way).to_xml
 489     put :update, :id => way.id
 490     assert_response :bad_request,
 491                     "should not be able to update a way with a different ID from the XML"
 492
 493     ## try an update with a minimal valid XML doc which isn't a well-formed OSM doc.
 494     content "<update/>"
 495     put :update, :id => way.id
 496     assert_response :bad_request,
 497                     "should not be able to update a way with non-OSM XML doc."
 498
 499     ## finally, produce a good request which should work
 500     content way.to_xml
 501     put :update, :id => way.id
 502     assert_response :success, "a valid update request failed"
 503   end
 504
 505   # ------------------------------------------------------------
 506   # test tags handling
 507   # ------------------------------------------------------------
 508
 509   ##
 510   # Try adding a new tag to a way
 511   def test_add_tags
 512     private_user = create(:user, :data_public => false)
 513     private_way = create(:way_with_nodes, :nodes_count => 2, :changeset => create(:changeset, :user => private_user))
 514     user = create(:user)
 515     way = create(:way_with_nodes, :nodes_count => 2, :changeset => create(:changeset, :user => user))
 516
 517     ## Try with the non-public user
 518     # setup auth
 519     basic_authorization(private_user.email, "test")
 520
 521     # add an identical tag to the way
 522     tag_xml = XML::Node.new("tag")
 523     tag_xml["k"] = "new"
 524     tag_xml["v"] = "yes"
 525
 526     # add the tag into the existing xml
 527     way_xml = private_way.to_xml
 528     way_xml.find("//osm/way").first << tag_xml
 529
 530     # try and upload it
 531     content way_xml
 532     put :update, :id => private_way.id
 533     assert_response :forbidden,
 534                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
 535
 536     ## Now try with the public user
 537     # setup auth
 538     basic_authorization(user.email, "test")
 539
 540     # add an identical tag to the way
 541     tag_xml = XML::Node.new("tag")
 542     tag_xml["k"] = "new"
 543     tag_xml["v"] = "yes"
 544
 545     # add the tag into the existing xml
 546     way_xml = way.to_xml
 547     way_xml.find("//osm/way").first << tag_xml
 548
 549     # try and upload it
 550     content way_xml
 551     put :update, :id => way.id
 552     assert_response :success,
 553                     "adding a new tag to a way should succeed"
 554     assert_equal way.version + 1, @response.body.to_i
 555   end
 556
 557   ##
 558   # Try adding a duplicate of an existing tag to a way
 559   def test_add_duplicate_tags
 560     ## Try with the non-public user
 561     # setup auth
 562     basic_authorization(users(:normal_user).email, "test")
 563
 564     existing = create(:way_tag, :way => current_ways(:visible_way))
 565
 566     # add an identical tag to the way
 567     tag_xml = XML::Node.new("tag")
 568     tag_xml["k"] = existing.k
 569     tag_xml["v"] = existing.v
 570
 571     # add the tag into the existing xml
 572     way_xml = current_ways(:visible_way).to_xml
 573     way_xml.find("//osm/way").first << tag_xml
 574
 575     # try and upload it
 576     content way_xml
 577     put :update, :id => current_ways(:visible_way).id
 578     assert_response :forbidden,
 579                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
 580
 581     ## Now try with the public user
 582     # setup auth
 583     basic_authorization(users(:public_user).email, "test")
 584
 585     # add an identical tag to the way
 586     tag_xml = XML::Node.new("tag")
 587     tag_xml["k"] = existing.k
 588     tag_xml["v"] = existing.v
 589
 590     # add the tag into the existing xml
 591     way_xml = current_ways(:visible_way).to_xml
 592     way_xml.find("//osm/way").first << tag_xml
 593
 594     # try and upload it
 595     content way_xml
 596     put :update, :id => current_ways(:visible_way).id
 597     assert_response :bad_request,
 598                     "adding a duplicate tag to a way should fail with 'bad request'"
 599     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{existing.k}", @response.body
 600   end
 601
 602   ##
 603   # Try adding a new duplicate tags to a way
 604   def test_new_duplicate_tags
 605     ## First test with the non-public user so should be rejected
 606     # setup auth
 607     basic_authorization(users(:normal_user).email, "test")
 608
 609     # create duplicate tag
 610     tag_xml = XML::Node.new("tag")
 611     tag_xml["k"] = "i_am_a_duplicate"
 612     tag_xml["v"] = "foobar"
 613
 614     # add the tag into the existing xml
 615     way_xml = current_ways(:visible_way).to_xml
 616
 617     # add two copies of the tag
 618     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
 619
 620     # try and upload it
 621     content way_xml
 622     put :update, :id => current_ways(:visible_way).id
 623     assert_response :forbidden,
 624                     "adding new duplicate tags to a way using a non-public user should fail with 'forbidden'"
 625
 626     ## Now test with the public user
 627     # setup auth
 628     basic_authorization(users(:public_user).email, "test")
 629
 630     # create duplicate tag
 631     tag_xml = XML::Node.new("tag")
 632     tag_xml["k"] = "i_am_a_duplicate"
 633     tag_xml["v"] = "foobar"
 634
 635     # add the tag into the existing xml
 636     way_xml = current_ways(:visible_way).to_xml
 637
 638     # add two copies of the tag
 639     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
 640
 641     # try and upload it
 642     content way_xml
 643     put :update, :id => current_ways(:visible_way).id
 644     assert_response :bad_request,
 645                     "adding new duplicate tags to a way should fail with 'bad request'"
 646     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate", @response.body
 647   end
 648
 649   ##
 650   # Try adding a new duplicate tags to a way.
 651   # But be a bit subtle - use unicode decoding ambiguities to use different
 652   # binary strings which have the same decoding.
 653   def test_invalid_duplicate_tags
 654     ## First make sure that you can't with a non-public user
 655     # setup auth
 656     basic_authorization(users(:normal_user).email, "test")
 657
 658     # add the tag into the existing xml
 659     way_str = "<osm><way changeset='1'>"
 660     way_str << "<tag k='addr:housenumber' v='1'/>"
 661     way_str << "<tag k='addr:housenumber' v='2'/>"
 662     way_str << "</way></osm>"
 663
 664     # try and upload it
 665     content way_str
 666     put :create
 667     assert_response :forbidden,
 668                     "adding new duplicate tags to a way with a non-public user should fail with 'forbidden'"
 669
 670     ## Now do it with a public user
 671     # setup auth
 672     basic_authorization(users(:public_user).email, "test")
 673
 674     # add the tag into the existing xml
 675     way_str = "<osm><way changeset='1'>"
 676     way_str << "<tag k='addr:housenumber' v='1'/>"
 677     way_str << "<tag k='addr:housenumber' v='2'/>"
 678     way_str << "</way></osm>"
 679
 680     # try and upload it
 681     content way_str
 682     put :create
 683     assert_response :bad_request,
 684                     "adding new duplicate tags to a way should fail with 'bad request'"
 685     assert_equal "Element way/ has duplicate tags with key addr:housenumber", @response.body
 686   end
 687
 688   ##
 689   # test that a call to ways_for_node returns all ways that contain the node
 690   # and none that don't.
 691   def test_ways_for_node
 692     # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4
 693     # *used* to use it but doesn't.
 694     get :ways_for_node, :id => current_nodes(:used_node_1).id
 695     assert_response :success
 696     ways_xml = XML::Parser.string(@response.body).parse
 697     assert_not_nil ways_xml, "failed to parse ways_for_node response"
 698
 699     # check that the set of IDs match expectations
 700     expected_way_ids = [current_ways(:visible_way).id,
 701                         current_ways(:used_way).id]
 702     found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
 703     assert_equal expected_way_ids.sort, found_way_ids.sort,
 704                  "expected ways for node #{current_nodes(:used_node_1).id} did not match found"
 705
 706     # check the full ways to ensure we're not missing anything
 707     expected_way_ids.each do |id|
 708       way_xml = ways_xml.find("//osm/way[@id='#{id}']").first
 709       assert_ways_are_equal(Way.find(id),
 710                             Way.from_xml_node(way_xml))
 711     end
 712   end
 713
 714   ##
 715   # update the changeset_id of a way element
 716   def update_changeset(xml, changeset_id)
 717     xml_attr_rewrite(xml, "changeset", changeset_id)
 718   end
 719
 720   ##
 721   # update an attribute in the way element
 722   def xml_attr_rewrite(xml, name, value)
 723     xml.find("//osm/way").first[name] = value.to_s
 724     xml
 725   end
 726
 727   ##
 728   # replace a node in a way element
 729   def xml_replace_node(xml, old_node, new_node)
 730     xml.find("//osm/way/nd[@ref='#{old_node}']").first["ref"] = new_node.to_s
 731     xml
 732   end
 733 end