X-Git-Url: https://git.openstreetmap.org/rails.git/blobdiff_plain/cedbd885b757aa18150e32493c29ddbac5ba2da7..396f2e28dd27d514f7882c3918103b12764038de:/test/controllers/changeset_controller_test.rb diff --git a/test/controllers/changeset_controller_test.rb b/test/controllers/changeset_controller_test.rb index 14338111f..abdd4cdaa 100644 --- a/test/controllers/changeset_controller_test.rb +++ b/test/controllers/changeset_controller_test.rb @@ -2,8 +2,6 @@ require "test_helper" require "changeset_controller" class ChangesetControllerTest < ActionController::TestCase - api_fixtures - ## # test all routes which lead to this controller def test_routes @@ -329,22 +327,22 @@ class ChangesetControllerTest < ActionController::TestCase # simple diff to change a node, way and relation by removing # their tags - diff = < - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + EOF # upload it @@ -359,22 +357,22 @@ EOF # simple diff to change a node, way and relation by removing # their tags - diff = < - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + EOF # upload it @@ -389,22 +387,22 @@ EOF # simple diff to change a node, way and relation by removing # their tags - diff = < - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + EOF # upload it @@ -424,29 +422,32 @@ EOF def test_upload_create_valid user = create(:user) changeset = create(:changeset, :user => user) + node = create(:node) + way = create(:way_with_nodes, :nodes_count => 2) + relation = create(:relation) basic_authorization user.email, "test" # simple diff to create a node way and relation using placeholders - diff = < - - - - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + + + + EOF # upload it @@ -508,7 +509,7 @@ EOF delete << used_node.to_xml_node # update the changeset to one that this user owns - %w(node way relation).each do |type| + %w[node way relation].each do |type| delete.find("//osmChange/delete/#{type}").each do |n| n["changeset"] = changeset.id.to_s end @@ -581,29 +582,29 @@ EOF # upload some widely-spaced nodes, spiralling positive and negative to cause # largest bbox over-expansion possible. - diff = < - - - - - - - - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + + + + + + + + EOF # upload it, which used to cause an error like "PGError: ERROR: @@ -644,7 +645,7 @@ EOF delete << used_node.to_xml_node # update the changeset to one that this user owns - %w(node way relation).each do |type| + %w[node way relation].each do |type| delete.find("//osmChange/delete/#{type}").each do |n| n["changeset"] = changeset.id.to_s end @@ -688,7 +689,7 @@ EOF delete << used_node.to_xml_node # update the changeset to one that this user owns - %w(node way relation).each do |type| + %w[node way relation].each do |type| delete.find("//osmChange/delete/#{type}").each do |n| n["changeset"] = changeset.id.to_s end @@ -738,14 +739,14 @@ EOF basic_authorization changeset.user.email, "test" # simple diff to create a node way and relation using placeholders - diff = < - - - - - - + diff = < + + + + + + EOF # upload it @@ -769,26 +770,26 @@ EOF basic_authorization changeset.user.email, "test" # simple diff to create a node way and relation using placeholders - diff = < - - - - - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + + + + + EOF # upload it @@ -821,77 +822,80 @@ 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 changesets(:public_user_first_change).user.email, "test" - cs_id = changesets(:public_user_first_change).id + changeset = create(:changeset) + other_changeset = create(:changeset, :user => changeset.user) + node = create(:node) + way = create(:way) + relation = create(:relation) + other_relation = create(:relation) + + basic_authorization changeset.user.email, "test" # simple diff to create a node way and relation using placeholders - diff = < - - - - - - - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + + + + + + + EOF - # cache the objects before uploading them - node = current_nodes(:visible_node) - way = current_ways(:visible_way) - rel = current_relations(:visible_relation) # upload it content diff - post :upload, :id => cs_id + post :upload, :id => changeset.id assert_response :conflict, - "uploading a diff with multiple changsets should have failed" + "uploading a diff with multiple changesets should have failed" # check that objects are unmodified - assert_nodes_are_equal(node, Node.find(1)) - assert_ways_are_equal(way, Way.find(1)) - assert_relations_are_equal(rel, Relation.find(1)) + assert_nodes_are_equal(node, Node.find(node.id)) + assert_ways_are_equal(way, Way.find(way.id)) + assert_relations_are_equal(relation, Relation.find(relation.id)) end ## # upload multiple versions of the same element in the same diff. def test_upload_multiple_valid - basic_authorization changesets(:public_user_first_change).user.email, "test" - cs_id = changesets(:public_user_first_change).id + node = create(:node) + changeset = create(:changeset) + basic_authorization changeset.user.email, "test" # change the location of a node multiple times, each time referencing # the last version. doesn't this depend on version numbers being # sequential? - diff = < - - - - - - - - - - - + diff = < + + + + + + + + + + + EOF # upload it content diff - post :upload, :id => cs_id + post :upload, :id => changeset.id assert_response :success, "can't upload multiple versions of an element in a diff: #{@response.body}" @@ -905,21 +909,23 @@ 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 changesets(:public_user_first_change).user.email, "test" - cs_id = changesets(:public_user_first_change).id - - diff = < - - - - - + node = create(:node) + changeset = create(:changeset) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + + EOF # upload it content diff - post :upload, :id => cs_id + post :upload, :id => changeset.id assert_response :conflict, "shouldn't be able to upload the same element twice in a diff: #{@response.body}" end @@ -927,20 +933,21 @@ EOF ## # try to upload some elements without specifying the version def test_upload_missing_version - basic_authorization changesets(:public_user_first_change).user.email, "test" - cs_id = changesets(:public_user_first_change).id - - diff = < - - - - + changeset = create(:changeset) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + EOF # upload it content diff - post :upload, :id => cs_id + post :upload, :id => changeset.id assert_response :bad_request, "shouldn't be able to upload an element without version: #{@response.body}" end @@ -948,18 +955,19 @@ EOF ## # try to upload with commands other than create, modify, or delete def test_action_upload_invalid - basic_authorization changesets(:public_user_first_change).user.email, "test" - cs_id = changesets(:public_user_first_change).id - - diff = < - - - - + changeset = create(:changeset) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + EOF content diff - post :upload, :id => cs_id + post :upload, :id => changeset.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" end @@ -968,26 +976,32 @@ EOF # 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 changesets(:public_user_first_change).user.email, "test" - changeset_id = changesets(:public_user_first_change).id - - diff = < - - - - - - - + changeset = create(:changeset) + node = create(:node) + way = create(:way_with_nodes, :nodes_count => 2) + relation = create(:relation) + other_relation = create(:relation) + create(:relation_tag, :relation => relation) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + + + + EOF # upload it content diff - post :upload, :id => changeset_id + post :upload, :id => changeset.id assert_response :success, "can't upload a valid diff with whitespace variations to changeset: #{@response.body}" @@ -996,36 +1010,36 @@ EOF assert_select "diffResult>relation", 1 # check that the changes made it into the database - assert_equal 1, Node.find(1).tags.size, "node 1 should now have one tag" - assert_equal 0, Relation.find(1).tags.size, "relation 1 should now have no tags" + assert_equal 1, Node.find(node.id).tags.size, "node #{node.id} should now have one tag" + assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags" end ## - # upload a valid changeset which has a mixture of whitespace - # to check a bug reported by ivansanchez. + # test that a placeholder can be reused within the same upload. def test_upload_reuse_placeholder_valid - basic_authorization changesets(:public_user_first_change).user.email, "test" - changeset_id = changesets(:public_user_first_change).id - - diff = < - - - - - - - - - - - - + changeset = create(:changeset) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + + + + + + + + + EOF # upload it content diff - post :upload, :id => changeset_id + post :upload, :id => changeset.id assert_response :success, "can't upload a valid diff with re-used placeholders to changeset: #{@response.body}" @@ -1038,22 +1052,23 @@ EOF # test what happens if a diff upload re-uses placeholder IDs in an # illegal way. def test_upload_placeholder_invalid - basic_authorization changesets(:public_user_first_change).user.email, "test" - changeset_id = changesets(:public_user_first_change).id - - diff = < - - - - - - + changeset = create(:changeset) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + + + EOF # upload it content diff - post :upload, :id => changeset_id + post :upload, :id => changeset.id assert_response :bad_request, "shouldn't be able to re-use placeholder IDs" end @@ -1062,110 +1077,114 @@ EOF # test that uploading a way referencing invalid placeholders gives a # proper error, not a 500. def test_upload_placeholder_invalid_way - basic_authorization changesets(:public_user_first_change).user.email, "test" - changeset_id = changesets(:public_user_first_change).id - - diff = < - - - - - - - - - - - - + changeset = create(:changeset) + way = create(:way) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + + + + + + + + + EOF # upload it content diff - post :upload, :id => changeset_id + 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 = < - - - - - - - - - - - - + diff = < + + + + + + + + + + + + EOF # upload it content diff - post :upload, :id => changeset_id + 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 + assert_equal "Placeholder node not found for reference -4 in way #{way.id}", @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 changesets(:public_user_first_change).user.email, "test" - changeset_id = changesets(:public_user_first_change).id - - diff = < - - - - - - - - - - - - + changeset = create(:changeset) + relation = create(:relation) + + basic_authorization changeset.user.email, "test" + + diff = < + + + + + + + + + + + + EOF # upload it content diff - post :upload, :id => changeset_id + 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 = < - - - - - - - - - - - - + # the same again, but this time use an existing relation + diff = < + + + + + + + + + + + + EOF # upload it content diff - post :upload, :id => changeset_id + 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 + assert_equal "Placeholder Way not found for reference -1 in relation #{relation.id}.", @response.body end ## @@ -1181,7 +1200,7 @@ EOF assert_response :success changeset_id = @response.body.to_i - old_node = current_nodes(:visible_node) + old_node = create(:node, :lat => 1, :lon => 1) diff = XML::Document.new diff.root = XML::Node.new "osmChange" @@ -1219,14 +1238,15 @@ EOF assert_response :success changeset_id = @response.body.to_i - old_way = current_ways(:visible_way) + old_way = create(:way) + create(:way_node, :way => old_way, :node => create(:node, :lat => 1, :lon => 1)) diff = XML::Document.new diff.root = XML::Node.new "osmChange" modify = XML::Node.new "modify" xml_old_way = old_way.to_xml_node nd_ref = XML::Node.new "nd" - nd_ref["ref"] = current_nodes(:visible_node).id.to_s + nd_ref["ref"] = create(:node, :lat => 3, :lon => 3).id.to_s xml_old_way << nd_ref xml_old_way["changeset"] = changeset_id.to_s modify << xml_old_way @@ -1249,7 +1269,9 @@ EOF ## # test for more issues in #1568 def test_upload_empty_invalid - basic_authorization changesets(:public_user_first_change).user.email, "test" + changeset = create(:changeset) + + basic_authorization changeset.user.email, "test" ["", "", @@ -1257,7 +1279,7 @@ EOF ""].each do |diff| # upload it content diff - post :upload, :id => changesets(:public_user_first_change).id + post :upload, :id => changeset.id assert_response(:success, "should be able to upload " + "empty changeset: " + diff) end @@ -1266,20 +1288,23 @@ EOF ## # test that the X-Error-Format header works to request XML errors def test_upload_xml_errors - basic_authorization changesets(:public_user_first_change).user.email, "test" - cs = changesets(:public_user_first_change) + changeset = create(:changeset) + node = create(:node) + create(:relation_member, :member => node) + + basic_authorization changeset.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 + delete << node.to_xml_node # upload it content diff error_format "xml" - post :upload, :id => cs.id + post :upload, :id => changeset.id assert_response :success, "failed to return error in XML format" @@ -1293,6 +1318,8 @@ EOF # when we make some simple changes we get the same changes back from the # diff download. def test_diff_download_simple + node = create(:node) + ## First try with a non-public user, which should get a forbidden basic_authorization(create(:user, :data_public => false).email, "test") @@ -1315,19 +1342,19 @@ EOF changeset_id = @response.body.to_i # add a diff to it - diff = < - - - - - - - - - - - + diff = < + + + + + + + + + + + EOF # upload it @@ -1360,33 +1387,33 @@ EOF assert_response :success changeset_id = @response.body.to_i - diff = < - - - - - - - - - - - - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + + + + + + + + + + + + OSMFILE # upload it @@ -1409,6 +1436,9 @@ OSMFILE # when we make some complex changes we get the same changes back from the # diff download. def test_diff_download_complex + node = create(:node) + node2 = create(:node) + way = create(:way) basic_authorization(create(:user).email, "test") # create a temporary changeset @@ -1420,26 +1450,26 @@ OSMFILE changeset_id = @response.body.to_i # add a diff to it - diff = < - - - - - - - - - - - - - - - - - - + diff = < + + + + + + + + + + + + + + + + + + EOF # upload it @@ -1462,9 +1492,15 @@ EOF end def test_changeset_download - tag = create(:old_node_tag, :old_node => nodes(:used_node_2)) + changeset = create(:changeset) + node = create(:node, :with_history, :version => 1, :changeset => changeset) + tag = create(:old_node_tag, :old_node => node.old_nodes.find_by(:version => 1)) + node2 = create(:node, :with_history, :version => 1, :changeset => changeset) + _node3 = create(:node, :with_history, :deleted, :version => 1, :changeset => changeset) + _relation = create(:relation, :with_history, :version => 1, :changeset => changeset) + _relation2 = create(:relation, :with_history, :deleted, :version => 1, :changeset => changeset) - get :download, :id => changesets(:normal_user_first_change).id + get :download, :id => changeset.id assert_response :success assert_template nil @@ -1472,10 +1508,10 @@ EOF # 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 "create>node[id='#{node.id}'][visible='#{node.visible?}'][version='#{node.version}']" do assert_select "tag[k='#{tag.k}'][v='#{tag.v}']" end - assert_select "create>node[id='#{nodes(:visible_node).node_id}']" + assert_select "create>node[id='#{node2.id}']" end end @@ -1483,6 +1519,9 @@ EOF # 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 + way = create(:way) + create(:way_node, :way => way, :node => create(:node, :lat => 3, :lon => 3)) + basic_authorization create(:user).email, "test" # create a new changeset @@ -1501,10 +1540,10 @@ EOF # 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 + assert_select "osm>changeset[min_lon='1.0000000']", 1 + assert_select "osm>changeset[max_lon='1.0000000']", 1 + assert_select "osm>changeset[min_lat='2.0000000']", 1 + assert_select "osm>changeset[max_lat='2.0000000']", 1 # add another node to it with_controller(NodeController.new) do @@ -1516,16 +1555,15 @@ EOF # 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 + assert_select "osm>changeset[min_lon='1.0000000']", 1 + assert_select "osm>changeset[max_lon='2.0000000']", 1 + assert_select "osm>changeset[min_lat='1.0000000']", 1 + assert_select "osm>changeset[max_lat='2.0000000']", 1 # add (delete) a way to it, which contains a point at (3,3) with_controller(WayController.new) do - content update_changeset(current_ways(:visible_way).to_xml, - changeset_id) - put :delete, :id => current_ways(:visible_way).id + content update_changeset(way.to_xml, changeset_id) + put :delete, :id => way.id assert_response :success, "Couldn't delete a way." end @@ -1533,10 +1571,10 @@ EOF get :read, :id => changeset_id assert_response :success, "Couldn't read back changeset for the third time." # note that the 3.1 here is because of the bbox overexpansion - 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 + assert_select "osm>changeset[min_lon='1.0000000']", 1 + assert_select "osm>changeset[max_lon='3.1000000']", 1 + assert_select "osm>changeset[min_lat='1.0000000']", 1 + assert_select "osm>changeset[max_lat='3.1000000']", 1 end ## @@ -1600,14 +1638,16 @@ EOF user = create(:user) changeset = create(:changeset, :user => user) closed_changeset = create(:changeset, :closed, :user => user, :created_at => Time.utc(2008, 1, 1, 0, 0, 0), :closed_at => Time.utc(2008, 1, 2, 0, 0, 0)) + changeset2 = create(:changeset, :min_lat => 5 * GeoRecord::SCALE, :min_lon => 5 * GeoRecord::SCALE, :max_lat => 15 * GeoRecord::SCALE, :max_lon => 15 * GeoRecord::SCALE) + changeset3 = create(:changeset, :min_lat => 4.5 * GeoRecord::SCALE, :min_lon => 4.5 * GeoRecord::SCALE, :max_lat => 5 * GeoRecord::SCALE, :max_lon => 5 * GeoRecord::SCALE) get :query, :bbox => "-10,-10, 10, 10" assert_response :success, "can't get changesets in bbox" - assert_changesets [1, 4, 6] + assert_changesets [changeset2, changeset3] get :query, :bbox => "4.5,4.5,4.6,4.6" assert_response :success, "can't get changesets in bbox" - assert_changesets [1] + assert_changesets [changeset3] # not found when looking for changesets of non-existing users get :query, :user => User.maximum(:id) + 1 @@ -1625,11 +1665,11 @@ EOF basic_authorization private_user.email, "test" get :query, :user => private_user.id assert_response :success, "can't get changesets by user ID" - assert_changesets [private_user_changeset.id, private_user_closed_changeset.id] + assert_changesets [private_user_changeset, private_user_closed_changeset] get :query, :display_name => private_user.display_name assert_response :success, "can't get changesets by user name" - assert_changesets [private_user_changeset.id, private_user_closed_changeset.id] + assert_changesets [private_user_changeset, private_user_closed_changeset] # check that the correct error is given when we provide both UID and name get :query, :user => private_user.id, :display_name => private_user.display_name @@ -1637,39 +1677,39 @@ EOF get :query, :user => private_user.id, :open => true assert_response :success, "can't get changesets by user and open" - assert_changesets [private_user_changeset.id] + assert_changesets [private_user_changeset] get :query, :time => "2007-12-31" assert_response :success, "can't get changesets by time-since" - assert_changesets [1, 2, 4, 5, 6, private_user_changeset.id, private_user_closed_changeset.id, changeset.id, closed_changeset.id] + assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3] 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, 6, private_user_changeset.id, private_user_closed_changeset.id, changeset.id, closed_changeset.id] + assert_changesets [private_user_changeset, private_user_closed_changeset, changeset, closed_changeset, changeset2, changeset3] get :query, :time => "2007-12-31T23:59Z,2008-01-02T00:01Z" assert_response :success, "can't get changesets by time-range" - assert_changesets [1, 5, 6, closed_changeset.id] + assert_changesets [closed_changeset] get :query, :open => "true" assert_response :success, "can't get changesets by open-ness" - assert_changesets [1, 2, 4, private_user_changeset.id, changeset.id] + assert_changesets [private_user_changeset, changeset, changeset2, changeset3] get :query, :closed => "true" assert_response :success, "can't get changesets by closed-ness" - assert_changesets [3, 5, 6, 7, 8, 9, private_user_closed_changeset.id, closed_changeset.id] + assert_changesets [private_user_closed_changeset, closed_changeset] get :query, :closed => "true", :user => private_user.id assert_response :success, "can't get changesets by closed-ness and user" - assert_changesets [private_user_closed_changeset.id] + assert_changesets [private_user_closed_changeset] get :query, :closed => "true", :user => user.id assert_response :success, "can't get changesets by closed-ness and user" - assert_changesets [closed_changeset.id] + assert_changesets [closed_changeset] get :query, :changesets => "#{private_user_changeset.id},#{changeset.id},#{closed_changeset.id}" assert_response :success, "can't get changesets by id (as comma-separated string)" - assert_changesets [private_user_changeset.id, changeset.id, closed_changeset.id] + assert_changesets [private_user_changeset, changeset, closed_changeset] get :query, :changesets => "" assert_response :bad_request, "should be a bad request since changesets is empty" @@ -2004,39 +2044,49 @@ EOF end ## - # This should display the last 20 changesets closed + # This should display the last 20 non-empty changesets def test_feed + changeset = create(:changeset, :num_changes => 1) + closed_changeset = create(:changeset, :closed, :num_changes => 1) + _empty_changeset = create(:changeset, :num_changes => 0) + get :feed, :format => :atom assert_response :success assert_template "list" assert_equal "application/atom+xml", response.content_type - check_feed_result(Changeset.all) + check_feed_result([changeset, closed_changeset]) end ## # This should display the last 20 changesets closed in a specific area def test_feed_bbox + changeset = create(:changeset, :num_changes => 1, :min_lat => 5 * GeoRecord::SCALE, :min_lon => 5 * GeoRecord::SCALE, :max_lat => 5 * GeoRecord::SCALE, :max_lon => 5 * GeoRecord::SCALE) + closed_changeset = create(:changeset, :closed, :num_changes => 1, :min_lat => 5 * GeoRecord::SCALE, :min_lon => 5 * GeoRecord::SCALE, :max_lat => 5 * GeoRecord::SCALE, :max_lon => 5 * GeoRecord::SCALE) + _elsewhere_changeset = create(:changeset, :num_changes => 1, :min_lat => -5 * GeoRecord::SCALE, :min_lon => -5 * GeoRecord::SCALE, :max_lat => -5 * GeoRecord::SCALE, :max_lon => -5 * GeoRecord::SCALE) + _empty_changeset = create(:changeset, :num_changes => 0, :min_lat => -5 * GeoRecord::SCALE, :min_lon => -5 * GeoRecord::SCALE, :max_lat => -5 * GeoRecord::SCALE, :max_lon => -5 * GeoRecord::SCALE) + get :feed, :format => :atom, :bbox => "4.5,4.5,5.5,5.5" assert_response :success assert_template "list" assert_equal "application/atom+xml", response.content_type - check_feed_result(Changeset.where("min_lon < 55000000 and max_lon > 45000000 and min_lat < 55000000 and max_lat > 45000000")) + check_feed_result([changeset, closed_changeset]) end ## # Checks the display of the user changesets feed def test_feed_user user = create(:user) - create_list(:changeset, 3, :user => user, :num_changes => 4) + changesets = create_list(:changeset, 3, :user => user, :num_changes => 4) + _other_changeset = create(:changeset) get :feed, :format => :atom, :display_name => user.display_name assert_response :success assert_template "list" assert_equal "application/atom+xml", response.content_type - check_feed_result(user.changesets) + check_feed_result(changesets) end ## @@ -2390,10 +2440,10 @@ EOF ## # 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 + def assert_changesets(changesets) + assert_select "osm>changeset", changesets.size + changesets.each do |changeset| + assert_select "osm>changeset[id='#{changeset.id}']", 1 end end @@ -2450,9 +2500,6 @@ EOF ## # check the result of a feed def check_feed_result(changesets) - changesets = changesets.where("num_changes > 0") - .order(:created_at => :desc) - .limit(20) assert changesets.size <= 20 assert_select "feed", :count => [changesets.size, 1].min do