X-Git-Url: https://git.openstreetmap.org./rails.git/blobdiff_plain/dcca3ab0e9fad052e884e5df715ba2391020f0cc..2a3bc0a38789b29b8798eafd80fc4fb77c5c7957:/test/functional/changeset_controller_test.rb diff --git a/test/functional/changeset_controller_test.rb b/test/functional/changeset_controller_test.rb index 018e5af23..9ed9f2959 100644 --- a/test/functional/changeset_controller_test.rb +++ b/test/functional/changeset_controller_test.rb @@ -4,6 +4,79 @@ require 'changeset_controller' class ChangesetControllerTest < ActionController::TestCase api_fixtures + ## + # test all routes which lead to this controller + def test_routes + assert_routing( + { :path => "/api/0.6/changeset/create", :method => :put }, + { :controller => "changeset", :action => "create" } + ) + assert_routing( + { :path => "/api/0.6/changeset/1/upload", :method => :post }, + { :controller => "changeset", :action => "upload", :id => "1" } + ) + assert_routing( + { :path => "/api/0.6/changeset/1/download", :method => :get }, + { :controller => "changeset", :action => "download", :id => "1" } + ) + assert_routing( + { :path => "/api/0.6/changeset/1/expand_bbox", :method => :post }, + { :controller => "changeset", :action => "expand_bbox", :id => "1" } + ) + assert_routing( + { :path => "/api/0.6/changeset/1", :method => :get }, + { :controller => "changeset", :action => "read", :id => "1" } + ) + assert_routing( + { :path => "/api/0.6/changeset/1", :method => :put }, + { :controller => "changeset", :action => "update", :id => "1" } + ) + assert_routing( + { :path => "/api/0.6/changeset/1/close", :method => :put }, + { :controller => "changeset", :action => "close", :id => "1" } + ) + assert_routing( + { :path => "/api/0.6/changesets", :method => :get }, + { :controller => "changeset", :action => "query" } + ) + assert_routing( + { :path => "/user/name/edits", :method => :get }, + { :controller => "changeset", :action => "list", :display_name => "name" } + ) + assert_routing( + { :path => "/user/name/edits/feed", :method => :get }, + { :controller => "changeset", :action => "feed", :display_name => "name", :format => :atom } + ) + assert_routing( + { :path => "/browse/friends", :method => :get }, + { :controller => "changeset", :action => "list", :friends => true } + ) + assert_routing( + { :path => "/browse/nearby", :method => :get }, + { :controller => "changeset", :action => "list", :nearby => true } + ) + assert_routing( + { :path => "/browse/changesets", :method => :get }, + { :controller => "changeset", :action => "list" } + ) + assert_routing( + { :path => "/browse/changesets/feed", :method => :get }, + { :controller => "changeset", :action => "feed", :format => :atom } + ) + assert_recognizes( + { :controller => "changeset", :action => "list" }, + { :path => "/browse", :method => :get } + ) + assert_recognizes( + { :controller => "changeset", :action => "list" }, + { :path => "/history", :method => :get } + ) + assert_recognizes( + { :controller => "changeset", :action => "feed", :format => :atom }, + { :path => "/history/feed", :method => :get } + ) + end + # ----------------------- # Test simple changeset creation # ----------------------- @@ -82,7 +155,7 @@ class ChangesetControllerTest < ActionController::TestCase post :create assert_response :method_not_allowed end - + ## # check that the changeset can be read and returns the correct # document structure. @@ -95,30 +168,95 @@ 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| + begin + get :read, :id => id + assert_response :not_found, "should get a not found" + rescue ActionController::RoutingError => ex + assert_match /No route matches/, ex.to_s + end + 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 user(:public_user).email, "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| + begin + put :close, :id => id + assert_response :unauthorized, "Shouldn't be able close the non-existant changeset #{id}, when not authorized" + rescue ActionController::RoutingError => ex + assert_match /No route matches/, ex.to_s + end + end + + # Now try with auth + basic_authorization users(:public_user).email, "test" + cs_ids.each do |id| + begin + put :close, :id => id + assert_response :not_found, "The changeset #{id} doesn't exist, so can't be closed" + rescue ActionController::RoutingError => ex + assert_match /No route matches/, ex.to_s + end + end + end ## # upload something simple, but valid and check that it can @@ -227,22 +365,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 = < - + - + - + @@ -253,7 +392,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}" @@ -289,7 +428,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" @@ -300,9 +439,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}" @@ -322,10 +469,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 @@ -343,7 +490,7 @@ 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 "" + @@ -357,25 +504,77 @@ EOF 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 is still used by relations 1.", @response.body # check that nothing was, in fact, deleted assert_equal true, Node.find(current_nodes(:node_used_by_relationship).id).visible @@ -383,27 +582,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 = < - + - + - + @@ -414,7 +689,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}" @@ -442,19 +717,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 = < - - + + - + @@ -475,7 +751,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" @@ -487,7 +763,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 @@ -495,21 +772,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}" @@ -523,20 +800,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 @@ -544,19 +822,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 @@ -564,19 +843,20 @@ 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 ## @@ -879,6 +1159,32 @@ EOF 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. @@ -1053,6 +1359,21 @@ 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).node_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).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 @@ -1134,6 +1455,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 @@ -1146,16 +1498,32 @@ 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_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] @@ -1170,11 +1538,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 ## @@ -1345,21 +1725,89 @@ 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 => ['num_changes > 0'], :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 "div[id='changeset_list'] ul", :count => changesets.size + 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 + + ## + # This should display the last 20 changesets closed. + def test_feed + changesets = Changeset.find(:all, :order => "created_at DESC", :conditions => ['num_changes > 0'], :limit=> 20) + assert changesets.size <= 20 + get :feed, {:format => "atom"} + assert_response :success + assert_template "list" + # Now check that all 20 (or however many were returned) changesets are in the html + assert_select "feed", :count => 1 + assert_select "entry", :count => changesets.size + changesets.each do |changeset| + # FIXME this test needs rewriting - test for feed contents + end + end + + ## + # Checks the display of the user changesets feed + def test_feed_user + user = users(:public_user) + get :feed, {:format => "atom", :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 user changesets feed + def test_feed_user_not_found + get :feed, {:format => "atom", :display_name => "Some random user"} + assert_response :not_found + end + + ## + # check that the changeset download for a changeset with a redacted + # element in it doesn't contain that element. + def test_diff_download_redacted + changeset_id = changesets(:public_user_first_change).id + + get :download, :id => changeset_id + assert_response :success + + assert_select "osmChange", 1 + # this changeset contains node 17 in versions 1 & 2, but 1 should + # be hidden. + assert_select "osmChange node[id=17]", 1 + assert_select "osmChange node[id=17][version=1]", 0 + end + #------------------------------------------------------------ # utility functions #------------------------------------------------------------