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     ## Try with the non-public user
 513     # setup auth
 514     basic_authorization(users(:normal_user).email, "test")
 515
 516     # add an identical tag to the way
 517     tag_xml = XML::Node.new("tag")
 518     tag_xml["k"] = "new"
 519     tag_xml["v"] = "yes"
 520
 521     # add the tag into the existing xml
 522     way_xml = current_ways(:visible_way).to_xml
 523     way_xml.find("//osm/way").first << tag_xml
 524
 525     # try and upload it
 526     content way_xml
 527     put :update, :id => current_ways(:visible_way).id
 528     assert_response :forbidden,
 529                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
 530
 531     ## Now try with the public user
 532     # setup auth
 533     basic_authorization(users(:public_user).email, "test")
 534
 535     # add an identical tag to the way
 536     tag_xml = XML::Node.new("tag")
 537     tag_xml["k"] = "new"
 538     tag_xml["v"] = "yes"
 539
 540     # add the tag into the existing xml
 541     way_xml = current_ways(:visible_way).to_xml
 542     way_xml.find("//osm/way").first << tag_xml
 543
 544     # try and upload it
 545     content way_xml
 546     put :update, :id => current_ways(:visible_way).id
 547     assert_response :success,
 548                     "adding a new tag to a way should succeed"
 549     assert_equal current_ways(:visible_way).version + 1, @response.body.to_i
 550   end
 551
 552   ##
 553   # Try adding a duplicate of an existing tag to a way
 554   def test_add_duplicate_tags
 555     ## Try with the non-public user
 556     # setup auth
 557     basic_authorization(users(:normal_user).email, "test")
 558
 559     existing = create(:way_tag, :way => current_ways(:visible_way))
 560
 561     # add an identical tag to the way
 562     tag_xml = XML::Node.new("tag")
 563     tag_xml["k"] = existing.k
 564     tag_xml["v"] = existing.v
 565
 566     # add the tag into the existing xml
 567     way_xml = current_ways(:visible_way).to_xml
 568     way_xml.find("//osm/way").first << tag_xml
 569
 570     # try and upload it
 571     content way_xml
 572     put :update, :id => current_ways(:visible_way).id
 573     assert_response :forbidden,
 574                     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
 575
 576     ## Now try with the public user
 577     # setup auth
 578     basic_authorization(users(:public_user).email, "test")
 579
 580     # add an identical tag to the way
 581     tag_xml = XML::Node.new("tag")
 582     tag_xml["k"] = existing.k
 583     tag_xml["v"] = existing.v
 584
 585     # add the tag into the existing xml
 586     way_xml = current_ways(:visible_way).to_xml
 587     way_xml.find("//osm/way").first << tag_xml
 588
 589     # try and upload it
 590     content way_xml
 591     put :update, :id => current_ways(:visible_way).id
 592     assert_response :bad_request,
 593                     "adding a duplicate tag to a way should fail with 'bad request'"
 594     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{existing.k}", @response.body
 595   end
 596
 597   ##
 598   # Try adding a new duplicate tags to a way
 599   def test_new_duplicate_tags
 600     ## First test with the non-public user so should be rejected
 601     # setup auth
 602     basic_authorization(users(:normal_user).email, "test")
 603
 604     # create duplicate tag
 605     tag_xml = XML::Node.new("tag")
 606     tag_xml["k"] = "i_am_a_duplicate"
 607     tag_xml["v"] = "foobar"
 608
 609     # add the tag into the existing xml
 610     way_xml = current_ways(:visible_way).to_xml
 611
 612     # add two copies of the tag
 613     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
 614
 615     # try and upload it
 616     content way_xml
 617     put :update, :id => current_ways(:visible_way).id
 618     assert_response :forbidden,
 619                     "adding new duplicate tags to a way using a non-public user should fail with 'forbidden'"
 620
 621     ## Now test with the public user
 622     # setup auth
 623     basic_authorization(users(:public_user).email, "test")
 624
 625     # create duplicate tag
 626     tag_xml = XML::Node.new("tag")
 627     tag_xml["k"] = "i_am_a_duplicate"
 628     tag_xml["v"] = "foobar"
 629
 630     # add the tag into the existing xml
 631     way_xml = current_ways(:visible_way).to_xml
 632
 633     # add two copies of the tag
 634     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
 635
 636     # try and upload it
 637     content way_xml
 638     put :update, :id => current_ways(:visible_way).id
 639     assert_response :bad_request,
 640                     "adding new duplicate tags to a way should fail with 'bad request'"
 641     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate", @response.body
 642   end
 643
 644   ##
 645   # Try adding a new duplicate tags to a way.
 646   # But be a bit subtle - use unicode decoding ambiguities to use different
 647   # binary strings which have the same decoding.
 648   def test_invalid_duplicate_tags
 649     ## First make sure that you can't with a non-public user
 650     # setup auth
 651     basic_authorization(users(:normal_user).email, "test")
 652
 653     # add the tag into the existing xml
 654     way_str = "<osm><way changeset='1'>"
 655     way_str << "<tag k='addr:housenumber' v='1'/>"
 656     way_str << "<tag k='addr:housenumber' v='2'/>"
 657     way_str << "</way></osm>"
 658
 659     # try and upload it
 660     content way_str
 661     put :create
 662     assert_response :forbidden,
 663                     "adding new duplicate tags to a way with a non-public user should fail with 'forbidden'"
 664
 665     ## Now do it with a public user
 666     # setup auth
 667     basic_authorization(users(:public_user).email, "test")
 668
 669     # add the tag into the existing xml
 670     way_str = "<osm><way changeset='1'>"
 671     way_str << "<tag k='addr:housenumber' v='1'/>"
 672     way_str << "<tag k='addr:housenumber' v='2'/>"
 673     way_str << "</way></osm>"
 674
 675     # try and upload it
 676     content way_str
 677     put :create
 678     assert_response :bad_request,
 679                     "adding new duplicate tags to a way should fail with 'bad request'"
 680     assert_equal "Element way/ has duplicate tags with key addr:housenumber", @response.body
 681   end
 682
 683   ##
 684   # test that a call to ways_for_node returns all ways that contain the node
 685   # and none that don't.
 686   def test_ways_for_node
 687     # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4
 688     # *used* to use it but doesn't.
 689     get :ways_for_node, :id => current_nodes(:used_node_1).id
 690     assert_response :success
 691     ways_xml = XML::Parser.string(@response.body).parse
 692     assert_not_nil ways_xml, "failed to parse ways_for_node response"
 693
 694     # check that the set of IDs match expectations
 695     expected_way_ids = [current_ways(:visible_way).id,
 696                         current_ways(:used_way).id]
 697     found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
 698     assert_equal expected_way_ids.sort, found_way_ids.sort,
 699                  "expected ways for node #{current_nodes(:used_node_1).id} did not match found"
 700
 701     # check the full ways to ensure we're not missing anything
 702     expected_way_ids.each do |id|
 703       way_xml = ways_xml.find("//osm/way[@id='#{id}']").first
 704       assert_ways_are_equal(Way.find(id),
 705                             Way.from_xml_node(way_xml))
 706     end
 707   end
 708
 709   ##
 710   # update the changeset_id of a way element
 711   def update_changeset(xml, changeset_id)
 712     xml_attr_rewrite(xml, "changeset", changeset_id)
 713   end
 714
 715   ##
 716   # update an attribute in the way element
 717   def xml_attr_rewrite(xml, name, value)
 718     xml.find("//osm/way").first[name] = value.to_s
 719     xml
 720   end
 721
 722   ##
 723   # replace a node in a way element
 724   def xml_replace_node(xml, old_node, new_node)
 725     xml.find("//osm/way/nd[@ref='#{old_node}']").first["ref"] = new_node.to_s
 726     xml
 727   end
 728 end