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'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
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'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
put :create
assert_response :success, "Creation of changeset did not return sucess status"
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
assert_select "osm>changeset>discussion>comment", 0
changeset_id = changesets(:normal_user_closed_change).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"
assert_response :unauthorized
## Try using the non-public user
- basic_authorization users(:normal_user).email, "test"
+ basic_authorization changesets(:normal_user_first_change).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"
+ basic_authorization changesets(:public_user_first_change).user.email, "test"
cs_id = changesets(:public_user_first_change).id
put :close, :id => cs_id
##
# test that a different user can't close another user's changeset
def test_close_invalid
- basic_authorization users(:public_user).email, "test"
+ basic_authorization create(:user).email, "test"
put :close, :id => changesets(:normal_user_first_change).id
assert_response :conflict
##
# test that you can't close using another method
def test_close_method_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
get :close, :id => cs_id
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
"shouldnn't be able to upload a simple valid diff to changeset: #{@response.body}"
## Now try with a private user
- basic_authorization users(:normal_user).email, "test"
+ basic_authorization changesets(:normal_user_first_change).user.email, "test"
changeset_id = changesets(:normal_user_first_change).id
# simple diff to change a node, way and relation by removing
"can't upload a simple valid diff to changeset: #{@response.body}"
## Now try with the public user
- 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
# simple diff to change a node, way and relation by removing
##
# upload something which creates new objects using placeholders
def test_upload_create_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
# simple diff to create a node way and relation using placeholders
# 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>" +
- "<tag k='created_by' v='osm test suite checking changesets'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
assert_difference "Changeset.count", 1 do
put :create
end
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>"
# check that the changeset bbox is within bounds
cs = Changeset.find(changeset_id)
assert cs.min_lon >= -180 * GeoRecord::SCALE, "Minimum longitude (#{cs.min_lon / GeoRecord::SCALE}) should be >= -180 to be valid."
- assert cs.max_lon <= 180 * GeoRecord::SCALE, "Maximum longitude (#{cs.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
- assert cs.min_lat >= -90 * GeoRecord::SCALE, "Minimum latitude (#{cs.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
- assert cs.max_lat >= 90 * GeoRecord::SCALE, "Maximum latitude (#{cs.max_lat / GeoRecord::SCALE}) should be <= 90 to be valid."
+ assert cs.max_lon <= 180 * GeoRecord::SCALE, "Maximum longitude (#{cs.max_lon / GeoRecord::SCALE}) should be <= 180 to be valid."
+ assert cs.min_lat >= -90 * GeoRecord::SCALE, "Minimum latitude (#{cs.min_lat / GeoRecord::SCALE}) should be >= -90 to be valid."
+ assert cs.max_lat >= 90 * GeoRecord::SCALE, "Maximum latitude (#{cs.max_lat / GeoRecord::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 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'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
put :create
assert_response :success
changeset_id = @response.body.to_i
diff.root = XML::Node.new "osmChange"
modify = XML::Node.new "modify"
xml_old_node = old_node.to_xml_node
- xml_old_node["lat"] = (2.0).to_s
- xml_old_node["lon"] = (2.0).to_s
+ xml_old_node["lat"] = 2.0.to_s
+ xml_old_node["lon"] = 2.0.to_s
xml_old_node["changeset"] = changeset_id.to_s
modify << xml_old_node
diff.root << modify
##
# 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'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
put :create
assert_response :success
changeset_id = @response.body.to_i
##
# 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>" +
- "<tag k='created_by' v='osm test suite checking changesets'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
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>" +
- "<tag k='created_by' v='osm test suite checking changesets'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
put :create
assert_response :success
changeset_id = @response.body.to_i
#
# 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>" +
- "<tag k='created_by' v='osm test suite checking changesets'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
put :create
assert_response :success
changeset_id = @response.body.to_i
# 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>" +
- "<tag k='created_by' v='osm test suite checking changesets'/>" +
- "</changeset></osm>"
+ "<tag k='created_by' v='osm test suite checking changesets'/>" +
+ "</changeset></osm>"
put :create
assert_response :success
changeset_id = @response.body.to_i
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>"
# NOTE: the include method doesn't over-expand, like inserting
# a real method does. this is because we expect the client to
# know what it is doing!
- check_after_include(changeset_id, 1, 1, [1, 1, 1, 1])
- check_after_include(changeset_id, 3, 3, [1, 1, 3, 3])
- check_after_include(changeset_id, 4, 2, [1, 1, 4, 3])
- check_after_include(changeset_id, 2, 2, [1, 1, 4, 3])
- check_after_include(changeset_id, -1, -1, [-1, -1, 4, 3])
- check_after_include(changeset_id, -2, 5, [-2, -1, 4, 5])
+ check_after_include(changeset_id, 1, 1, [1, 1, 1, 1])
+ check_after_include(changeset_id, 3, 3, [1, 1, 3, 3])
+ check_after_include(changeset_id, 4, 2, [1, 1, 4, 3])
+ check_after_include(changeset_id, 2, 2, [1, 1, 4, 3])
+ check_after_include(changeset_id, -1, -1, [-1, -1, 4, 3])
+ check_after_include(changeset_id, -2, 5, [-2, -1, 4, 5])
end
##
# test 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>"
get :query, :closed => "true"
assert_response :success, "can't get changesets by closed-ness"
- assert_changesets [3, 5, 6, 7, 8]
+ assert_changesets [3, 5, 6, 7, 8, 9]
get :query, :closed => "true", :user => users(:normal_user).id
assert_response :success, "can't get changesets by closed-ness and user"
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>"
assert_response :success
assert_template "history"
- get :list, :format => "html", :display_name => user.display_name, :list => "1"
+ xhr :get, :list, :format => "html", :display_name => user.display_name, :list => "1"
assert_response :success
assert_template "list"
assert_response :success
assert_template "history"
- get :list, :format => "html", :display_name => user.display_name, :list => "1"
+ xhr :get, :list, :format => "html", :display_name => user.display_name, :list => "1"
assert_response :success
assert_template "list"
assert_response :not_found
assert_template "user/no_such_user"
- get :list, :format => "html", :display_name => "Some random user", :list => "1"
+ xhr :get, :list, :format => "html", :display_name => "Some random user", :list => "1"
assert_response :not_found
assert_template "user/no_such_user"
end
assert_response :success
assert_template "history"
- get :list, :friends => true, :list => "1"
+ xhr :get, :list, :friends => true, :list => "1"
assert_response :success
assert_template "list"
assert_response :success
assert_template "history"
- get :list, :nearby => true, :list => "1"
+ xhr :get, :list, :nearby => true, :list => "1"
assert_response :success
assert_template "list"
check_list_result(Changeset.where(:user => user.nearby))
end
+ ##
+ # Check that we can't request later pages of the changesets list
+ def test_list_max_id
+ xhr :get, :list, :format => "html", :max_id => 4
+ assert_response :success
+ assert_template "history"
+ assert_template :layout => "xhr"
+ assert_select "h2", :text => "Changesets", :count => 1
+
+ xhr :get, :list, :format => "html", :list => "1", :max_id => 4
+ assert_response :success
+ assert_template "list"
+
+ check_list_result(Changeset.where("id <= 4"))
+ end
+
##
# This should display the last 20 changesets closed
def test_feed
end
assert_response :success
+ changeset = changesets(:normal_user_subscribed_change)
+ changeset.subscribers.push(users(:normal_user))
+ changeset.subscribers.push(users(:public_user))
+ changeset.subscribers.push(users(:suspended_user))
+ changeset.subscribers.push(users(: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
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
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)
- assert("comment.visible") do
- post :hide_comment, :id => comment.id
- assert_response :unauthorized
- end
+ comment = create(:changeset_comment)
+ assert_equal true, comment.visible
- basic_authorization(users(:public_user).email, "test")
+ post :hide_comment, :id => comment.id
+ assert_response :unauthorized
+ assert_equal true, comment.reload.visible
+
+ basic_authorization(create(:user).email, "test")
# not a moderator
- assert("comment.visible") do
- post :hide_comment, :id => comment.id
- assert_response :forbidden
- end
+ 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
assert_response :not_found
+ assert_equal true, comment.reload.visible
end
##
# 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")
- assert("!comment.visible") do
- post :hide_comment, :id => comment.id
- end
+ post :hide_comment, :id => comment.id
assert_response :success
+ assert_equal false, comment.reload.visible
end
##
# test unhide comment fail
def test_unhide_comment_fail
# unauthorized
- comment = changeset_comments(:normal_comment_1)
- assert("comment.visible") do
- post :unhide_comment, :id => comment.id
- assert_response :unauthorized
- end
+ comment = create(:changeset_comment, :visible => false)
+ assert_equal false, comment.visible
- basic_authorization(users(:public_user).email, "test")
+ post :unhide_comment, :id => comment.id
+ assert_response :unauthorized
+ assert_equal false, comment.reload.visible
+
+ basic_authorization(create(:user).email, "test")
# not a moderator
- assert("comment.visible") do
- post :unhide_comment, :id => comment.id
- assert_response :forbidden
- end
+ 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
assert_response :not_found
+ assert_equal false, comment.reload.visible
end
##
# test unhide comment succes
def test_unhide_comment_success
- comment = changeset_comments(:normal_comment_1)
+ 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")
- assert("!comment.visible") do
- post :unhide_comment, :id => comment.id
- end
+ post :unhide_comment, :id => comment.id
assert_response :success
+ assert_equal true, comment.reload.visible
end
##
# 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
end
end
+ get :comments_feed, :format => "rss", :limit => 2
+ assert_response :success
+ assert_equal "application/rss+xml", @response.content_type
+ assert_select "rss", :count => 1 do
+ assert_select "channel", :count => 1 do
+ assert_select "item", :count => 2
+ end
+ end
+
get :comments_feed, :id => changesets(:normal_user_closed_change), :format => "rss"
assert_response :success
assert_equal "application/rss+xml", @response.content_type
end
end
+ ##
+ # test comments feed
+ def test_comments_feed_bad_limit
+ get :comments_feed, :format => "rss", :limit => 0
+ assert_response :bad_request
+
+ get :comments_feed, :format => "rss", :limit => 100001
+ assert_response :bad_request
+ end
+
private
##
# check the result of a list
def check_list_result(changesets)
changesets = changesets.where("num_changes > 0")
- .order(:created_at => :desc)
- .limit(20)
+ .order(:created_at => :desc)
+ .limit(20)
assert changesets.size <= 20
assert_select "ol.changesets", :count => [changesets.size, 1].min do
# check the result of a feed
def check_feed_result(changesets)
changesets = changesets.where("num_changes > 0")
- .order(:created_at => :desc)
- .limit(20)
+ .order(:created_at => :desc)
+ .limit(20)
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