X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/1f8a68371ad34594cce4aadf5fef229588fd4ddc..43e12e7d02307ad92cc51ebd09f4e88a466168aa:/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 6465c894d..01600c2d9 100644 --- a/test/functional/changeset_controller_test.rb +++ b/test/functional/changeset_controller_test.rb @@ -4,21 +4,21 @@ require 'changeset_controller' class ChangesetControllerTest < ActionController::TestCase api_fixtures - def basic_authorization(user, pass) - @request.env["HTTP_AUTHORIZATION"] = "Basic %s" % Base64.encode64("#{user}:#{pass}") - end - - def content(c) - @request.env["RAW_POST_DATA"] = c.to_s - end - # ----------------------- # Test simple changeset creation # ----------------------- def test_create - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:normal_user).email, "test" + # Create the first user's changeset + content "" + + "" + + "" + put :create + assert_require_public_data + + basic_authorization users(:public_user).email, "test" # Create the first user's changeset content "" + "" + @@ -42,12 +42,47 @@ class ChangesetControllerTest < ActionController::TestCase end def test_create_invalid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:normal_user).email, "test" + content "" + put :create + assert_require_public_data + + ## Try the public user + basic_authorization users(:public_user).email, "test" content "" put :create assert_response :bad_request, "creating a invalid changeset should fail" end + def test_create_invalid_no_content + ## First check with no auth + put :create + assert_response :unauthorized, "shouldn't be able to create a changeset with no auth" + + ## Now try to with the non-public user + basic_authorization users(:normal_user).email, "test" + put :create + assert_require_public_data + + ## Try the inactive user + basic_authorization users(:inactive_user).email, "test" + put :create + assert_inactive_user + + ## Now try to use the public user + basic_authorization users(:public_user).email, "test" + put :create + assert_response :bad_request, "creating a changeset with no content should fail" + end + + def test_create_wrong_method + basic_authorization users(:public_user).email, "test" + get :create + assert_response :method_not_allowed + post :create + assert_response :method_not_allowed + end + ## # check that the changeset can be read and returns the correct # document structure. @@ -60,49 +95,168 @@ class ChangesetControllerTest < ActionController::TestCase assert_select "osm>changeset[id=#{changeset_id}]", 1 end + ## + # check that a changeset that doesn't exist returns an appropriate message + def test_read_not_found + [0, -32, 233455644, "afg", "213"].each do |id| + get :read, :id => id + assert_response :not_found, "should get a not found" + end + end + ## # test that the user who opened a change can close it def test_close - basic_authorization "test@openstreetmap.org", "test" + ## Try without authentication + put :close, :id => changesets(:public_user_first_change).id + assert_response :unauthorized + + + ## Try using the non-public user + basic_authorization users(:normal_user).email, "test" + put :close, :id => changesets(:normal_user_first_change).id + assert_require_public_data + + + ## The try with the public user + basic_authorization users(:public_user).email, "test" - cs_id = changesets(:normal_user_first_change).id + cs_id = changesets(:public_user_first_change).id put :close, :id => cs_id assert_response :success # test that it really is closed now cs = Changeset.find(cs_id) assert(!cs.is_open?, - "changeset should be closed now (#{cs.closed_at} > #{Time.now}.") + "changeset should be closed now (#{cs.closed_at} > #{Time.now.getutc}.") end ## # test that a different user can't close another user's changeset def test_close_invalid - basic_authorization "test@example.com", "test" + basic_authorization users(:public_user).email, "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 + + ## + # test that you can't close using another method + def test_close_method_invalid + basic_authorization users(:public_user).email, "test" + + cs_id = changesets(:public_user_first_change).id + get :close, :id => cs_id + assert_response :method_not_allowed + + post :close, :id => cs_id + assert_response :method_not_allowed + end + + ## + # check that you can't close a changeset that isn't found + def test_close_not_found + cs_ids = [0, -132, "123"] + + # First try to do it with no auth + cs_ids.each do |id| + put :close, :id => id + assert_response :unauthorized, "Shouldn't be able close the non-existant changeset #{id}, when not authorized" + end + + # Now try with auth + basic_authorization users(:public_user).email, "test" + cs_ids.each do |id| + put :close, :id => id + assert_response :not_found, "The changeset #{id} doesn't exist, so can't be closed" + end + end ## # upload something simple, but valid and check that it can - # be read back ok. + # be read back ok + # Also try without auth and another user. def test_upload_simple_valid - basic_authorization "test@openstreetmap.org", "test" + ## Try with no auth + changeset_id = changesets(:public_user_first_change).id + + # simple diff to change a node, way and relation by removing + # their tags + diff = < + + + + + + + + + + + + + + +EOF + + # upload it + content diff + post :upload, :id => changeset_id + assert_response :unauthorized, + "shouldnn't be able to upload a simple valid diff to changeset: #{@response.body}" + + + + ## Now try with a private user + basic_authorization users(:normal_user).email, "test" + changeset_id = changesets(:normal_user_first_change).id + + # simple diff to change a node, way and relation by removing + # their tags + diff = < + + + + + + + + + + + + + + +EOF + + # upload it + content diff + post :upload, :id => changeset_id + assert_response :forbidden, + "can't upload a simple valid diff to changeset: #{@response.body}" + + + + ## Now try with the public user + basic_authorization users(:public_user).email, "test" + changeset_id = changesets(:public_user_first_change).id # simple diff to change a node, way and relation by removing # their tags diff = < - - + + - + @@ -113,7 +267,7 @@ EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => changeset_id assert_response :success, "can't upload a simple valid diff to changeset: #{@response.body}" @@ -126,22 +280,23 @@ EOF ## # upload something which creates new objects using placeholders def test_upload_create_valid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id # simple diff to create a node way and relation using placeholders diff = < - + - + - + @@ -152,7 +307,7 @@ EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => cs_id assert_response :success, "can't upload a simple valid creation to changeset: #{@response.body}" @@ -188,7 +343,7 @@ EOF # test a complex delete where we delete elements which rely on eachother # in the same transaction. def test_upload_delete - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).display_name, "test" diff = XML::Document.new diff.root = XML::Node.new "osmChange" @@ -199,9 +354,17 @@ EOF delete << current_ways(:used_way).to_xml_node delete << current_nodes(:node_used_by_relationship).to_xml_node + # update the changeset to one that this user owns + changeset_id = changesets(:public_user_first_change).id + ["node", "way", "relation"].each do |type| + delete.find("//osmChange/delete/#{type}").each do |n| + n['changeset'] = changeset_id.to_s + end + end + # upload it content diff - post :upload, :id => 1 + post :upload, :id => changeset_id assert_response :success, "can't upload a deletion diff to changeset: #{@response.body}" @@ -221,10 +384,10 @@ EOF # test uploading a delete with no lat/lon, as they are optional in # the osmChange spec. def test_upload_nolatlon_delete - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).display_name, "test" - node = current_nodes(:visible_node) - cs = changesets(:normal_user_first_change) + node = current_nodes(:public_visible_node) + cs = changesets(:public_user_first_change) diff = "" # upload it @@ -242,37 +405,91 @@ EOF def test_repeated_changeset_create 30.times do - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" # create a temporary changeset content "" + "" + "" - put :create + assert_difference('Changeset.count', 1) do + put :create + end assert_response :success changeset_id = @response.body.to_i end end + def test_upload_large_changeset + basic_authorization users(:public_user).email, "test" + + # create a changeset + content "" + put :create + assert_response :success, "Should be able to create a changeset: #{@response.body}" + changeset_id = @response.body.to_i + + # upload some widely-spaced nodes, spiralling positive and negative to cause + # largest bbox over-expansion possible. + diff = < + + + + + + + + + + + + + + + + + + + + + +EOF + + # upload it, which used to cause an error like "PGError: ERROR: + # integer out of range" (bug #2152). but shouldn't any more. + content diff + post :upload, :id => changeset_id + assert_response :success, + "can't upload a spatially-large diff to changeset: #{@response.body}" + + # check that the changeset bbox is within bounds + cs = Changeset.find(changeset_id) + assert cs.min_lon >= -180 * SCALE, "Minimum longitude (#{cs.min_lon / SCALE}) should be >= -180 to be valid." + assert cs.max_lon <= 180 * SCALE, "Maximum longitude (#{cs.max_lon / SCALE}) should be <= 180 to be valid." + assert cs.min_lat >= -90 * SCALE, "Minimum latitude (#{cs.min_lat / SCALE}) should be >= -90 to be valid." + assert cs.max_lat >= 90 * SCALE, "Maximum latitude (#{cs.max_lat / SCALE}) should be <= 90 to be valid." + end + ## # test that deleting stuff in a transaction doesn't bypass the checks # to ensure that used elements are not deleted. def test_upload_delete_invalid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" diff = XML::Document.new diff.root = XML::Node.new "osmChange" delete = XML::Node.new "delete" diff.root << delete - delete << current_relations(:visible_relation).to_xml_node + delete << current_relations(:public_visible_relation).to_xml_node delete << current_ways(:used_way).to_xml_node delete << current_nodes(:node_used_by_relationship).to_xml_node # upload it content diff - post :upload, :id => 1 + post :upload, :id => 2 assert_response :precondition_failed, "shouldn't be able to upload a invalid deletion diff: #{@response.body}" + assert_equal "Precondition failed: Way 3 still used by relation 1.", @response.body # check that nothing was, in fact, deleted assert_equal true, Node.find(current_nodes(:node_used_by_relationship).id).visible @@ -280,27 +497,103 @@ EOF assert_equal true, Relation.find(current_relations(:visible_relation).id).visible end + ## + # test that a conditional delete of an in use object works. + def test_upload_delete_if_unused + basic_authorization users(:public_user).email, "test" + + diff = XML::Document.new + diff.root = XML::Node.new "osmChange" + delete = XML::Node.new "delete" + diff.root << delete + delete["if-unused"] = "" + delete << current_relations(:public_used_relation).to_xml_node + delete << current_ways(:used_way).to_xml_node + delete << current_nodes(:node_used_by_relationship).to_xml_node + + # upload it + content diff + post :upload, :id => 2 + assert_response :success, + "can't do a conditional delete of in use objects: #{@response.body}" + + # check the returned payload + 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 + + # parse the response + doc = XML::Parser.string(@response.body).parse + + # check the old IDs are all present and what we expect + assert_equal current_nodes(:node_used_by_relationship).id, doc.find("//diffResult/node").first["old_id"].to_i + assert_equal current_ways(:used_way).id, doc.find("//diffResult/way").first["old_id"].to_i + assert_equal current_relations(:public_used_relation).id, doc.find("//diffResult/relation").first["old_id"].to_i + + # check the new IDs are all present and unchanged + assert_equal current_nodes(:node_used_by_relationship).id, doc.find("//diffResult/node").first["new_id"].to_i + assert_equal current_ways(:used_way).id, doc.find("//diffResult/way").first["new_id"].to_i + assert_equal current_relations(:public_used_relation).id, doc.find("//diffResult/relation").first["new_id"].to_i + + # check the new versions are all present and unchanged + assert_equal current_nodes(:node_used_by_relationship).version, doc.find("//diffResult/node").first["new_version"].to_i + assert_equal current_ways(:used_way).version, doc.find("//diffResult/way").first["new_version"].to_i + assert_equal current_relations(:public_used_relation).version, doc.find("//diffResult/relation").first["new_version"].to_i + + # check that nothing was, in fact, deleted + assert_equal true, Node.find(current_nodes(:node_used_by_relationship).id).visible + assert_equal true, Way.find(current_ways(:used_way).id).visible + assert_equal true, Relation.find(current_relations(:public_used_relation).id).visible + end + + ## + # upload an element with a really long tag value + def test_upload_invalid_too_long_tag + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id + + # simple diff to create a node way and relation using placeholders + diff = < + + + + + + +EOF + + # upload it + content diff + post :upload, :id => cs_id + assert_response :bad_request, + "shoudln't be able to upload too long a tag to changeset: #{@response.body}" + + end + ## # upload something which creates new objects and inserts them into # existing containers using placeholders. def test_upload_complex - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id # simple diff to create a node way and relation using placeholders diff = < - + - + - + @@ -311,7 +604,7 @@ EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => cs_id assert_response :success, "can't upload a complex diff to changeset: #{@response.body}" @@ -339,19 +632,20 @@ EOF # create a diff which references several changesets, which should cause # a rollback and none of the diff gets committed def test_upload_invalid_changesets - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id # simple diff to create a node way and relation using placeholders diff = < - - + + - + @@ -372,7 +666,7 @@ EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => cs_id assert_response :conflict, "uploading a diff with multiple changsets should have failed" @@ -384,7 +678,8 @@ EOF ## # upload multiple versions of the same element in the same diff. def test_upload_multiple_valid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id # change the location of a node multiple times, each time referencing # the last version. doesn't this depend on version numbers being @@ -392,21 +687,21 @@ EOF diff = < - - - - - - - - + + + + + + + + EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => cs_id assert_response :success, "can't upload multiple versions of an element in a diff: #{@response.body}" @@ -420,20 +715,21 @@ EOF # upload multiple versions of the same element in the same diff, but # keep the version numbers the same. def test_upload_multiple_duplicate - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id diff = < - - + + EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => cs_id assert_response :conflict, "shouldn't be able to upload the same element twice in a diff: #{@response.body}" end @@ -441,19 +737,20 @@ EOF ## # try to upload some elements without specifying the version def test_upload_missing_version - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id diff = < - + EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => cs_id assert_response :bad_request, "shouldn't be able to upload an element without version: #{@response.body}" end @@ -461,34 +758,36 @@ EOF ## # try to upload with commands other than create, modify, or delete def test_action_upload_invalid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + cs_id = changesets(:public_user_first_change).id diff = < - + EOF content diff - post :upload, :id => 1 + post :upload, :id => cs_id 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." + assert_equal @response.body, "Unknown action ping, choices are create, modify, delete" end ## # upload a valid changeset which has a mixture of whitespace # to check a bug reported by ivansanchez (#1565). def test_upload_whitespace_valid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + changeset_id = changesets(:public_user_first_change).id diff = < - - + - @@ -498,7 +797,7 @@ EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => changeset_id assert_response :success, "can't upload a valid diff with whitespace variations to changeset: #{@response.body}" @@ -515,27 +814,28 @@ EOF # upload a valid changeset which has a mixture of whitespace # to check a bug reported by ivansanchez. def test_upload_reuse_placeholder_valid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + changeset_id = changesets(:public_user_first_change).id diff = < - + - + - + EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => changeset_id assert_response :success, "can't upload a valid diff with re-used placeholders to changeset: #{@response.body}" @@ -548,30 +848,141 @@ EOF # test what happens if a diff upload re-uses placeholder IDs in an # illegal way. def test_upload_placeholder_invalid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" + changeset_id = changesets(:public_user_first_change).id diff = < - - - + + + EOF # upload it content diff - post :upload, :id => 1 + post :upload, :id => changeset_id assert_response :bad_request, "shouldn't be able to re-use placeholder IDs" end + ## + # test that uploading a way referencing invalid placeholders gives a + # proper error, not a 500. + def test_upload_placeholder_invalid_way + basic_authorization users(:public_user).email, "test" + changeset_id = changesets(:public_user_first_change).id + + diff = < + + + + + + + + + + + + +EOF + + # upload it + content diff + post :upload, :id => changeset_id + assert_response :bad_request, + "shouldn't be able to use invalid placeholder IDs" + assert_equal "Placeholder node not found for reference -4 in way -1", @response.body + + # the same again, but this time use an existing way + diff = < + + + + + + + + + + + + +EOF + + # upload it + content diff + post :upload, :id => changeset_id + assert_response :bad_request, + "shouldn't be able to use invalid placeholder IDs" + assert_equal "Placeholder node not found for reference -4 in way 1", @response.body + end + + ## + # test that uploading a relation referencing invalid placeholders gives a + # proper error, not a 500. + def test_upload_placeholder_invalid_relation + basic_authorization users(:public_user).email, "test" + changeset_id = changesets(:public_user_first_change).id + + diff = < + + + + + + + + + + + + +EOF + + # upload it + content diff + post :upload, :id => changeset_id + assert_response :bad_request, + "shouldn't be able to use invalid placeholder IDs" + assert_equal "Placeholder Node not found for reference -4 in relation -1.", @response.body + + # the same again, but this time use an existing way + diff = < + + + + + + + + + + + + +EOF + + # upload it + content diff + post :upload, :id => changeset_id + assert_response :bad_request, + "shouldn't be able to use invalid placeholder IDs" + assert_equal "Placeholder Way not found for reference -1 in relation 1.", @response.body + end + ## # test what happens if a diff is uploaded containing only a node # move. def test_upload_node_move - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" content "" + "" + @@ -609,7 +1020,7 @@ EOF ## # test what happens if a diff is uploaded adding a node to a way. def test_upload_way_extend - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" content "" + "" + @@ -648,7 +1059,7 @@ EOF ## # test for more issues in #1568 def test_upload_empty_invalid - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" [ "", "", @@ -657,18 +1068,57 @@ EOF ].each do |diff| # upload it content diff - post :upload, :id => 1 + post :upload, :id => changesets(:public_user_first_change).id assert_response(:success, "should be able to upload " + "empty changeset: " + diff) end end + ## + # test that the X-Error-Format header works to request XML errors + def test_upload_xml_errors + basic_authorization users(:public_user).email, "test" + + # try and delete a node that is in use + diff = XML::Document.new + diff.root = XML::Node.new "osmChange" + delete = XML::Node.new "delete" + diff.root << delete + delete << current_nodes(:node_used_by_relationship).to_xml_node + + # upload it + content diff + error_format "xml" + post :upload, :id => 2 + assert_response :success, + "failed to return error in XML format" + + # check the returned payload + assert_select "osmError[version=#{API_VERSION}][generator=\"OpenStreetMap server\"]", 1 + assert_select "osmError>status", 1 + assert_select "osmError>message", 1 + + end + ## # when we make some simple changes we get the same changes back from the # diff download. def test_diff_download_simple + ## First try with the normal user, which should get a forbidden basic_authorization(users(:normal_user).email, "test") + # create a temporary changeset + content "" + + "" + + "" + put :create + assert_response :forbidden + + + + ## Now try with the public user + basic_authorization(users(:public_user).email, "test") + # create a temporary changeset content "" + "" + @@ -713,7 +1163,7 @@ EOF # # NOTE: the error turned out to be something else completely! def test_josm_upload - basic_authorization(users(:normal_user).email, "test") + basic_authorization(users(:public_user).email, "test") # create a temporary changeset content "" + @@ -723,7 +1173,7 @@ EOF assert_response :success changeset_id = @response.body.to_i - diff = < @@ -750,7 +1200,7 @@ EOF -OSM +OSMFILE # upload it content diff @@ -772,7 +1222,7 @@ OSM # when we make some complex changes we get the same changes back from the # diff download. def test_diff_download_complex - basic_authorization(users(:normal_user).email, "test") + basic_authorization(users(:public_user).email, "test") # create a temporary changeset content "" + @@ -824,10 +1274,26 @@ EOF assert_select "osmChange>modify>way", 1 end + def test_changeset_download + get :download, :id => changesets(:normal_user_first_change).id + assert_response :success + assert_template nil + #print @response.body + # FIXME needs more assert_select tests + assert_select "osmChange[version='#{API_VERSION}'][generator='#{GENERATOR}']" do + assert_select "create", :count => 5 + assert_select "create>node[id=#{nodes(:used_node_2).id}][visible=#{nodes(:used_node_2).visible?}][version=#{nodes(:used_node_2).version}]" do + assert_select "tag[k=#{node_tags(:t3).k}][v=#{node_tags(:t3).v}]" + end + assert_select "create>node[id=#{nodes(:visible_node).id}]" + end + end + ## # check that the bounding box of a changeset gets updated correctly + ## FIXME: This should really be moded to a integration test due to the with_controller def test_changeset_bbox - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" # create a new changeset content "" @@ -886,7 +1352,7 @@ EOF ## # test that the changeset :include method works as it should def test_changeset_include - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).display_name, "test" # create a new changeset content "" @@ -904,6 +1370,37 @@ EOF check_after_include(changeset_id, -1, -1, [-1, -1, 4, 3]) check_after_include(changeset_id, -2, 5, [-2, -1, 4, 5]) end + + ## + # test that a not found, wrong method with the expand bbox works as expected + def test_changeset_expand_bbox_error + basic_authorization users(:public_user).display_name, "test" + + # create a new changeset + content "" + put :create + assert_response :success, "Creating of changeset failed." + changeset_id = @response.body.to_i + + lon=58.2 + lat=-0.45 + + # Try and put + content "" + put :expand_bbox, :id => changeset_id + assert_response :method_not_allowed, "shouldn't be able to put a bbox expand" + + # Try to get the update + content "" + get :expand_bbox, :id => changeset_id + assert_response :method_not_allowed, "shouldn't be able to get a bbox expand" + + # Try to use a hopefully missing changeset + content "" + post :expand_bbox, :id => changeset_id+13245 + assert_response :not_found, "shouldn't be able to do a bbox expand on a nonexistant changeset" + + end ## # test the query functionality of changesets @@ -916,19 +1413,35 @@ EOF assert_response :success, "can't get changesets in bbox" assert_changesets [1] + # not found when looking for changesets of non-existing users + get :query, :user => User.maximum(:id) + 1 + assert_response :not_found + get :query, :display_name => " " + assert_response :not_found + # 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" + assert_response :not_found, "shouldn't be able to get changesets by non-public user (ID)" + get :query, :display_name => users(:normal_user).display_name + assert_response :not_found, "shouldn't be able to get changesets by non-public user (name)" # 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,6] + assert_response :success, "can't get changesets by user ID" + assert_changesets [1,3,6] + + get :query, :display_name => users(:normal_user).display_name + assert_response :success, "can't get changesets by user name" + assert_changesets [1,3,6] + + # check that the correct error is given when we provide both UID and name + get :query, :user => users(:normal_user).id, :display_name => users(:normal_user).display_name + assert_response :bad_request, "should be a bad request to have both ID and name specified" get :query, :user => users(:normal_user).id, :open => true assert_response :success, "can't get changesets by user and open" - assert_changesets [1,4] + assert_changesets [1] get :query, :time => '2007-12-31' assert_response :success, "can't get changesets by time-since" @@ -940,11 +1453,23 @@ EOF 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,6] + assert_changesets [1,5,6] get :query, :open => 'true' assert_response :success, "can't get changesets by open-ness" assert_changesets [1,2,4] + + get :query, :closed => 'true' + assert_response :success, "can't get changesets by closed-ness" + assert_changesets [3,5,6,7] + + get :query, :closed => 'true', :user => users(:normal_user).id + assert_response :success, "can't get changesets by closed-ness and user" + assert_changesets [3,6] + + get :query, :closed => 'true', :user => users(:public_user).id + assert_response :success, "can't get changesets by closed-ness and user" + assert_changesets [7] end ## @@ -982,6 +1507,7 @@ EOF ## # check updating tags on a changeset def test_changeset_update + ## First try with the non-public user changeset = changesets(:normal_user_first_change) new_changeset = changeset.to_xml new_tag = XML::Node.new "tag" @@ -995,12 +1521,37 @@ EOF assert_response :unauthorized # try with the wrong authorization - basic_authorization "test@example.com", "test" + basic_authorization users(:public_user).email, "test" + put :update, :id => changeset.id + assert_response :conflict + + # now this should get an unauthorized + basic_authorization users(:normal_user).email, "test" + put :update, :id => changeset.id + assert_require_public_data "user with their data non-public, shouldn't be able to edit their changeset" + + + ## Now try with the public user + changeset = changesets(:public_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 + @request.env["HTTP_AUTHORIZATION"] = nil + put :update, :id => changeset.id + assert_response :unauthorized + + # try with the wrong authorization + basic_authorization users(:second_public_user).email, "test" put :update, :id => changeset.id assert_response :conflict # now this should work... - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" put :update, :id => changeset.id assert_response :success @@ -1013,7 +1564,7 @@ EOF # 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" + basic_authorization users(:public_user).email, "test" changeset = changesets(:normal_user_first_change) new_changeset = changeset.to_xml @@ -1029,8 +1580,9 @@ EOF ## # check that a changeset can contain a certain max number of changes. + ## FIXME should be changed to an integration test due to the with_controller def test_changeset_limits - basic_authorization "test@openstreetmap.org", "test" + basic_authorization users(:public_user).email, "test" # open a new changeset content "" @@ -1088,21 +1640,40 @@ EOF "element limit.") end + ## # This should display the last 20 changesets closed. def test_list - @changesets = Changeset.find(:all, :order => "created_at DESC", :conditions => ['min_lat IS NOT NULL'], :limit=> 20) - assert @changesets.size <= 20 - get :list + changesets = Changeset.find(:all, :order => "created_at DESC", :conditions => ['min_lat IS NOT NULL'], :limit=> 20) + assert changesets.size <= 20 + get :list, {:format => "html"} assert_response :success assert_template "list" # Now check that all 20 (or however many were returned) changesets are in the html - assert_select "h1", :text => "Recent Changes", :count => 1 - assert_select "table[id='keyvalue'] tr", :count => @changesets.size + 1 - @changesets.each do |changeset| + assert_select "h1", :text => "Changesets", :count => 1 + assert_select "table[id='changeset_list'] tr", :count => changesets.size + 1 + changesets.each do |changeset| # FIXME this test needs rewriting - test for table contents end end + ## + # Checks the display of the user changesets listing + def test_list_user + user = users(:public_user) + get :list, {:format => "html", :display_name => user.display_name} + assert_response :success + assert_template "changeset/_user" + ## FIXME need to add more checks to see which if edits are actually shown if your data is public + end + + ## + # Check the not found of the list user changesets + def test_list_user_not_found + get :list, {:format => "html", :display_name => "Some random user"} + assert_response :not_found + assert_template 'user/no_such_user' + end + #------------------------------------------------------------ # utility functions #------------------------------------------------------------