class ChangesetControllerTest < ActionController::TestCase
api_fixtures
- fixtures :friends, :changeset_comments, :changesets_subscribers
##
# test all routes which lead to this controller
# -----------------------
def test_create
- basic_authorization users(:normal_user).email, "test"
+ basic_authorization create(:user, :data_public => false).email, "test"
# Create the first user's changeset
content "<osm><changeset>" +
"<tag k='created_by' v='osm test suite checking changesets'/>" +
put :create
assert_require_public_data
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
# Create the first user's changeset
content "<osm><changeset>" +
"<tag k='created_by' v='osm test suite checking changesets'/>" +
end
def test_create_invalid
- basic_authorization users(:normal_user).email, "test"
+ basic_authorization create(:user, :data_public => false).email, "test"
content "<osm><changeset></osm>"
put :create
assert_require_public_data
## Try the public user
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
content "<osm><changeset></osm>"
put :create
assert_response :bad_request, "creating a invalid changeset should fail"
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"
+ ## Now try to with a non-public user
+ basic_authorization create(:user, :data_public => false).email, "test"
put :create
assert_require_public_data
- ## Try the inactive user
- basic_authorization users(:inactive_user).email, "test"
+ ## Try an inactive user
+ basic_authorization create(:user, :pending).email, "test"
put :create
assert_inactive_user
- ## Now try to use the public user
- basic_authorization users(:public_user).email, "test"
+ ## Now try to use a normal user
+ basic_authorization create(: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"
+ basic_authorization create(:user).email, "test"
get :create
assert_response :method_not_allowed
post :create
# check that the changeset can be read and returns the correct
# document structure.
def test_read
- changeset_id = changesets(:normal_user_first_change).id
+ changeset_id = create(:changeset).id
get :read, :id => changeset_id
assert_response :success, "cannot get first changeset"
assert_select "osm>changeset>discussion", 1
assert_select "osm>changeset>discussion>comment", 0
- changeset_id = changesets(:normal_user_closed_change).id
+ changeset_id = create(:changeset, :closed).id
+ create_list(:changeset_comment, 3, :changeset_id => changeset_id)
get :read, :id => changeset_id, :include_discussion => true
assert_response :success, "cannot get closed changeset with comments"
##
# test that the user who opened a change can close it
def test_close
+ private_user = create(:user, :data_public => false)
+ private_changeset = create(:changeset, :user => private_user)
+ user = create(:user)
+ changeset = create(:changeset, :user => user)
+
## Try without authentication
- put :close, :id => changesets(:public_user_first_change).id
+ put :close, :id => changeset.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
+ basic_authorization private_user.email, "test"
+ put :close, :id => private_changeset.id
assert_require_public_data
## The try with the public user
- basic_authorization users(:public_user).email, "test"
+ basic_authorization user.email, "test"
- cs_id = changesets(:public_user_first_change).id
+ cs_id = changeset.id
put :close, :id => cs_id
assert_response :success
##
# test that a different user can't close another user's changeset
def test_close_invalid
- basic_authorization users(:public_user).email, "test"
+ user = create(:user)
+ changeset = create(:changeset)
+
+ basic_authorization user.email, "test"
- put :close, :id => changesets(:normal_user_first_change).id
+ put :close, :id => changeset.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"
+ user = create(:user)
+ changeset = create(:changeset, :user => user)
- cs_id = changesets(:public_user_first_change).id
- get :close, :id => cs_id
+ basic_authorization user.email, "test"
+
+ get :close, :id => changeset.id
assert_response :method_not_allowed
- post :close, :id => cs_id
+ post :close, :id => changeset.id
assert_response :method_not_allowed
end
end
# Now try with auth
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
cs_ids.each do |id|
begin
put :close, :id => id
# be read back ok
# Also try without auth and another user.
def test_upload_simple_valid
+ private_user = create(:user, :data_public => false)
+ private_changeset = create(:changeset, :user => private_user)
+ user = create(:user)
+ changeset = create(:changeset, :user => user)
+
+ node = create(:node)
+ way = create(:way)
+ relation = create(:relation)
+ other_relation = create(:relation)
+ # create some tags, since we test that they are removed later
+ create(:node_tag, :node => node)
+ create(:way_tag, :way => way)
+ create(:relation_tag, :relation => relation)
+
## Try with no auth
- changeset_id = changesets(:public_user_first_change).id
+ changeset_id = changeset.id
# simple diff to change a node, way and relation by removing
# their tags
diff = <<EOF
<osmChange>
<modify>
- <node id='1' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
- <way id='1' changeset='#{changeset_id}' version='1'>
- <nd ref='3'/>
+ <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
+ <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
+ <nd ref='#{node.id}'/>
</way>
</modify>
<modify>
- <relation id='1' changeset='#{changeset_id}' version='1'>
- <member type='way' role='some' ref='3'/>
- <member type='node' role='some' ref='5'/>
- <member type='relation' role='some' ref='3'/>
+ <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
+ <member type='way' role='some' ref='#{way.id}'/>
+ <member type='node' role='some' ref='#{node.id}'/>
+ <member type='relation' role='some' ref='#{other_relation.id}'/>
</relation>
</modify>
</osmChange>
content diff
post :upload, :id => changeset_id
assert_response :unauthorized,
- "shouldnn't be able to upload a simple valid diff to changeset: #{@response.body}"
+ "shouldn'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
+ basic_authorization private_user.email, "test"
+ changeset_id = private_changeset.id
# simple diff to change a node, way and relation by removing
# their tags
diff = <<EOF
<osmChange>
<modify>
- <node id='1' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
- <way id='1' changeset='#{changeset_id}' version='1'>
- <nd ref='3'/>
+ <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
+ <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
+ <nd ref='#{node.id}'/>
</way>
</modify>
<modify>
- <relation id='1' changeset='#{changeset_id}' version='1'>
- <member type='way' role='some' ref='3'/>
- <member type='node' role='some' ref='5'/>
- <member type='relation' role='some' ref='3'/>
+ <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
+ <member type='way' role='some' ref='#{way.id}'/>
+ <member type='node' role='some' ref='#{node.id}'/>
+ <member type='relation' role='some' ref='#{other_relation.id}'/>
</relation>
</modify>
</osmChange>
"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
+ basic_authorization user.email, "test"
+ changeset_id = changeset.id
# simple diff to change a node, way and relation by removing
# their tags
diff = <<EOF
<osmChange>
<modify>
- <node id='1' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
- <way id='1' changeset='#{changeset_id}' version='1'>
- <nd ref='3'/>
+ <node id='#{node.id}' lon='0' lat='0' changeset='#{changeset_id}' version='1'/>
+ <way id='#{way.id}' changeset='#{changeset_id}' version='1'>
+ <nd ref='#{node.id}'/>
</way>
</modify>
<modify>
- <relation id='1' changeset='#{changeset_id}' version='1'>
- <member type='way' role='some' ref='3'/>
- <member type='node' role='some' ref='5'/>
- <member type='relation' role='some' ref='3'/>
+ <relation id='#{relation.id}' changeset='#{changeset_id}' version='1'>
+ <member type='way' role='some' ref='#{way.id}'/>
+ <member type='node' role='some' ref='#{node.id}'/>
+ <member type='relation' role='some' ref='#{other_relation.id}'/>
</relation>
</modify>
</osmChange>
"can't upload a simple valid diff to changeset: #{@response.body}"
# check that the changes made it into the database
- assert_equal 0, Node.find(1).tags.size, "node 1 should now have no tags"
- assert_equal 0, Way.find(1).tags.size, "way 1 should now have no tags"
- assert_equal 0, Relation.find(1).tags.size, "relation 1 should now have no tags"
+ assert_equal 0, Node.find(node.id).tags.size, "node #{node.id} should now have no tags"
+ assert_equal 0, Way.find(way.id).tags.size, "way #{way.id} should now have no tags"
+ assert_equal 0, Relation.find(relation.id).tags.size, "relation #{relation.id} should now have no tags"
end
##
# upload something which creates new objects using placeholders
def test_upload_create_valid
- basic_authorization users(:public_user).email, "test"
- cs_id = changesets(:public_user_first_change).id
+ user = create(:user)
+ changeset = create(:changeset, :user => user)
+
+ basic_authorization user.email, "test"
# simple diff to create a node way and relation using placeholders
diff = <<EOF
<osmChange>
<create>
- <node id='-1' lon='0' lat='0' changeset='#{cs_id}'>
+ <node id='-1' lon='0' lat='0' changeset='#{changeset.id}'>
<tag k='foo' v='bar'/>
<tag k='baz' v='bat'/>
</node>
- <way id='-1' changeset='#{cs_id}'>
+ <way id='-1' changeset='#{changeset.id}'>
<nd ref='3'/>
</way>
</create>
<create>
- <relation id='-1' changeset='#{cs_id}'>
+ <relation id='-1' changeset='#{changeset.id}'>
<member type='way' role='some' ref='3'/>
<member type='node' role='some' ref='5'/>
<member type='relation' role='some' ref='3'/>
# upload it
content diff
- post :upload, :id => cs_id
+ post :upload, :id => changeset.id
assert_response :success,
"can't upload a simple valid creation to changeset: #{@response.body}"
# test a complex delete where we delete elements which rely on eachother
# in the same transaction.
def test_upload_delete
- basic_authorization users(:public_user).display_name, "test"
+ basic_authorization changesets(:public_user_first_change).user.display_name, "test"
diff = XML::Document.new
diff.root = XML::Node.new "osmChange"
# test uploading a delete with no lat/lon, as they are optional in
# the osmChange spec.
def test_upload_nolatlon_delete
- basic_authorization users(:public_user).display_name, "test"
+ basic_authorization changesets(:public_user_first_change).user.display_name, "test"
node = current_nodes(:public_visible_node)
cs = changesets(:public_user_first_change)
def test_repeated_changeset_create
30.times do
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
# create a temporary changeset
content "<osm><changeset>" +
end
def test_upload_large_changeset
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
# create a changeset
content "<osm><changeset/></osm>"
# 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 users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
+ cs = changesets(:public_user_first_change)
diff = XML::Document.new
diff.root = XML::Node.new "osmChange"
# upload it
content diff
- post :upload, :id => 2
+ post :upload, :id => cs.id
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
##
# test that a conditional delete of an in use object works.
def test_upload_delete_if_unused
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
+ cs = changesets(:public_user_first_change)
diff = XML::Document.new
diff.root = XML::Node.new "osmChange"
# upload it
content diff
- post :upload, :id => 2
+ post :upload, :id => cs.id
assert_response :success,
"can't do a conditional delete of in use objects: #{@response.body}"
##
# upload an element with a really long tag value
def test_upload_invalid_too_long_tag
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
# simple diff to create a node way and relation using placeholders
<osmChange>
<create>
<node id='-1' lon='0' lat='0' changeset='#{cs_id}'>
- <tag k='foo' v='#{"x" * 256}'/>
+ <tag k='foo' v='#{'x' * 256}'/>
</node>
</create>
</osmChange>
# upload something which creates new objects and inserts them into
# existing containers using placeholders.
def test_upload_complex
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
# simple diff to create a node way and relation using placeholders
# 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 users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
# simple diff to create a node way and relation using placeholders
##
# upload multiple versions of the same element in the same diff.
def test_upload_multiple_valid
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
# change the location of a node multiple times, each time referencing
# 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 users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
diff = <<EOF
##
# try to upload some elements without specifying the version
def test_upload_missing_version
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
diff = <<EOF
##
# try to upload with commands other than create, modify, or delete
def test_action_upload_invalid
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
diff = <<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 users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
changeset_id = changesets(:public_user_first_change).id
diff = <<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 users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
changeset_id = changesets(:public_user_first_change).id
diff = <<EOF
# test what happens if a diff upload re-uses placeholder IDs in an
# illegal way.
def test_upload_placeholder_invalid
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
changeset_id = changesets(:public_user_first_change).id
diff = <<EOF
# 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"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
changeset_id = changesets(:public_user_first_change).id
diff = <<EOF
# 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"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
changeset_id = changesets(:public_user_first_change).id
diff = <<EOF
# test what happens if a diff is uploaded containing only a node
# move.
def test_upload_node_move
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
content "<osm><changeset>" +
"<tag k='created_by' v='osm test suite checking changesets'/>" +
##
# test what happens if a diff is uploaded adding a node to a way.
def test_upload_way_extend
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
content "<osm><changeset>" +
"<tag k='created_by' v='osm test suite checking changesets'/>" +
##
# test for more issues in #1568
def test_upload_empty_invalid
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
["<osmChange/>",
"<osmChange></osmChange>",
"<osmChange><modify/></osmChange>",
- "<osmChange><modify></modify></osmChange>"
- ].each do |diff|
+ "<osmChange><modify></modify></osmChange>"].each do |diff|
# upload it
content diff
post :upload, :id => changesets(:public_user_first_change).id
##
# test that the X-Error-Format header works to request XML errors
def test_upload_xml_errors
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
+ cs = changesets(:public_user_first_change)
# try and delete a node that is in use
diff = XML::Document.new
# upload it
content diff
error_format "xml"
- post :upload, :id => 2
+ post :upload, :id => cs.id
assert_response :success,
"failed to return error in XML format"
# 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")
+ ## First try with a non-public user, which should get a forbidden
+ basic_authorization(create(:user, :data_public => false).email, "test")
# create a temporary changeset
content "<osm><changeset>" +
put :create
assert_response :forbidden
- ## Now try with the public user
- basic_authorization(users(:public_user).email, "test")
+ ## Now try with a normal user
+ basic_authorization(create(:user).email, "test")
# create a temporary changeset
content "<osm><changeset>" +
#
# NOTE: the error turned out to be something else completely!
def test_josm_upload
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(create(:user).email, "test")
# create a temporary changeset
content "<osm><changeset>" +
# when we make some complex changes we get the same changes back from the
# diff download.
def test_diff_download_complex
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(create(:user).email, "test")
# create a temporary changeset
content "<osm><changeset>" +
end
def test_changeset_download
+ tag = create(:old_node_tag, :old_node => nodes(:used_node_2))
+
get :download, :id => changesets(:normal_user_first_change).id
+
assert_response :success
assert_template nil
# print @response.body
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}']"
+ assert_select "tag[k='#{tag.k}'][v='#{tag.v}']"
end
assert_select "create>node[id='#{nodes(:visible_node).node_id}']"
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 users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
# create a new changeset
content "<osm><changeset/></osm>"
##
# test that the changeset :include method works as it should
def test_changeset_include
- basic_authorization users(:public_user).display_name, "test"
+ basic_authorization create(:user).display_name, "test"
# create a new changeset
content "<osm><changeset/></osm>"
##
# 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"
+ basic_authorization create(:user).display_name, "test"
# create a new changeset
content "<osm><changeset/></osm>"
##
# test the query functionality of changesets
def test_query
+ private_user = create(:user, :data_public => false)
+ private_user_changeset = create(:changeset, :user => private_user)
+ private_user_closed_changeset = create(:changeset, :closed, :user => private_user)
+ 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))
+
get :query, :bbox => "-10,-10, 10, 10"
assert_response :success, "can't get changesets in bbox"
assert_changesets [1, 4, 6]
assert_response :not_found
# can't get changesets of user 1 without authenticating
- get :query, :user => users(:normal_user).id
+ get :query, :user => private_user.id
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
+ get :query, :display_name => private_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
+ basic_authorization private_user.email, "test"
+ get :query, :user => private_user.id
assert_response :success, "can't get changesets by user ID"
- assert_changesets [1, 3, 6, 8]
+ assert_changesets [private_user_changeset.id, private_user_closed_changeset.id]
- get :query, :display_name => users(:normal_user).display_name
+ get :query, :display_name => private_user.display_name
assert_response :success, "can't get changesets by user name"
- assert_changesets [1, 3, 6, 8]
+ assert_changesets [private_user_changeset.id, private_user_closed_changeset.id]
# 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
+ get :query, :user => private_user.id, :display_name => private_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
+ get :query, :user => private_user.id, :open => true
assert_response :success, "can't get changesets by user and open"
- assert_changesets [1]
+ assert_changesets [private_user_changeset.id]
get :query, :time => "2007-12-31"
assert_response :success, "can't get changesets by time-since"
- assert_changesets [1, 2, 4, 5, 6]
+ assert_changesets [1, 2, 4, 5, 6, private_user_changeset.id, private_user_closed_changeset.id, changeset.id, closed_changeset.id]
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]
+ assert_changesets [1, 2, 4, 5, 6, private_user_changeset.id, private_user_closed_changeset.id, changeset.id, closed_changeset.id]
- get :query, :time => "2007-12-31T23:59Z,2008-01-01T00:01Z"
+ 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]
+ assert_changesets [1, 5, 6, closed_changeset.id]
get :query, :open => "true"
assert_response :success, "can't get changesets by open-ness"
- assert_changesets [1, 2, 4]
+ assert_changesets [1, 2, 4, private_user_changeset.id, changeset.id]
get :query, :closed => "true"
assert_response :success, "can't get changesets by closed-ness"
- assert_changesets [3, 5, 6, 7, 8, 9]
+ assert_changesets [3, 5, 6, 7, 8, 9, private_user_closed_changeset.id, closed_changeset.id]
- get :query, :closed => "true", :user => users(:normal_user).id
+ get :query, :closed => "true", :user => private_user.id
assert_response :success, "can't get changesets by closed-ness and user"
- assert_changesets [3, 6, 8]
+ assert_changesets [private_user_closed_changeset.id]
- get :query, :closed => "true", :user => users(:public_user).id
+ get :query, :closed => "true", :user => user.id
assert_response :success, "can't get changesets by closed-ness and user"
- assert_changesets [7]
+ assert_changesets [closed_changeset.id]
- get :query, :changesets => "1,2,3"
+ 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 [1, 2, 3]
+ assert_changesets [private_user_changeset.id, changeset.id, closed_changeset.id]
get :query, :changesets => ""
assert_response :bad_request, "should be a bad request since changesets is empty"
def test_query_invalid
["abracadabra!",
"1,2,3,F",
- ";drop table users;"
- ].each do |bbox|
+ ";drop table users;"].each do |bbox|
get :query, :bbox => bbox
assert_response :bad_request, "'#{bbox}' isn't a bbox"
end
"00-00-00",
";drop table users;",
",",
- "-,-"
- ].each do |time|
+ "-,-"].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|
+ "0"].each do |uid|
get :query, :user => uid
assert_response :bad_request, "'#{uid}' isn't a valid user ID"
end
##
# check updating tags on a changeset
def test_changeset_update
- ## First try with the non-public user
+ ## First try with a non-public user
changeset = changesets(:normal_user_first_change)
new_changeset = changeset.to_xml
new_tag = XML::Node.new "tag"
assert_response :unauthorized
# try with the wrong authorization
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
put :update, :id => changeset.id
assert_response :conflict
# now this should get an unauthorized
- basic_authorization users(:normal_user).email, "test"
+ basic_authorization changeset.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)
+ create(:changeset_tag, :changeset => changeset)
new_changeset = changeset.to_xml
new_tag = XML::Node.new "tag"
new_tag["k"] = "tagtesting"
assert_response :unauthorized
# try with the wrong authorization
- basic_authorization users(:second_public_user).email, "test"
+ basic_authorization create(:user).email, "test"
put :update, :id => changeset.id
assert_response :conflict
# now this should work...
- basic_authorization users(:public_user).email, "test"
+ basic_authorization changeset.user.email, "test"
put :update, :id => changeset.id
assert_response :success
# check that a user different from the one who opened the changeset
# can't modify it.
def test_changeset_update_invalid
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
changeset = changesets(:normal_user_first_change)
new_changeset = changeset.to_xml
# 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 users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
# open a new changeset
content "<osm><changeset/></osm>"
##
# Checks the display of the user changesets listing
def test_list_user
- user = users(:public_user)
+ user = create(:user)
+ create(:changeset, :user => user)
+ create(:changeset, :closed, :user => user)
get :list, :format => "html", :display_name => user.display_name
assert_response :success
##
# Checks the display of the user changesets listing for a private user
def test_list_private_user
- user = users(:normal_user)
+ private_user = create(:user, :data_public => false)
+ create(:changeset, :user => private_user)
+ create(:changeset, :closed, :user => private_user)
- get :list, :format => "html", :display_name => user.display_name
+ get :list, :format => "html", :display_name => private_user.display_name
assert_response :success
assert_template "history"
- xhr :get, :list, :format => "html", :display_name => user.display_name, :list => "1"
+ xhr :get, :list, :format => "html", :display_name => private_user.display_name, :list => "1"
assert_response :success
assert_template "list"
##
# Checks the display of the friends changesets listing
def test_list_friends
- user = users(:normal_user)
+ private_user = create(:user, :data_public => true)
+ friend = create(:friend, :befriender => private_user)
+ create(:changeset, :user => friend.befriendee)
get :list, :friends => true
assert_response :redirect
assert_redirected_to :controller => :user, :action => :login, :referer => friend_changesets_path
- session[:user] = user.id
+ session[:user] = private_user.id
get :list, :friends => true
assert_response :success
assert_response :success
assert_template "list"
- check_list_result(Changeset.where(:user => user.friend_users.identifiable))
+ check_list_result(Changeset.where(:user => private_user.friend_users.identifiable))
end
##
# Checks the display of the nearby user changesets listing
def test_list_nearby
- user = users(:normal_user)
+ private_user = create(:user, :data_public => false, :home_lat => 51.1, :home_lon => 1.0)
+ user = create(:user, :home_lat => 51.0, :home_lon => 1.0)
+ create(:changeset, :user => user)
get :list, :nearby => true
assert_response :redirect
assert_redirected_to :controller => :user, :action => :login, :referer => nearby_changesets_path
- session[:user] = user.id
+ session[:user] = private_user.id
get :list, :nearby => true
assert_response :success
##
# Checks the display of the user changesets feed
def test_feed_user
- user = users(:public_user)
+ user = create(:user)
+ create_list(:changeset, 3, :user => user, :num_changes => 4)
get :feed, :format => :atom, :display_name => user.display_name
assert_response :success
##
# create comment success
def test_create_comment_success
- basic_authorization(users(:public_user).email, "test")
+ user = create(:user)
+ user2 = create(:user)
+ private_user = create(:user, :data_public => false)
+ suspended_user = create(:user, :suspended)
+ deleted_user = create(:user, :deleted)
+ private_user_closed_changeset = create(:changeset, :closed, :user => private_user)
+
+ basic_authorization(user.email, "test")
assert_difference "ChangesetComment.count", 1 do
assert_no_difference "ActionMailer::Base.deliveries.size" do
- post :comment, :id => changesets(:normal_user_closed_change).id, :text => "This is a comment"
+ post :comment, :id => private_user_closed_changeset.id, :text => "This is a comment"
end
end
assert_response :success
+ changeset = create(:changeset, :closed, :user => private_user)
+ changeset.subscribers.push(private_user)
+ changeset.subscribers.push(user)
+ changeset.subscribers.push(suspended_user)
+ changeset.subscribers.push(deleted_user)
+
assert_difference "ChangesetComment.count", 1 do
assert_difference "ActionMailer::Base.deliveries.size", 1 do
- post :comment, :id => changesets(:normal_user_subscribed_change).id, :text => "This is a comment"
+ post :comment, :id => changeset.id, :text => "This is a comment"
end
end
assert_response :success
email = ActionMailer::Base.deliveries.first
assert_equal 1, email.to.length
- assert_equal "[OpenStreetMap] test2 has commented on one of your changesets", email.subject
- assert_equal "test@openstreetmap.org", email.to.first
+ assert_equal "[OpenStreetMap] #{user.display_name} has commented on one of your changesets", email.subject
+ assert_equal private_user.email, email.to.first
ActionMailer::Base.deliveries.clear
- basic_authorization(users(:second_public_user).email, "test")
+ basic_authorization(user2.email, "test")
assert_difference "ChangesetComment.count", 1 do
assert_difference "ActionMailer::Base.deliveries.size", 2 do
- post :comment, :id => changesets(:normal_user_subscribed_change).id, :text => "This is a comment"
+ post :comment, :id => changeset.id, :text => "This is a comment"
end
end
assert_response :success
- email = ActionMailer::Base.deliveries.find { |e| e.to.first == "test@openstreetmap.org" }
+ email = ActionMailer::Base.deliveries.find { |e| e.to.first == private_user.email }
assert_not_nil email
assert_equal 1, email.to.length
- assert_equal "[OpenStreetMap] pulibc_test2 has commented on one of your changesets", email.subject
+ assert_equal "[OpenStreetMap] #{user2.display_name} has commented on one of your changesets", email.subject
- email = ActionMailer::Base.deliveries.find { |e| e.to.first == "test@example.com" }
+ email = ActionMailer::Base.deliveries.find { |e| e.to.first == user.email }
assert_not_nil email
assert_equal 1, email.to.length
- assert_equal "[OpenStreetMap] pulibc_test2 has commented on a changeset you are interested in", email.subject
+ assert_equal "[OpenStreetMap] #{user2.display_name} has commented on a changeset you are interested in", email.subject
ActionMailer::Base.deliveries.clear
end
post :comment, :id => changesets(:normal_user_closed_change).id, :text => "This is a comment"
assert_response :unauthorized
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(create(:user).email, "test")
# bad changeset id
assert_no_difference "ChangesetComment.count" do
##
# test subscribe success
def test_subscribe_success
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(create(:user).email, "test")
changeset = changesets(:normal_user_closed_change)
assert_difference "changeset.subscribers.count", 1 do
##
# test subscribe fail
def test_subscribe_fail
+ user = create(:user)
+
# unauthorized
changeset = changesets(:normal_user_closed_change)
assert_no_difference "changeset.subscribers.count" do
end
assert_response :unauthorized
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(user.email, "test")
# bad changeset id
assert_no_difference "changeset.subscribers.count" do
# trying to subscribe when already subscribed
changeset = changesets(:normal_user_subscribed_change)
+ changeset.subscribers.push(user)
assert_no_difference "changeset.subscribers.count" do
post :subscribe, :id => changeset.id
end
##
# test unsubscribe success
def test_unsubscribe_success
- basic_authorization(users(:public_user).email, "test")
+ user = create(:user)
+ basic_authorization(user.email, "test")
changeset = changesets(:normal_user_subscribed_change)
+ changeset.subscribers.push(user)
assert_difference "changeset.subscribers.count", -1 do
post :unsubscribe, :id => changeset.id
end
assert_response :unauthorized
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(create(:user).email, "test")
# bad changeset id
assert_no_difference "changeset.subscribers.count" do
# test hide comment fail
def test_hide_comment_fail
# unauthorized
- comment = changeset_comments(:normal_comment_1)
+ comment = create(:changeset_comment)
assert_equal true, comment.visible
post :hide_comment, :id => comment.id
assert_response :unauthorized
assert_equal true, comment.reload.visible
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(create(:user).email, "test")
# not a moderator
post :hide_comment, :id => comment.id
assert_response :forbidden
assert_equal true, comment.reload.visible
- basic_authorization(users(:moderator_user).email, "test")
+ basic_authorization(create(:moderator_user).email, "test")
# bad comment id
post :hide_comment, :id => 999111
##
# test hide comment succes
def test_hide_comment_success
- comment = changeset_comments(:normal_comment_1)
+ comment = create(:changeset_comment)
assert_equal true, comment.visible
- basic_authorization(users(:moderator_user).email, "test")
+ basic_authorization(create(:moderator_user).email, "test")
post :hide_comment, :id => comment.id
assert_response :success
# test unhide comment fail
def test_unhide_comment_fail
# unauthorized
- comment = changeset_comments(:hidden_comment)
+ comment = create(:changeset_comment, :visible => false)
assert_equal false, comment.visible
post :unhide_comment, :id => comment.id
assert_response :unauthorized
assert_equal false, comment.reload.visible
- basic_authorization(users(:public_user).email, "test")
+ basic_authorization(create(:user).email, "test")
# not a moderator
post :unhide_comment, :id => comment.id
assert_response :forbidden
assert_equal false, comment.reload.visible
- basic_authorization(users(:moderator_user).email, "test")
+ basic_authorization(create(:moderator_user).email, "test")
# bad comment id
post :unhide_comment, :id => 999111
##
# test unhide comment succes
def test_unhide_comment_success
- comment = changeset_comments(:hidden_comment)
+ comment = create(:changeset_comment, :visible => false)
assert_equal false, comment.visible
- basic_authorization(users(:moderator_user).email, "test")
+ basic_authorization(create(:moderator_user).email, "test")
post :unhide_comment, :id => comment.id
assert_response :success
##
# test comments feed
def test_comments_feed
+ create_list(:changeset_comment, 3, :changeset_id => changesets(:normal_user_closed_change).id)
+
get :comments_feed, :format => "rss"
assert_response :success
assert_equal "application/rss+xml", @response.content_type
assert changesets.size <= 20
assert_select "feed", :count => [changesets.size, 1].min do
- assert_select "entry", :count => changesets.size
+ assert_select "> title", :count => 1, :text => /^Changesets/
+ assert_select "> entry", :count => changesets.size
changesets.each do |changeset|
- assert_select "entry > id", changeset_url(:id => changeset.id)
+ assert_select "> entry > id", changeset_url(:id => changeset.id)
end
end
end
projects / rails.git / blobdiff