test/controllers/api/ways_controller_test.rb

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