X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/427becc1db048c05576887e74b26c4118fa32d77..acc5ffbe1ca930676ec0ec71592e2b37d9029ce6:/test/functional/changeset_controller_test.rb?ds=sidebyside diff --git a/test/functional/changeset_controller_test.rb b/test/functional/changeset_controller_test.rb index 5e26c2071..e8648e5c3 100644 --- a/test/functional/changeset_controller_test.rb +++ b/test/functional/changeset_controller_test.rb @@ -26,7 +26,19 @@ class ChangesetControllerTest < ActionController::TestCase put :create assert_response :success, "Creation of changeset did not return sucess status" - newid = @response.body + newid = @response.body.to_i + + # check end time, should be an hour ahead of creation time + cs = Changeset.find(newid) + duration = cs.closed_at - cs.created_at + # the difference can either be a rational, or a floating point number + # of seconds, depending on the code path taken :-( + if duration.class == Rational + assert_equal Rational(1,24), duration , "initial idle timeout should be an hour (#{cs.created_at} -> #{cs.closed_at})" + else + # must be number of seconds... + assert_equal 3600.0, duration , "initial idle timeout should be an hour (#{cs.created_at} -> #{cs.closed_at})" + end end def test_create_invalid @@ -36,12 +48,35 @@ class ChangesetControllerTest < ActionController::TestCase assert_response :bad_request, "creating a invalid changeset should fail" end + ## + # check that the changeset can be read and returns the correct + # document structure. def test_read + changeset_id = changesets(:normal_user_first_change).id + get :read, :id => changeset_id + assert_response :success, "cannot get first changeset" + assert_select "osm[version=#{API_VERSION}][generator=\"OpenStreetMap server\"]", 1 + assert_select "osm>changeset[id=#{changeset_id}]", 1 end + ## + # test that the user who opened a change can close it def test_close - + basic_authorization "test@openstreetmap.org", "test" + + put :close, :id => changesets(:normal_user_first_change).id + assert_response :success + end + + ## + # test that a different user can't close another user's changeset + def test_close_invalid + basic_authorization "test@example.com", "test" + + put :close, :id => changesets(:normal_user_first_change).id + assert_response :conflict + assert_equal "The user doesn't own that changeset", @response.body end ## @@ -116,26 +151,26 @@ EOF "can't upload a simple valid creation to changeset: #{@response.body}" # check the returned payload - assert_select "osm[version=#{API_VERSION}][generator=\"OpenStreetMap server\"]", 1 - assert_select "osm>node", 1 - assert_select "osm>way", 1 - assert_select "osm>relation", 1 + assert_select "diffResult[version=#{API_VERSION}][generator=\"OpenStreetMap server\"]", 1 + assert_select "diffResult>node", 1 + assert_select "diffresult>way", 1 + assert_select "diffResult>relation", 1 # inspect the response to find out what the new element IDs are doc = XML::Parser.string(@response.body).parse - new_node_id = doc.find("//osm/node").first["new_id"].to_i - new_way_id = doc.find("//osm/way").first["new_id"].to_i - new_rel_id = doc.find("//osm/relation").first["new_id"].to_i + new_node_id = doc.find("//diffResult/node").first["new_id"].to_i + new_way_id = doc.find("//diffResult/way").first["new_id"].to_i + new_rel_id = doc.find("//diffResult/relation").first["new_id"].to_i # check the old IDs are all present and negative one - assert_equal -1, doc.find("//osm/node").first["old_id"].to_i - assert_equal -1, doc.find("//osm/way").first["old_id"].to_i - assert_equal -1, doc.find("//osm/relation").first["old_id"].to_i + assert_equal -1, doc.find("//diffResult/node").first["old_id"].to_i + assert_equal -1, doc.find("//diffResult/way").first["old_id"].to_i + assert_equal -1, doc.find("//diffResult/relation").first["old_id"].to_i # check the versions are present and equal one - assert_equal 1, doc.find("//osm/node").first["new_version"].to_i - assert_equal 1, doc.find("//osm/way").first["new_version"].to_i - assert_equal 1, doc.find("//osm/relation").first["new_version"].to_i + assert_equal 1, doc.find("//diffResult/node").first["new_version"].to_i + assert_equal 1, doc.find("//diffResult/way").first["new_version"].to_i + assert_equal 1, doc.find("//diffResult/relation").first["new_version"].to_i # check that the changes made it into the database assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags" @@ -233,14 +268,14 @@ EOF "can't upload a complex diff to changeset: #{@response.body}" # check the returned payload - assert_select "osm[version=#{API_VERSION}][generator=\"OpenStreetMap server\"]", 1 - assert_select "osm>node", 1 - assert_select "osm>way", 1 - assert_select "osm>relation", 1 + assert_select "diffResult[version=#{API_VERSION}][generator=\"#{GENERATOR}\"]", 1 + assert_select "diffResult>node", 1 + assert_select "diffResult>way", 1 + assert_select "diffResult>relation", 1 # inspect the response to find out what the new element IDs are doc = XML::Parser.string(@response.body).parse - new_node_id = doc.find("//osm/node").first["new_id"].to_i + new_node_id = doc.find("//diffResult/node").first["new_id"].to_i # check that the changes made it into the database assert_equal 2, Node.find(new_node_id).tags.size, "new node should have two tags" @@ -275,7 +310,7 @@ EOF - + @@ -369,6 +404,24 @@ EOF assert_response :bad_request, "shouldn't be able to upload an element without version: #{@response.body}" end + + ## + # try to upload with commands other than create, modify, or delete + def test_action_upload_invalid + basic_authorization "test@openstreetmap.org", "test" + + diff = < + + + + +EOF + content diff + post :upload, :id => 1 + assert_response :bad_request, "Shouldn't be able to upload a diff with the action ping" + assert_equal @response.body, "Unknown action ping, choices are create, modify, delete." + end ## # when we make some simple changes we get the same changes back from the @@ -414,6 +467,67 @@ EOF assert_select "osmChange>modify>node", 8 end + ## + # culled this from josm to ensure that nothing in the way that josm + # is formatting the request is causing it to fail. + # + # NOTE: the error turned out to be something else completely! + def test_josm_upload + basic_authorization(users(:normal_user).email, "test") + + # create a temporary changeset + content "" + + "" + + "" + put :create + assert_response :success + changeset_id = @response.body.to_i + + diff = < + + + + + + + + + + + + + + + + + + + + + + + + + +OSM + + # upload it + content diff + post :upload, :id => changeset_id + assert_response :success, + "can't upload a diff from JOSM: #{@response.body}" + + get :download, :id => changeset_id + assert_response :success + + assert_select "osmChange", 1 + assert_select "osmChange>create>node", 9 + assert_select "osmChange>create>way", 1 + assert_select "osmChange>create>way>nd", 9 + assert_select "osmChange>create>way>tag", 2 + end + ## # when we make some complex changes we get the same changes back from the # diff download. @@ -469,5 +583,310 @@ EOF assert_select "osmChange>modify>node", 1 assert_select "osmChange>modify>way", 1 end + + ## + # check that the bounding box of a changeset gets updated correctly + def test_changeset_bbox + basic_authorization "test@openstreetmap.org", "test" + + # create a new changeset + content "" + put :create + assert_response :success, "Creating of changeset failed." + changeset_id = @response.body.to_i + + # add a single node to it + with_controller(NodeController.new) do + content "" + put :create + assert_response :success, "Couldn't create node." + end + + # get the bounding box back from the changeset + get :read, :id => changeset_id + assert_response :success, "Couldn't read back changeset." + assert_select "osm>changeset[min_lon=1.0]", 1 + assert_select "osm>changeset[max_lon=1.0]", 1 + assert_select "osm>changeset[min_lat=2.0]", 1 + assert_select "osm>changeset[max_lat=2.0]", 1 + + # add another node to it + with_controller(NodeController.new) do + content "" + put :create + assert_response :success, "Couldn't create second node." + end + + # get the bounding box back from the changeset + get :read, :id => changeset_id + assert_response :success, "Couldn't read back changeset for the second time." + assert_select "osm>changeset[min_lon=1.0]", 1 + assert_select "osm>changeset[max_lon=2.0]", 1 + assert_select "osm>changeset[min_lat=1.0]", 1 + assert_select "osm>changeset[max_lat=2.0]", 1 + + # add (delete) a way to it + with_controller(WayController.new) do + content update_changeset(current_ways(:visible_way).to_xml, + changeset_id) + put :delete, :id => current_ways(:visible_way).id + assert_response :success, "Couldn't delete a way." + end + + # get the bounding box back from the changeset + get :read, :id => changeset_id + assert_response :success, "Couldn't read back changeset for the third time." + assert_select "osm>changeset[min_lon=1.0]", 1 + assert_select "osm>changeset[max_lon=3.1]", 1 + assert_select "osm>changeset[min_lat=1.0]", 1 + assert_select "osm>changeset[max_lat=3.1]", 1 + end + + ## + # test that the changeset :include method works as it should + def test_changeset_include + basic_authorization "test@openstreetmap.org", "test" + + # create a new changeset + content "" + put :create + assert_response :success, "Creating of changeset failed." + changeset_id = @response.body.to_i + + # NOTE: the include method doesn't over-expand, like inserting + # a real method does. this is because we expect the client to + # know what it is doing! + check_after_include(changeset_id, 1, 1, [ 1, 1, 1, 1]) + check_after_include(changeset_id, 3, 3, [ 1, 1, 3, 3]) + check_after_include(changeset_id, 4, 2, [ 1, 1, 4, 3]) + check_after_include(changeset_id, 2, 2, [ 1, 1, 4, 3]) + check_after_include(changeset_id, -1, -1, [-1, -1, 4, 3]) + check_after_include(changeset_id, -2, 5, [-2, -1, 4, 5]) + end + + ## + # test the query functionality of changesets + def test_query + get :query, :bbox => "-10,-10, 10, 10" + assert_response :success, "can't get changesets in bbox" + assert_changesets [1,4] + + get :query, :bbox => "4.5,4.5,4.6,4.6" + assert_response :success, "can't get changesets in bbox" + assert_changesets [1] + + # can't get changesets of user 1 without authenticating + get :query, :user => users(:normal_user).id + assert_response :not_found, "shouldn't be able to get changesets by non-public user" + + # but this should work + basic_authorization "test@openstreetmap.org", "test" + get :query, :user => users(:normal_user).id + assert_response :success, "can't get changesets by user" + assert_changesets [1,3,4] + + get :query, :user => users(:normal_user).id, :open => true + assert_response :success, "can't get changesets by user and open" + assert_changesets [1,4] + + get :query, :time => '2007-12-31' + assert_response :success, "can't get changesets by time-since" + assert_changesets [1,2,4,5] + + get :query, :time => '2008-01-01T12:34Z' + assert_response :success, "can't get changesets by time-since with hour" + assert_changesets [1,2,4,5] + + get :query, :time => '2007-12-31T23:59Z,2008-01-01T00:01Z' + assert_response :success, "can't get changesets by time-range" + assert_changesets [1,4,5] + + get :query, :open => 'true' + assert_response :success, "can't get changesets by open-ness" + assert_changesets [1,2,4] + end + + ## + # check that errors are returned if garbage is inserted + # into query strings + def test_query_invalid + [ "abracadabra!", + "1,2,3,F", + ";drop table users;" + ].each do |bbox| + get :query, :bbox => bbox + assert_response :bad_request, "'#{bbox}' isn't a bbox" + end + + [ "now()", + "00-00-00", + ";drop table users;", + ",", + "-,-" + ].each do |time| + get :query, :time => time + assert_response :bad_request, "'#{time}' isn't a valid time range" + end + + [ "me", + "foobar", + "-1", + "0" + ].each do |uid| + get :query, :user => uid + assert_response :bad_request, "'#{uid}' isn't a valid user ID" + end + end + + ## + # check updating tags on a changeset + def test_changeset_update + changeset = changesets(:normal_user_first_change) + new_changeset = changeset.to_xml + new_tag = XML::Node.new "tag" + new_tag['k'] = "tagtesting" + new_tag['v'] = "valuetesting" + new_changeset.find("//osm/changeset").first << new_tag + content new_changeset + + # try without any authorization + put :update, :id => changeset.id + assert_response :unauthorized + + # try with the wrong authorization + basic_authorization "test@example.com", "test" + put :update, :id => changeset.id + assert_response :conflict + + # now this should work... + basic_authorization "test@openstreetmap.org", "test" + put :update, :id => changeset.id + assert_response :success + + assert_select "osm>changeset[id=#{changeset.id}]", 1 + assert_select "osm>changeset>tag", 2 + assert_select "osm>changeset>tag[k=tagtesting][v=valuetesting]", 1 + end + + ## + # check that a user different from the one who opened the changeset + # can't modify it. + def test_changeset_update_invalid + basic_authorization "test@example.com", "test" + + changeset = changesets(:normal_user_first_change) + new_changeset = changeset.to_xml + new_tag = XML::Node.new "tag" + new_tag['k'] = "testing" + new_tag['v'] = "testing" + new_changeset.find("//osm/changeset").first << new_tag + + content new_changeset + put :update, :id => changeset.id + assert_response :conflict + end + + ## + # check that a changeset can contain a certain max number of changes. + def test_changeset_limits + basic_authorization "test@openstreetmap.org", "test" + + # open a new changeset + content "" + put :create + assert_response :success, "can't create a new changeset" + cs_id = @response.body.to_i + + # start the counter just short of where the changeset should finish. + offset = 10 + # alter the database to set the counter on the changeset directly, + # otherwise it takes about 6 minutes to fill all of them. + changeset = Changeset.find(cs_id) + changeset.num_changes = Changeset::MAX_ELEMENTS - offset + changeset.save! + + with_controller(NodeController.new) do + # create a new node + content "" + put :create + assert_response :success, "can't create a new node" + node_id = @response.body.to_i + + get :read, :id => node_id + assert_response :success, "can't read back new node" + node_doc = XML::Parser.string(@response.body).parse + node_xml = node_doc.find("//osm/node").first + + # loop until we fill the changeset with nodes + offset.times do |i| + node_xml['lat'] = rand.to_s + node_xml['lon'] = rand.to_s + node_xml['version'] = (i+1).to_s + + content node_doc + put :update, :id => node_id + assert_response :success, "attempt #{i} should have succeeded" + end + + # trying again should fail + node_xml['lat'] = rand.to_s + node_xml['lon'] = rand.to_s + node_xml['version'] = offset.to_s + + content node_doc + put :update, :id => node_id + assert_response :conflict, "final attempt should have failed" + end + + changeset = Changeset.find(cs_id) + assert_equal Changeset::MAX_ELEMENTS + 1, changeset.num_changes + end + #------------------------------------------------------------ + # utility functions + #------------------------------------------------------------ + + ## + # boilerplate for checking that certain changesets exist in the + # output. + def assert_changesets(ids) + assert_select "osm>changeset", ids.size + ids.each do |id| + assert_select "osm>changeset[id=#{id}]", 1 + end + end + + ## + # call the include method and assert properties of the bbox + def check_after_include(changeset_id, lon, lat, bbox) + content "" + post :expand_bbox, :id => changeset_id + assert_response :success, "Setting include of changeset failed: #{@response.body}" + + # check exactly one changeset + assert_select "osm>changeset", 1 + assert_select "osm>changeset[id=#{changeset_id}]", 1 + + # check the bbox + doc = XML::Parser.string(@response.body).parse + changeset = doc.find("//osm/changeset").first + assert_equal bbox[0], changeset['min_lon'].to_f, "min lon" + assert_equal bbox[1], changeset['min_lat'].to_f, "min lat" + assert_equal bbox[2], changeset['max_lon'].to_f, "max lon" + assert_equal bbox[3], changeset['max_lat'].to_f, "max lat" + end + + ## + # update the changeset_id of a way element + def update_changeset(xml, changeset_id) + xml_attr_rewrite(xml, 'changeset', changeset_id) + end + + ## + # update an attribute in a way element + def xml_attr_rewrite(xml, name, value) + xml.find("//osm/way").first[name] = value.to_s + return xml + end + end