X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/3549d8900fae286019f9a4ad89d860e4eda76fb6..e13b35e0cbf6b1c0ec429ed61ee6b9d8c4de176c:/test/functional/way_controller_test.rb diff --git a/test/functional/way_controller_test.rb b/test/functional/way_controller_test.rb index 58bb6a9a1..895e7532f 100644 --- a/test/functional/way_controller_test.rb +++ b/test/functional/way_controller_test.rb @@ -37,21 +37,11 @@ class WayControllerTest < Test::Unit::TestCase # check chat a non-existent way is not returned get :read, :id => 0 assert_response :not_found + end - # check the "ways for node" mode - get :ways_for_node, :id => current_nodes(:used_node_1).id - assert_response :success - # FIXME check whether this contains the stuff we want! - #print @response.body - # Needs to be updated when changing fixtures - # The generator should probably be defined in the environment.rb file - # in the same place as the api version - assert_select "osm[version=#{API_VERSION}][generator=\"OpenStreetMap server\"]", 1 - assert_select "osm way", 3 - assert_select "osm way nd", 3 - assert_select "osm way tag", 3 - - # check the "full" mode + ## + # check the "full" mode + def test_full get :full, :id => current_ways(:visible_way).id assert_response :success # FIXME check whether this contains the stuff we want! @@ -165,20 +155,168 @@ class WayControllerTest < Test::Unit::TestCase delete :delete, :id => current_ways(:visible_way).id assert_response :bad_request - # Now try and get a changeset - changeset_id = changesets(:normal_user_first_change).id + # try to delete with an invalid (closed) changeset + content update_changeset(current_ways(:visible_way).to_xml, + changesets(:normal_user_closed_change).id) + delete :delete, :id => current_ways(:visible_way).id + assert_response :conflict + + # try to delete with an invalid (non-existent) changeset + content update_changeset(current_ways(:visible_way).to_xml,0) + delete :delete, :id => current_ways(:visible_way).id + assert_response :conflict + + # Now try with a valid changeset content current_ways(:visible_way).to_xml delete :delete, :id => current_ways(:visible_way).id assert_response :success + # check the returned value - should be the new version number + # valid delete should return the new version number, which should + # be greater than the old version number + assert @response.body.to_i > current_ways(:visible_way).version, + "delete request should return a new version number for way" + # this won't work since the way is already deleted content current_ways(:invisible_way).to_xml delete :delete, :id => current_ways(:invisible_way).id assert_response :gone + # this shouldn't work as the way is used in a relation + content current_ways(:used_way).to_xml + delete :delete, :id => current_ways(:used_way).id + assert_response :precondition_failed, + "shouldn't be able to delete a way used in a relation (#{@response.body})" + # this won't work since the way never existed delete :delete, :id => 0 assert_response :not_found end + # ------------------------------------------------------------ + # test tags handling + # ------------------------------------------------------------ + + ## + # Try adding a duplicate of an existing tag to a way + def test_add_duplicate_tags + # setup auth + basic_authorization(users(:normal_user).email, "test") + + # add an identical tag to the way + tag_xml = XML::Node.new("tag") + tag_xml['k'] = current_way_tags(:t1).k + tag_xml['v'] = current_way_tags(:t1).v + + # add the tag into the existing xml + way_xml = current_ways(:visible_way).to_xml + way_xml.find("//osm/way").first << tag_xml + + # try and upload it + content way_xml + put :update, :id => current_ways(:visible_way).id + assert_response :bad_request, + "adding a duplicate tag to a way should fail with 'bad request'" + end + + ## + # Try adding a new duplicate tags to a way + def test_new_duplicate_tags + # setup auth + basic_authorization(users(:normal_user).email, "test") + + # create duplicate tag + tag_xml = XML::Node.new("tag") + tag_xml['k'] = "i_am_a_duplicate" + tag_xml['v'] = "foobar" + + # add the tag into the existing xml + way_xml = current_ways(:visible_way).to_xml + + # add two copies of the tag + way_xml.find("//osm/way").first << tag_xml.copy(true) << tag_xml + + # try and upload it + content way_xml + put :update, :id => current_ways(:visible_way).id + assert_response :bad_request, + "adding new duplicate tags to a way should fail with 'bad request'" + end + + ## + # Try adding a new duplicate tags to a way. + # But be a bit subtle - use unicode decoding ambiguities to use different + # binary strings which have the same decoding. + # + # NOTE: I'm not sure this test is working correctly, as a lot of the tag + # keys seem to come out as "addr��housenumber". It might be something to + # do with Ruby's unicode handling...? + def test_invalid_duplicate_tags + # setup auth + basic_authorization(users(:normal_user).email, "test") + + # add the tag into the existing xml + way_str = "" + way_str << "" + + # all of these keys have the same unicode decoding, but are binary + # not equal. libxml should make these identical as it decodes the + # XML document... + [ "addr\xc0\xbahousenumber", + "addr\xe0\x80\xbahousenumber", + "addr\xf0\x80\x80\xbahousenumber" ].each do |key| + # copy the XML doc to add the tags + way_str_copy = way_str.clone + + # add all new tags to the way + way_str_copy << "" + way_str_copy << ""; + + # try and upload it + content way_str_copy + put :create + assert_response :bad_request, + "adding new duplicate tags to a way should fail with 'bad request'" + end + end + + ## + # test that a call to ways_for_node returns all ways that contain the node + # and none that don't. + def test_ways_for_node + # in current fixtures ways 1 and 3 all use node 3. ways 2 and 4 + # *used* to use it but doesn't. + get :ways_for_node, :id => current_nodes(:used_node_1).id + assert_response :success + ways_xml = XML::Parser.string(@response.body).parse + assert_not_nil ways_xml, "failed to parse ways_for_node response" + + # check that the set of IDs match expectations + expected_way_ids = [ current_ways(:visible_way).id, + current_ways(:used_way).id + ] + found_way_ids = ways_xml.find("//osm/way").collect { |w| w["id"].to_i } + assert_equal expected_way_ids, found_way_ids, + "expected ways for node #{current_nodes(:used_node_1).id} did not match found" + + # check the full ways to ensure we're not missing anything + expected_way_ids.each do |id| + way_xml = ways_xml.find("//osm/way[@id=#{id}]").first + assert_ways_are_equal(Way.find(id), + Way.from_xml_node(way_xml)) + end + end + + ## + # update the changeset_id of a node element + def update_changeset(xml, changeset_id) + xml_attr_rewrite(xml, 'changeset', changeset_id) + end + + ## + # update an attribute in the node element + def xml_attr_rewrite(xml, name, value) + xml.find("//osm/way").first[name] = value.to_s + return xml + end end