test/functional/way_controller_test.rb

   1 require File.dirname(__FILE__) + '/../test_helper'
   2 require 'way_controller'
   3
   4 class WayControllerTest < ActionController::TestCase
   5   api_fixtures
   6
   7   # -------------------------------------
   8   # Test reading ways.
   9   # -------------------------------------
  10
  11   def test_read
  12     # check that a visible way is returned properly
  13     get :read, :id => current_ways(:visible_way).id
  14     assert_response :success
  15
  16     # check that an invisible way is not returned
  17     get :read, :id => current_ways(:invisible_way).id
  18     assert_response :gone
  19
  20     # check chat a non-existent way is not returned
  21     get :read, :id => 0
  22     assert_response :not_found
  23   end
  24
  25   ##
  26   # check the "full" mode
  27   def test_full
  28     Way.find(:all).each do |way|
  29       get :full, :id => way.id
  30
  31       # full call should say "gone" for non-visible ways...
  32       unless way.visible
  33         assert_response :gone
  34         next
  35       end
  36
  37       # otherwise it should say success
  38       assert_response :success
  39
  40       # Check the way is correctly returned
  41       assert_select "osm way[id=#{way.id}][version=#{way.version}][visible=#{way.visible}]", 1
  42
  43       # check that each node in the way appears once in the output as a
  44       # reference and as the node element. note the slightly dodgy assumption
  45       # that nodes appear only once. this is currently the case with the
  46       # fixtures, but it doesn't have to be.
  47       way.nodes.each do |n|
  48         assert_select "osm way nd[ref=#{n.id}]", 1
  49         assert_select "osm node[id=#{n.id}][version=#{n.version}][lat=#{n.lat}][lon=#{n.lon}]", 1
  50       end
  51     end
  52   end
  53
  54   # -------------------------------------
  55   # Test simple way creation.
  56   # -------------------------------------
  57
  58   def test_create
  59     ## First check that it fails when creating a way using a non-public user
  60     nid1 = current_nodes(:used_node_1).id
  61     nid2 = current_nodes(:used_node_2).id
  62     basic_authorization users(:normal_user).email, "test"
  63
  64     # use the first user's open changeset
  65     changeset_id = changesets(:normal_user_first_change).id
  66
  67     # create a way with pre-existing nodes
  68     content "<osm><way changeset='#{changeset_id}'>" +
  69       "<nd ref='#{nid1}'/><nd ref='#{nid2}'/>" +
  70       "<tag k='test' v='yes' /></way></osm>"
  71     put :create
  72     # hope for success
  73     assert_response :forbidden,
  74         "way upload did not return success status"
  75     # read id of created way and search for it
  76     wayid = @response.body
  77
  78     ## Now use a public user
  79     nid1 = current_nodes(:used_node_1).id
  80     nid2 = current_nodes(:used_node_2).id
  81     basic_authorization users(:public_user).email, "test"
  82
  83     # use the first user's open changeset
  84     changeset_id = changesets(:public_user_first_change).id
  85
  86     # create a way with pre-existing nodes
  87     content "<osm><way changeset='#{changeset_id}'>" +
  88       "<nd ref='#{nid1}'/><nd ref='#{nid2}'/>" +
  89       "<tag k='test' v='yes' /></way></osm>"
  90     put :create
  91     # hope for success
  92     assert_response :success,
  93         "way upload did not return success status"
  94     # read id of created way and search for it
  95     wayid = @response.body
  96     checkway = Way.find(wayid)
  97     assert_not_nil checkway,
  98         "uploaded way not found in data base after upload"
  99     # compare values
 100     assert_equal checkway.nds.length, 2,
 101         "saved way does not contain exactly one node"
 102     assert_equal checkway.nds[0], nid1,
 103         "saved way does not contain the right node on pos 0"
 104     assert_equal checkway.nds[1], nid2,
 105         "saved way does not contain the right node on pos 1"
 106     assert_equal checkway.changeset_id, changeset_id,
 107         "saved way does not belong to the correct changeset"
 108     assert_equal users(:public_user).id, checkway.changeset.user_id,
 109         "saved way does not belong to user that created it"
 110     assert_equal true, checkway.visible,
 111         "saved way is not visible"
 112   end
 113
 114   # -------------------------------------
 115   # Test creating some invalid ways.
 116   # -------------------------------------
 117
 118   def test_create_invalid
 119     ## First test with a private user to make sure that they are not authorized
 120     basic_authorization users(:normal_user).email, "test"
 121
 122     # use the first user's open changeset
 123     open_changeset_id = changesets(:normal_user_first_change).id
 124     closed_changeset_id = changesets(:normal_user_closed_change).id
 125     nid1 = current_nodes(:used_node_1).id
 126
 127     # create a way with non-existing node
 128     content "<osm><way changeset='#{open_changeset_id}'>" +
 129       "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
 130     put :create
 131     # expect failure
 132     assert_response :forbidden,
 133     "way upload with invalid node using a private user did not return 'forbidden'"
 134
 135     # create a way with no nodes
 136     content "<osm><way changeset='#{open_changeset_id}'>" +
 137       "<tag k='test' v='yes' /></way></osm>"
 138     put :create
 139     # expect failure
 140     assert_response :forbidden,
 141     "way upload with no node using a private userdid not return 'forbidden'"
 142
 143     # create a way inside a closed changeset
 144     content "<osm><way changeset='#{closed_changeset_id}'>" +
 145       "<nd ref='#{nid1}'/></way></osm>"
 146     put :create
 147     # expect failure
 148     assert_response :forbidden,
 149     "way upload to closed changeset with a private user did not return 'forbidden'"
 150
 151
 152     ## Now test with a public user
 153     basic_authorization users(:public_user).email, "test"
 154
 155     # use the first user's open changeset
 156     open_changeset_id = changesets(:public_user_first_change).id
 157     closed_changeset_id = changesets(:public_user_closed_change).id
 158     nid1 = current_nodes(:used_node_1).id
 159
 160     # create a way with non-existing node
 161     content "<osm><way changeset='#{open_changeset_id}'>" +
 162       "<nd ref='0'/><tag k='test' v='yes' /></way></osm>"
 163     put :create
 164     # expect failure
 165     assert_response :precondition_failed,
 166         "way upload with invalid node did not return 'precondition failed'"
 167     assert_equal "Precondition failed: Way  requires the node with id 0, which either does not exist, or is not visible.", @response.body
 168
 169     # create a way with no nodes
 170     content "<osm><way changeset='#{open_changeset_id}'>" +
 171       "<tag k='test' v='yes' /></way></osm>"
 172     put :create
 173     # expect failure
 174     assert_response :precondition_failed,
 175         "way upload with no node did not return 'precondition failed'"
 176     assert_equal "Precondition failed: Cannot create way: data is invalid.", @response.body
 177
 178     # create a way inside a closed changeset
 179     content "<osm><way changeset='#{closed_changeset_id}'>" +
 180       "<nd ref='#{nid1}'/></way></osm>"
 181     put :create
 182     # expect failure
 183     assert_response :conflict,
 184         "way upload to closed changeset did not return 'conflict'"
 185   end
 186
 187   # -------------------------------------
 188   # Test deleting ways.
 189   # -------------------------------------
 190
 191   def test_delete
 192     # first try to delete way without auth
 193     delete :delete, :id => current_ways(:visible_way).id
 194     assert_response :unauthorized
 195
 196     # now set auth using the private user
 197     basic_authorization(users(:normal_user).email, "test");
 198
 199     # this shouldn't work as with the 0.6 api we need pay load to delete
 200     delete :delete, :id => current_ways(:visible_way).id
 201     assert_response :forbidden
 202
 203     # Now try without having a changeset
 204     content "<osm><way id='#{current_ways(:visible_way).id}'></osm>"
 205     delete :delete, :id => current_ways(:visible_way).id
 206     assert_response :forbidden
 207
 208     # try to delete with an invalid (closed) changeset
 209     content update_changeset(current_ways(:visible_way).to_xml,
 210                              changesets(:normal_user_closed_change).id)
 211     delete :delete, :id => current_ways(:visible_way).id
 212     assert_response :forbidden
 213
 214     # try to delete with an invalid (non-existent) changeset
 215     content update_changeset(current_ways(:visible_way).to_xml,0)
 216     delete :delete, :id => current_ways(:visible_way).id
 217     assert_response :forbidden
 218
 219     # Now try with a valid changeset
 220     content current_ways(:visible_way).to_xml
 221     delete :delete, :id => current_ways(:visible_way).id
 222     assert_response :forbidden
 223
 224     # check the returned value - should be the new version number
 225     # valid delete should return the new version number, which should
 226     # be greater than the old version number
 227     #assert @response.body.to_i > current_ways(:visible_way).version,
 228     #   "delete request should return a new version number for way"
 229
 230     # this won't work since the way is already deleted
 231     content current_ways(:invisible_way).to_xml
 232     delete :delete, :id => current_ways(:invisible_way).id
 233     assert_response :forbidden
 234
 235     # this shouldn't work as the way is used in a relation
 236     content current_ways(:used_way).to_xml
 237     delete :delete, :id => current_ways(:used_way).id
 238     assert_response :forbidden,
 239     "shouldn't be able to delete a way used in a relation (#{@response.body}), when done by a private user"
 240
 241     # this won't work since the way never existed
 242     delete :delete, :id => 0
 243     assert_response :forbidden
 244
 245
 246     ### Now check with a public user
 247     # now set auth
 248     basic_authorization(users(:public_user).email, "test");
 249
 250     # this shouldn't work as with the 0.6 api we need pay load to delete
 251     delete :delete, :id => current_ways(:visible_way).id
 252     assert_response :bad_request
 253
 254     # Now try without having a changeset
 255     content "<osm><way id='#{current_ways(:visible_way).id}'></osm>"
 256     delete :delete, :id => current_ways(:visible_way).id
 257     assert_response :bad_request
 258
 259     # try to delete with an invalid (closed) changeset
 260     content update_changeset(current_ways(:visible_way).to_xml,
 261                              changesets(:public_user_closed_change).id)
 262     delete :delete, :id => current_ways(:visible_way).id
 263     assert_response :conflict
 264
 265     # try to delete with an invalid (non-existent) changeset
 266     content update_changeset(current_ways(:visible_way).to_xml,0)
 267     delete :delete, :id => current_ways(:visible_way).id
 268     assert_response :conflict
 269
 270     # Now try with a valid changeset
 271     content current_ways(:visible_way).to_xml
 272     delete :delete, :id => current_ways(:visible_way).id
 273     assert_response :success
 274
 275     # check the returned value - should be the new version number
 276     # valid delete should return the new version number, which should
 277     # be greater than the old version number
 278     assert @response.body.to_i > current_ways(:visible_way).version,
 279        "delete request should return a new version number for way"
 280
 281     # this won't work since the way is already deleted
 282     content current_ways(:invisible_way).to_xml
 283     delete :delete, :id => current_ways(:invisible_way).id
 284     assert_response :gone
 285
 286     # this shouldn't work as the way is used in a relation
 287     content current_ways(:used_way).to_xml
 288     delete :delete, :id => current_ways(:used_way).id
 289     assert_response :precondition_failed,
 290        "shouldn't be able to delete a way used in a relation (#{@response.body})"
 291     assert_equal "Precondition failed: Way 3 still used by relation 1.", @response.body
 292
 293     # this won't work since the way never existed
 294     delete :delete, :id => 0
 295     assert_response :not_found
 296   end
 297
 298   # ------------------------------------------------------------
 299   # test tags handling
 300   # ------------------------------------------------------------
 301
 302   ##
 303   # Try adding a duplicate of an existing tag to a way
 304   def test_add_duplicate_tags
 305     ## Try with the non-public user
 306     # setup auth
 307     basic_authorization(users(:normal_user).email, "test")
 308
 309     # add an identical tag to the way
 310     tag_xml = XML::Node.new("tag")
 311     tag_xml['k'] = current_way_tags(:t1).k
 312     tag_xml['v'] = current_way_tags(:t1).v
 313
 314     # add the tag into the existing xml
 315     way_xml = current_ways(:visible_way).to_xml
 316     way_xml.find("//osm/way").first << tag_xml
 317
 318     # try and upload it
 319     content way_xml
 320     put :update, :id => current_ways(:visible_way).id
 321     assert_response :forbidden,
 322     "adding a duplicate tag to a way for a non-public should fail with 'forbidden'"
 323
 324     ## Now try with the public user
 325     # setup auth
 326     basic_authorization(users(:public_user).email, "test")
 327
 328     # add an identical tag to the way
 329     tag_xml = XML::Node.new("tag")
 330     tag_xml['k'] = current_way_tags(:t1).k
 331     tag_xml['v'] = current_way_tags(:t1).v
 332
 333     # add the tag into the existing xml
 334     way_xml = current_ways(:visible_way).to_xml
 335     way_xml.find("//osm/way").first << tag_xml
 336
 337     # try and upload it
 338     content way_xml
 339     put :update, :id => current_ways(:visible_way).id
 340     assert_response :bad_request,
 341        "adding a duplicate tag to a way should fail with 'bad request'"
 342     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key #{current_way_tags(:t1).k}.", @response.body
 343   end
 344
 345   ##
 346   # Try adding a new duplicate tags to a way
 347   def test_new_duplicate_tags
 348     ## First test with the non-public user so should be rejected
 349     # setup auth
 350     basic_authorization(users(:normal_user).email, "test")
 351
 352     # create duplicate tag
 353     tag_xml = XML::Node.new("tag")
 354     tag_xml['k'] = "i_am_a_duplicate"
 355     tag_xml['v'] = "foobar"
 356
 357     # add the tag into the existing xml
 358     way_xml = current_ways(:visible_way).to_xml
 359
 360     # add two copies of the tag
 361     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
 362
 363     # try and upload it
 364     content way_xml
 365     put :update, :id => current_ways(:visible_way).id
 366     assert_response :forbidden,
 367     "adding new duplicate tags to a way using a non-public user should fail with 'forbidden'"
 368
 369     ## Now test with the public user
 370     # setup auth
 371     basic_authorization(users(:public_user).email, "test")
 372
 373     # create duplicate tag
 374     tag_xml = XML::Node.new("tag")
 375     tag_xml['k'] = "i_am_a_duplicate"
 376     tag_xml['v'] = "foobar"
 377
 378     # add the tag into the existing xml
 379     way_xml = current_ways(:visible_way).to_xml
 380
 381     # add two copies of the tag
 382     way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml
 383
 384     # try and upload it
 385     content way_xml
 386     put :update, :id => current_ways(:visible_way).id
 387     assert_response :bad_request,
 388        "adding new duplicate tags to a way should fail with 'bad request'"
 389     assert_equal "Element way/#{current_ways(:visible_way).id} has duplicate tags with key i_am_a_duplicate.", @response.body
 390
 391   end
 392
 393   ##
 394   # Try adding a new duplicate tags to a way.
 395   # But be a bit subtle - use unicode decoding ambiguities to use different
 396   # binary strings which have the same decoding.
 397   def test_invalid_duplicate_tags
 398     ## First make sure that you can't with a non-public user
 399     # setup auth
 400     basic_authorization(users(:normal_user).email, "test")
 401
 402     # add the tag into the existing xml
 403     way_str = "<osm><way changeset='1'>"
 404     way_str << "<tag k='addr:housenumber' v='1'/>"
 405     way_str << "<tag k='addr:housenumber' v='2'/>"
 406     way_str << "</way></osm>";
 407
 408     # try and upload it
 409     content way_str
 410     put :create
 411     assert_response :forbidden,
 412     "adding new duplicate tags to a way with a non-public user should fail with 'forbidden'"
 413
 414     ## Now do it with a public user
 415     # setup auth
 416     basic_authorization(users(:public_user).email, "test")
 417
 418     # add the tag into the existing xml
 419     way_str = "<osm><way changeset='1'>"
 420     way_str << "<tag k='addr:housenumber' v='1'/>"
 421     way_str << "<tag k='addr:housenumber' v='2'/>"
 422     way_str << "</way></osm>";
 423
 424     # try and upload it
 425     content way_str
 426     put :create
 427     assert_response :bad_request,
 428     "adding new duplicate tags to a way should fail with 'bad request'"
 429     assert_equal "Element way/ has duplicate tags with key addr:housenumber.", @response.body
 430   end
 431
 432   ##
 433   # test that a call to ways_for_node returns all ways that contain the node
 434   # and none that don't.
 435   def test_ways_for_node
 436     # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4
 437     # *used* to use it but doesn't.
 438     get :ways_for_node, :id => current_nodes(:used_node_1).id
 439     assert_response :success
 440     ways_xml = XML::Parser.string(@response.body).parse
 441     assert_not_nil ways_xml, "failed to parse ways_for_node response"
 442
 443     # check that the set of IDs match expectations
 444     expected_way_ids = [ current_ways(:visible_way).id,
 445                          current_ways(:used_way).id
 446                        ]
 447     found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i }
 448     assert_equal expected_way_ids, found_way_ids,
 449       "expected ways for node #{current_nodes(:used_node_1).id} did not match found"
 450
 451     # check the full ways to ensure we're not missing anything
 452     expected_way_ids.each do |id|
 453       way_xml = ways_xml.find("//osm/way[@id=#{id}]").first
 454       assert_ways_are_equal(Way.find(id),
 455                             Way.from_xml_node(way_xml))
 456     end
 457   end
 458
 459   ##
 460   # update the changeset_id of a node element
 461   def update_changeset(xml, changeset_id)
 462     xml_attr_rewrite(xml, 'changeset', changeset_id)
 463   end
 464
 465   ##
 466   # update an attribute in the node element
 467   def xml_attr_rewrite(xml, name, value)
 468     xml.find("//osm/way").first[name] = value.to_s
 469     return xml
 470   end
 471 end