cst1/openstreetmap-website
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Pass the user object, rather than the id, for sessions.

Browse source 
This simplifies the code slightly.
This commit is contained in:
Andy Allan 2017-02-22 09:57:18 +00:00
parent 1dc2ff7d57
commit 7d9d496da2
5 changed files with 130 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

4
test/controllers/changeset_controller_test.rb
View file

@ -1578,11 +1578,11 @@ EOF
assert_response :success, "can't get changesets by closed-ness"
assert_changesets [3, 5, 6, 7, 8, 9]
get :query, :closed => "true", :user => users(:normal_user).id
get :query, :closed => "true", :user => users(:normal_user)
assert_response :success, "can't get changesets by closed-ness and user"
assert_changesets [3, 6, 8]
get :query, :closed => "true", :user => users(:public_user).id
get :query, :closed => "true", :user => users(:public_user)
assert_response :success, "can't get changesets by closed-ness and user"
assert_changesets [7]

62
test/controllers/diary_entry_controller_test.rb
View file

@ -109,7 +109,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
def test_new_form
# Now try again when logged in
get :new, {}, { :user => create(:normal_user).id }
get :new, {}, { :user => create(:normal_user) }
assert_response :success
assert_select "title", :text => /New Diary Entry/, :count => 1
assert_select "div.content-heading", :count => 1 do
@ -231,7 +231,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_equal "suspended", User.find(user.id).status
# Follow the redirect
get :list, { :display_name => user.display_name }, { :user => user.id }
get :list, { :display_name => user.display_name }, { :user => user }
assert_response :redirect
assert_redirected_to :controller => :user, :action => :suspended
end
@ -249,7 +249,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_redirected_to :controller => :user, :action => :login, :referer => "/user/#{URI.encode(entry.user.display_name)}/diary/#{entry.id}/edit"
# Verify that you get a not found error, when you pass a bogus id
get :edit, { :display_name => entry.user.display_name, :id => 9999 }, { :user => entry.user.id }
get :edit, { :display_name => entry.user.display_name, :id => 9999 }, { :user => entry.user }
assert_response :not_found
assert_select "div.content-heading", :count => 1 do
assert_select "h2", :text => "No entry with the id: 9999", :count => 1
@ -257,13 +257,13 @@ class DiaryEntryControllerTest < ActionController::TestCase
# Verify that you get redirected to view if you are not the user
# that created the entry
get :edit, { :display_name => entry.user.display_name, :id => entry.id }, { :user => other_user.id }
get :edit, { :display_name => entry.user.display_name, :id => entry.id }, { :user => other_user }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => entry.user.display_name, :id => entry.id
# Now pass the id, and check that you can edit it, when using the same
# user as the person who created the entry
get :edit, { :display_name => entry.user.display_name, :id => entry.id }, { :user => entry.user.id }
get :edit, { :display_name => entry.user.display_name, :id => entry.id }, { :user => entry.user }
assert_response :success
assert_select "title", :text => /Edit diary entry/, :count => 1
assert_select "div.content-heading", :count => 1 do
@ -297,7 +297,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_redirected_to :action => :view, :display_name => entry.user.display_name, :id => entry.id
# Now check that the new data is rendered, when logged in
get :view, { :display_name => entry.user.display_name, :id => entry.id }, { :user => entry.user.id }
get :view, { :display_name => entry.user.display_name, :id => entry.id }, { :user => entry.user }
assert_response :success
assert_template "diary_entry/view"
assert_select "title", :text => /Users' diaries | /, :count => 1
@ -316,7 +316,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
end
# and when not logged in as the user who wrote the entry
get :view, { :display_name => entry.user.display_name, :id => entry.id }, { :user => entry.user.id }
get :view, { :display_name => entry.user.display_name, :id => entry.id }, { :user => entry.user }
assert_response :success
assert_template "diary_entry/view"
assert_select "title", :text => /Users' diaries | /, :count => 1
@ -339,7 +339,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
def test_edit_i18n
user = create(:normal_user)
diary_entry = create(:diary_entry, :language_code => "en", :user => user)
get :edit, { :display_name => user.display_name, :id => diary_entry.id }, { :user => user.id }
get :edit, { :display_name => user.display_name, :id => diary_entry.id }, { :user => user }
assert_response :success
assert_select "span[class=translation_missing]", false, "Missing translation in edit diary entry"
end
@ -354,19 +354,19 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_response :forbidden
# Verify that you get a not found error, when you pass a bogus id
post :comment, { :display_name => entry.user.display_name, :id => 9999 }, { :user => other_user.id }
post :comment, { :display_name => entry.user.display_name, :id => 9999 }, { :user => other_user }
assert_response :not_found
assert_select "div.content-heading", :count => 1 do
assert_select "h2", :text => "No entry with the id: 9999", :count => 1
end
post :subscribe, { :id => entry.id, :display_name => entry.user.display_name }, { :user => user.id }
post :subscribe, { :id => entry.id, :display_name => entry.user.display_name }, { :user => user }
# Now try an invalid comment with an empty body
assert_no_difference "ActionMailer::Base.deliveries.size" do
assert_no_difference "DiaryComment.count" do
assert_no_difference "entry.subscribers.count" do
post :comment, { :display_name => entry.user.display_name, :id => entry.id, :diary_comment => { :body => "" } }, { :user => other_user.id }
post :comment, { :display_name => entry.user.display_name, :id => entry.id, :diary_comment => { :body => "" } }, { :user => other_user }
end
end
end
@ -377,7 +377,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_difference "ActionMailer::Base.deliveries.size", entry.subscribers.count do
assert_difference "DiaryComment.count", 1 do
assert_difference "entry.subscribers.count", 1 do
post :comment, { :display_name => entry.user.display_name, :id => entry.id, :diary_comment => { :body => "New comment" } }, { :user => other_user.id }
post :comment, { :display_name => entry.user.display_name, :id => entry.id, :diary_comment => { :body => "New comment" } }, { :user => other_user }
end
end
end
@ -411,7 +411,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
# Find the entry to comment on
entry = create(:diary_entry, :user => user)
post :subscribe, { :id => entry.id, :display_name => entry.user.display_name }, { :user => user.id }
post :subscribe, { :id => entry.id, :display_name => entry.user.display_name }, { :user => user }
# Generate some spammy content
spammy_text = 1.upto(50).map { |n| "http://example.com/spam#{n}" }.join(" ")
@ -419,7 +419,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
# Try creating a spammy comment
assert_difference "ActionMailer::Base.deliveries.size", 1 do
assert_difference "DiaryComment.count", 1 do
post :comment, { :display_name => entry.user.display_name, :id => entry.id, :diary_comment => { :body => spammy_text } }, { :user => other_user.id }
post :comment, { :display_name => entry.user.display_name, :id => entry.id, :diary_comment => { :body => spammy_text } }, { :user => other_user }
end
end
assert_response :redirect
@ -437,7 +437,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_equal "suspended", User.find(other_user.id).status
# Follow the redirect
get :list, { :display_name => user.display_name }, { :user => other_user.id }
get :list, { :display_name => user.display_name }, { :user => other_user }
assert_response :redirect
assert_redirected_to :controller => :user, :action => :suspended
@ -488,9 +488,9 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_redirected_to :controller => :user, :action => :login, :referer => "/diary/friends"
# Try a list of diary entries for your friends when logged in
get :list, { :friends => true }, { :user => user.id }
get :list, { :friends => true }, { :user => user }
check_diary_list diary_entry
get :list, { :friends => true }, { :user => other_user.id }
get :list, { :friends => true }, { :user => other_user }
check_diary_list
end
@ -506,9 +506,9 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_redirected_to :controller => :user, :action => :login, :referer => "/diary/nearby"
# Try a list of diary entries for nearby users when logged in
get :list, { :nearby => true }, { :user => nearby_user.id }
get :list, { :nearby => true }, { :user => nearby_user }
check_diary_list diary_entry
get :list, { :nearby => true }, { :user => user.id }
get :list, { :nearby => true }, { :user => user }
check_diary_list
end
@ -664,13 +664,13 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_equal true, DiaryEntry.find(diary_entry.id).visible
# Now try as a normal user
post :hide, { :display_name => user.display_name, :id => diary_entry.id }, { :user => user.id }
post :hide, { :display_name => user.display_name, :id => diary_entry.id }, { :user => user }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => user.display_name, :id => diary_entry.id
assert_equal true, DiaryEntry.find(diary_entry.id).visible
# Finally try as an administrator
post :hide, { :display_name => user.display_name, :id => diary_entry.id }, { :user => create(:administrator_user, :status => "confirmed", :terms_seen => true).id }
post :hide, { :display_name => user.display_name, :id => diary_entry.id }, { :user => create(:administrator_user, :status => "confirmed", :terms_seen => true) }
assert_response :redirect
assert_redirected_to :action => :list, :display_name => user.display_name
assert_equal false, DiaryEntry.find(diary_entry.id).visible
@ -687,13 +687,13 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_equal true, DiaryComment.find(diary_comment.id).visible
# Now try as a normal user
post :hidecomment, { :display_name => user.display_name, :id => diary_entry.id, :comment => diary_comment.id }, { :user => user.id }
post :hidecomment, { :display_name => user.display_name, :id => diary_entry.id, :comment => diary_comment.id }, { :user => user }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => user.display_name, :id => diary_entry.id
assert_equal true, DiaryComment.find(diary_comment.id).visible
# Finally try as an administrator
post :hidecomment, { :display_name => user.display_name, :id => diary_entry.id, :comment => diary_comment.id }, { :user => administrator_user.id }
post :hidecomment, { :display_name => user.display_name, :id => diary_entry.id, :comment => diary_comment.id }, { :user => administrator_user }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => user.display_name, :id => diary_entry.id
assert_equal false, DiaryComment.find(diary_comment.id).visible
@ -737,7 +737,7 @@ class DiaryEntryControllerTest < ActionController::TestCase
diary_entry = create(:diary_entry, :user => user)
assert_difference "diary_entry.subscribers.count", 1 do
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user.id }
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user }
end
assert_response :redirect
end
@ -755,13 +755,13 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_response :forbidden
# bad diary id
post :subscribe, { :id => 999111, :display_name => "username" }, { :user => other_user.id }
post :subscribe, { :id => 999111, :display_name => "username" }, { :user => other_user }
assert_response :not_found
# trying to subscribe when already subscribed
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user.id }
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user }
assert_no_difference "diary_entry.subscribers.count" do
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user.id }
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user }
end
end
@ -771,9 +771,9 @@ class DiaryEntryControllerTest < ActionController::TestCase
diary_entry = create(:diary_entry, :user => user)
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user.id }
post :subscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user }
assert_difference "diary_entry.subscribers.count", -1 do
post :unsubscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user.id }
post :unsubscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user }
end
assert_response :redirect
end
@ -791,12 +791,12 @@ class DiaryEntryControllerTest < ActionController::TestCase
assert_response :forbidden
# bad diary id
post :unsubscribe, { :id => 999111, :display_name => "username" }, { :user => other_user.id }
post :unsubscribe, { :id => 999111, :display_name => "username" }, { :user => other_user }
assert_response :not_found
# trying to unsubscribe when not subscribed
assert_no_difference "diary_entry.subscribers.count" do
post :unsubscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user.id }
post :unsubscribe, { :id => diary_entry.id, :display_name => diary_entry.user.display_name }, { :user => other_user }
end
end

30
test/controllers/site_controller_test.rb
View file

@ -172,7 +172,7 @@ class SiteControllerTest < ActionController::TestCase
# Test the right editor gets used when the user hasn't set a preference
def test_edit_without_preference
get :edit, nil, :user => users(:public_user).id
get :edit, nil, :user => users(:public_user)
assert_response :success
assert_template "edit"
assert_template :partial => "_#{DEFAULT_EDITOR}", :count => 1
@ -184,7 +184,7 @@ class SiteControllerTest < ActionController::TestCase
user.preferred_editor = "id"
user.save!
get :edit, nil, :user => user.id
get :edit, nil, :user => user
assert_response :success
assert_template "edit"
assert_template :partial => "_id", :count => 1
@ -193,7 +193,7 @@ class SiteControllerTest < ActionController::TestCase
user.preferred_editor = "potlatch2"
user.save!
get :edit, nil, :user => user.id
get :edit, nil, :user => user
assert_response :success
assert_template "edit"
assert_template :partial => "_potlatch2", :count => 1
@ -202,7 +202,7 @@ class SiteControllerTest < ActionController::TestCase
user.preferred_editor = "potlatch"
user.save!
get :edit, nil, :user => user.id
get :edit, nil, :user => user
assert_response :success
assert_template "edit"
assert_template :partial => "_potlatch", :count => 1
@ -211,29 +211,29 @@ class SiteControllerTest < ActionController::TestCase
user.preferred_editor = "remote"
user.save!
get :edit, nil, :user => user.id
get :edit, nil, :user => user
assert_response :success
assert_template "index"
end
# Test the right editor gets used when the URL has an override
def test_edit_with_override
get :edit, { :editor => "id" }, { :user => users(:public_user).id }
get :edit, { :editor => "id" }, { :user => users(:public_user) }
assert_response :success
assert_template "edit"
assert_template :partial => "_id", :count => 1
get :edit, { :editor => "potlatch2" }, { :user => users(:public_user).id }
get :edit, { :editor => "potlatch2" }, { :user => users(:public_user) }
assert_response :success
assert_template "edit"
assert_template :partial => "_potlatch2", :count => 1
get :edit, { :editor => "potlatch" }, { :user => users(:public_user).id }
get :edit, { :editor => "potlatch" }, { :user => users(:public_user) }
assert_response :success
assert_template "edit"
assert_template :partial => "_potlatch", :count => 1
get :edit, { :editor => "remote" }, { :user => users(:public_user).id }
get :edit, { :editor => "remote" }, { :user => users(:public_user) }
assert_response :success
assert_template "index"
end
@ -243,7 +243,7 @@ class SiteControllerTest < ActionController::TestCase
user = users(:public_user)
node = current_nodes(:visible_node)
get :edit, { :node => node.id }, { :user => user.id }
get :edit, { :node => node.id }, { :user => user }
assert_response :success
assert_template "edit"
assert_equal 1.0, assigns(:lat)
@ -256,7 +256,7 @@ class SiteControllerTest < ActionController::TestCase
user = users(:public_user)
way = current_ways(:visible_way)
get :edit, { :way => way.id }, { :user => user.id }
get :edit, { :way => way.id }, { :user => user }
assert_response :success
assert_template "edit"
assert_equal 3.0, assigns(:lat)
@ -271,7 +271,7 @@ class SiteControllerTest < ActionController::TestCase
n.comments.create(:author_id => user.id)
end
get :edit, { :note => note.id }, { :user => user.id }
get :edit, { :note => note.id }, { :user => user }
assert_response :success
assert_template "edit"
assert_equal 1.0, assigns(:lat)
@ -284,7 +284,7 @@ class SiteControllerTest < ActionController::TestCase
user = users(:public_user)
gpx = create(:trace, :latitude => 1, :longitude => 1)
get :edit, { :gpx => gpx.id }, { :user => user.id }
get :edit, { :gpx => gpx.id }, { :user => user }
assert_response :success
assert_template "edit"
assert_equal 1.0, assigns(:lat)
@ -317,7 +317,7 @@ class SiteControllerTest < ActionController::TestCase
assert_response :redirect
assert_redirected_to :controller => :user, :action => :login, :referer => "/welcome"
get :welcome, nil, :user => users(:public_user).id
get :welcome, nil, :user => users(:public_user)
assert_response :success
assert_template "welcome"
end
@ -377,7 +377,7 @@ class SiteControllerTest < ActionController::TestCase
# Test the id frame
def test_id
get :id, nil, :user => users(:public_user).id
get :id, nil, :user => users(:public_user)
assert_response :success
assert_template "id"
assert_template :layout => false

102
test/controllers/trace_controller_test.rb
View file

@ -194,11 +194,11 @@ class TraceControllerTest < ActionController::TestCase
check_trace_list [trace_a]
# Should see more when we are logged in
get :list, {}, { :user => users(:public_user).id }
get :list, {}, { :user => users(:public_user) }
check_trace_list [trace_d, trace_c, trace_b, trace_a]
# Again, we should see more when we are logged in
get :list, { :tag => "London" }, { :user => users(:public_user).id }
get :list, { :tag => "London" }, { :user => users(:public_user) }
check_trace_list [trace_c, trace_a]
end
@ -216,11 +216,11 @@ class TraceControllerTest < ActionController::TestCase
assert_redirected_to :controller => "user", :action => "login", :referer => "/traces/mine"
# Now try when logged in
get :mine, {}, { :user => users(:public_user).id }
get :mine, {}, { :user => users(:public_user) }
assert_redirected_to :controller => "trace", :action => "list", :display_name => users(:public_user).display_name
# Fetch the actual list
get :list, { :display_name => users(:public_user).display_name }, { :user => users(:public_user).id }
get :list, { :display_name => users(:public_user).display_name }, { :user => users(:public_user) }
check_trace_list [trace_b]
end
@ -241,15 +241,15 @@ class TraceControllerTest < ActionController::TestCase
check_trace_list [trace_b]
# Should still see only public ones when authenticated as another user
get :list, { :display_name => users(:public_user).display_name }, { :user => users(:normal_user).id }
get :list, { :display_name => users(:public_user).display_name }, { :user => users(:normal_user) }
check_trace_list [trace_b]
# Should see all traces when authenticated as the target user
get :list, { :display_name => users(:public_user).display_name }, { :user => users(:public_user).id }
get :list, { :display_name => users(:public_user).display_name }, { :user => users(:public_user) }
check_trace_list [trace_c, trace_b]
# Should only see traces with the correct tag when a tag is specified
get :list, { :display_name => users(:public_user).display_name, :tag => "London" }, { :user => users(:public_user).id }
get :list, { :display_name => users(:public_user).display_name, :tag => "London" }, { :user => users(:public_user) }
check_trace_list [trace_c]
# Should get an error if the user does not exist
@ -286,11 +286,11 @@ class TraceControllerTest < ActionController::TestCase
check_trace_view public_trace_file
# Now with some other user, which should work since the trace is public
get :view, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
get :view, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user) }
check_trace_view public_trace_file
# And finally we should be able to do it with the owner of the trace
get :view, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
get :view, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user) }
check_trace_view public_trace_file
end
@ -304,12 +304,12 @@ class TraceControllerTest < ActionController::TestCase
assert_redirected_to :action => :list
# Now with some other user, which should not work since the trace is anon
get :view, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user).id }
get :view, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user) }
assert_response :redirect
assert_redirected_to :action => :list
# And finally we should be able to do it with the owner of the trace
get :view, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
get :view, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user) }
check_trace_view anon_trace_file
end
@ -323,12 +323,12 @@ class TraceControllerTest < ActionController::TestCase
assert_redirected_to :action => :list
# Now with some other user
get :view, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
get :view, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user) }
assert_response :redirect
assert_redirected_to :action => :list
# And finally we should not be able to view a deleted trace
get :view, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
get :view, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user) }
assert_response :redirect
assert_redirected_to :action => :list
end
@ -342,11 +342,11 @@ class TraceControllerTest < ActionController::TestCase
check_trace_data public_trace_file
# Now with some other user, which should work since the trace is public
get :data, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
get :data, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user) }
check_trace_data public_trace_file
# And finally we should be able to do it with the owner of the trace
get :data, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
get :data, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user) }
check_trace_data public_trace_file
end
@ -376,11 +376,11 @@ class TraceControllerTest < ActionController::TestCase
assert_response :not_found
# Now with some other user, which shouldn't work since the trace is anon
get :data, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user).id }
get :data, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user) }
assert_response :not_found
# And finally we should be able to do it with the owner of the trace
get :data, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
get :data, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user) }
check_trace_data anon_trace_file
end
@ -393,11 +393,11 @@ class TraceControllerTest < ActionController::TestCase
assert_response :not_found
# Now with a trace that has never existed
get :data, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
get :data, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user) }
assert_response :not_found
# Now with a trace that has been deleted
get :data, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
get :data, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user) }
assert_response :not_found
end
@ -410,11 +410,11 @@ class TraceControllerTest < ActionController::TestCase
check_trace_picture public_trace_file
# Now with some other user, which should work since the trace is public
get :picture, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
get :picture, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user) }
check_trace_picture public_trace_file
# And finally we should be able to do it with the owner of the trace
get :picture, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
get :picture, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user) }
check_trace_picture public_trace_file
end
@ -427,11 +427,11 @@ class TraceControllerTest < ActionController::TestCase
assert_response :forbidden
# Now with some other user, which shouldn't work since the trace is anon
get :picture, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user).id }
get :picture, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user) }
assert_response :forbidden
# And finally we should be able to do it with the owner of the trace
get :picture, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
get :picture, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user) }
check_trace_picture anon_trace_file
end
@ -442,12 +442,12 @@ class TraceControllerTest < ActionController::TestCase
assert_response :not_found
# Now with some other user, which should work since the trace is public
get :picture, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
get :picture, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user) }
assert_response :not_found
# And finally we should not be able to do it with a deleted trace
deleted_trace_file = create(:trace, :deleted)
get :picture, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
get :picture, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user) }
assert_response :not_found
end
@ -460,11 +460,11 @@ class TraceControllerTest < ActionController::TestCase
check_trace_icon public_trace_file
# Now with some other user, which should work since the trace is public
get :icon, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
get :icon, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user) }
check_trace_icon public_trace_file
# And finally we should be able to do it with the owner of the trace
get :icon, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
get :icon, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user) }
check_trace_icon public_trace_file
end
@ -477,11 +477,11 @@ class TraceControllerTest < ActionController::TestCase
assert_response :forbidden
# Now with some other user, which shouldn't work since the trace is anon
get :icon, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user).id }
get :icon, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:normal_user) }
assert_response :forbidden
# And finally we should be able to do it with the owner of the trace
get :icon, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
get :icon, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user) }
check_trace_icon anon_trace_file
end
@ -492,12 +492,12 @@ class TraceControllerTest < ActionController::TestCase
assert_response :not_found
# Now with some other user
get :icon, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
get :icon, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user) }
assert_response :not_found
# And finally we should not be able to do it with a deleted trace
deleted_trace_file = create(:trace, :deleted)
get :icon, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
get :icon, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user) }
assert_response :not_found
end
@ -510,20 +510,20 @@ class TraceControllerTest < ActionController::TestCase
# Now authenticated as a user with gps.trace.visibility set
create(:user_preference, :user => users(:public_user), :k => "gps.trace.visibility", :v => "identifiable")
get :create, {}, { :user => users(:public_user).id }
get :create, {}, { :user => users(:public_user) }
assert_response :success
assert_template :create
assert_select "select#trace_visibility option[value=identifiable][selected]", 1
# Now authenticated as a user with gps.trace.public set
create(:user_preference, :user => users(:second_public_user), :k => "gps.trace.public", :v => "default")
get :create, {}, { :user => users(:second_public_user).id }
get :create, {}, { :user => users(:second_public_user) }
assert_response :success
assert_template :create
assert_select "select#trace_visibility option[value=public][selected]", 1
# Now authenticated as a user with no preferences
get :create, {}, { :user => users(:normal_user).id }
get :create, {}, { :user => users(:normal_user) }
assert_response :success
assert_template :create
assert_select "select#trace_visibility option[value=private][selected]", 1
@ -542,7 +542,7 @@ class TraceControllerTest < ActionController::TestCase
# Now authenticated
create(:user_preference, :user => users(:public_user), :k => "gps.trace.visibility", :v => "identifiable")
assert_not_equal "trackable", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
post :create, { :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" } }, { :user => users(:public_user).id }
post :create, { :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" } }, { :user => users(:public_user) }
assert_response :redirect
assert_redirected_to :action => :list, :display_name => users(:public_user).display_name
assert_match /file has been uploaded/, flash[:notice]
@ -568,19 +568,19 @@ class TraceControllerTest < ActionController::TestCase
assert_redirected_to :controller => :user, :action => :login, :referer => trace_edit_path(:display_name => users(:normal_user).display_name, :id => public_trace_file.id)
# Now with some other user, which should fail
get :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
get :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user) }
assert_response :forbidden
# Now with a trace which doesn't exist
get :edit, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
get :edit, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user) }
assert_response :not_found
# Now with a trace which has been deleted
get :edit, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
get :edit, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user) }
assert_response :not_found
# Finally with a trace that we are allowed to edit
get :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
get :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user) }
assert_response :success
end
@ -594,19 +594,19 @@ class TraceControllerTest < ActionController::TestCase
assert_response :forbidden
# Now with some other user, which should fail
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user) }
assert_response :forbidden
# Now with a trace which doesn't exist
post :edit, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
post :edit, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user) }
assert_response :not_found
# Now with a trace which has been deleted
post :edit, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
post :edit, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user) }
assert_response :not_found
# Finally with a trace that we are allowed to edit
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user) }
assert_response :success
end
@ -623,19 +623,19 @@ class TraceControllerTest < ActionController::TestCase
assert_response :forbidden
# Now with some other user, which should fail
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id, :trace => new_details }, { :user => users(:public_user).id }
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id, :trace => new_details }, { :user => users(:public_user) }
assert_response :forbidden
# Now with a trace which doesn't exist
post :edit, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id, :trace => new_details }
post :edit, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user), :trace => new_details }
assert_response :not_found
# Now with a trace which has been deleted
post :edit, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id, :trace => new_details }, { :user => users(:public_user).id }
post :edit, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id, :trace => new_details }, { :user => users(:public_user) }
assert_response :not_found
# Finally with a trace that we are allowed to edit
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id, :trace => new_details }, { :user => users(:normal_user).id }
post :edit, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id, :trace => new_details }, { :user => users(:normal_user) }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
trace = Trace.find(public_trace_file.id)
@ -654,19 +654,19 @@ class TraceControllerTest < ActionController::TestCase
assert_response :forbidden
# Now with some other user, which should fail
post :delete, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
post :delete, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user) }
assert_response :forbidden
# Now with a trace which doesn't exist
post :delete, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
post :delete, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user) }
assert_response :not_found
# Now with a trace has already been deleted
post :delete, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
post :delete, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user) }
assert_response :not_found
# Finally with a trace that we are allowed to delete
post :delete, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
post :delete, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user) }
assert_response :redirect
assert_redirected_to :action => :list, :display_name => users(:normal_user).display_name
trace = Trace.find(public_trace_file.id)

62
test/controllers/user_controller_test.rb
View file

@ -768,7 +768,7 @@ class UserControllerTest < ActionController::TestCase
assert_redirected_to :controller => :user, :action => "login", :referer => "/user/test/account"
# Make sure that you are blocked when not logged in as the right user
get :account, { :display_name => user.display_name }, { :user => users(:public_user).id }
get :account, { :display_name => user.display_name }, { :user => users(:public_user) }
assert_response :forbidden
# Make sure we get the page when we are logged in as the right user
@ -778,7 +778,7 @@ class UserControllerTest < ActionController::TestCase
# Updating the description should work
user.description = "new description"
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select "div#errorExplanation", false
@ -787,7 +787,7 @@ class UserControllerTest < ActionController::TestCase
# Changing to a invalid editor should fail
user.preferred_editor = "unknown"
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select ".notice", false
@ -796,7 +796,7 @@ class UserControllerTest < ActionController::TestCase
# Changing to a valid editor should work
user.preferred_editor = "potlatch2"
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select "div#errorExplanation", false
@ -805,7 +805,7 @@ class UserControllerTest < ActionController::TestCase
# Changing to the default editor should work
user.preferred_editor = "default"
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select "div#errorExplanation", false
@ -814,7 +814,7 @@ class UserControllerTest < ActionController::TestCase
# Changing to an uploaded image should work
image = Rack::Test::UploadedFile.new("test/gpx/fixtures/a.gif", "image/gif")
post :account, { :display_name => user.display_name, :image_action => "new", :user => user.attributes.merge(:image => image) }, { :user => user.id }
post :account, { :display_name => user.display_name, :image_action => "new", :user => user.attributes.merge(:image => image) }, { :user => user }
assert_response :success
assert_template :account
assert_select "div#errorExplanation", false
@ -822,7 +822,7 @@ class UserControllerTest < ActionController::TestCase
assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=image_action][checked][value=?]", "keep"
# Changing to a gravatar image should work
post :account, { :display_name => user.display_name, :image_action => "gravatar", :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :image_action => "gravatar", :user => user.attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select "div#errorExplanation", false
@ -830,7 +830,7 @@ class UserControllerTest < ActionController::TestCase
assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=image_action][checked][value=?]", "gravatar"
# Removing the image should work
post :account, { :display_name => user.display_name, :image_action => "delete", :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :image_action => "delete", :user => user.attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select "div#errorExplanation", false
@ -838,13 +838,13 @@ class UserControllerTest < ActionController::TestCase
assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=image_action][checked]", false
# Adding external authentication should redirect to the auth provider
post :account, { :display_name => user.display_name, :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }, { :user => user }
assert_response :redirect
assert_redirected_to auth_path(:provider => "openid", :openid_url => "https://www.google.com/accounts/o8/id", :origin => "/user/#{user.display_name}/account")
# Changing name to one that exists should fail
new_attributes = user.attributes.dup.merge(:display_name => users(:public_user).display_name)
post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select ".notice", false
@ -853,7 +853,7 @@ class UserControllerTest < ActionController::TestCase
# Changing name to one that exists should fail, regardless of case
new_attributes = user.attributes.dup.merge(:display_name => users(:public_user).display_name.upcase)
post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select ".notice", false
@ -862,7 +862,7 @@ class UserControllerTest < ActionController::TestCase
# Changing name to one that doesn't exist should work
new_attributes = user.attributes.dup.merge(:display_name => "new tester")
post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user }
assert_response :success
assert_template :account
assert_select "div#errorExplanation", false
@ -875,7 +875,7 @@ class UserControllerTest < ActionController::TestCase
# Changing email to one that exists should fail
user.new_email = users(:public_user).email
assert_no_difference "ActionMailer::Base.deliveries.size" do
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user }
end
assert_response :success
assert_template :account
@ -886,7 +886,7 @@ class UserControllerTest < ActionController::TestCase
# Changing email to one that exists should fail, regardless of case
user.new_email = users(:public_user).email.upcase
assert_no_difference "ActionMailer::Base.deliveries.size" do
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user }
end
assert_response :success
assert_template :account
@ -897,7 +897,7 @@ class UserControllerTest < ActionController::TestCase
# Changing email to one that doesn't exist should work
user.new_email = "new_tester@example.com"
assert_difference "ActionMailer::Base.deliveries.size", 1 do
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user }
end
assert_response :success
assert_template :account
@ -1137,7 +1137,7 @@ class UserControllerTest < ActionController::TestCase
assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
# When logged in a GET should get a confirmation page
get :make_friend, { :display_name => friend.display_name }, { :user => user.id }
get :make_friend, { :display_name => friend.display_name }, { :user => user }
assert_response :success
assert_template :make_friend
assert_select "form" do
@ -1148,7 +1148,7 @@ class UserControllerTest < ActionController::TestCase
# When logged in a POST should add the friendship
assert_difference "ActionMailer::Base.deliveries.size", 1 do
post :make_friend, { :display_name => friend.display_name }, { :user => user.id }
post :make_friend, { :display_name => friend.display_name }, { :user => user }
end
assert_redirected_to user_path(:display_name => friend.display_name)
assert_match /is now your friend/, flash[:notice]
@ -1160,7 +1160,7 @@ class UserControllerTest < ActionController::TestCase
# A second POST should report that the friendship already exists
assert_no_difference "ActionMailer::Base.deliveries.size" do
post :make_friend, { :display_name => friend.display_name }, { :user => user.id }
post :make_friend, { :display_name => friend.display_name }, { :user => user }
end
assert_redirected_to user_path(:display_name => friend.display_name)
assert_match /You are already friends with/, flash[:warning]
@ -1176,7 +1176,7 @@ class UserControllerTest < ActionController::TestCase
assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
# The GET should preserve any referer
get :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
get :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user }
assert_response :success
assert_template :make_friend
assert_select "form" do
@ -1187,7 +1187,7 @@ class UserControllerTest < ActionController::TestCase
# When logged in a POST should add the friendship and refer us
assert_difference "ActionMailer::Base.deliveries.size", 1 do
post :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
post :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user }
end
assert_redirected_to "/test"
assert_match /is now your friend/, flash[:notice]
@ -1200,7 +1200,7 @@ class UserControllerTest < ActionController::TestCase
def test_make_friend_unkown_user
# Should error when a bogus user is specified
get :make_friend, { :display_name => "No Such User" }, { :user => users(:normal_user).id }
get :make_friend, { :display_name => "No Such User" }, { :user => users(:normal_user) }
assert_response :not_found
assert_template :no_such_user
end
@ -1224,7 +1224,7 @@ class UserControllerTest < ActionController::TestCase
assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
# When logged in a GET should get a confirmation page
get :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
get :remove_friend, { :display_name => friend.display_name }, { :user => user }
assert_response :success
assert_template :remove_friend
assert_select "form" do
@ -1234,13 +1234,13 @@ class UserControllerTest < ActionController::TestCase
assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
# When logged in a POST should remove the friendship
post :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
post :remove_friend, { :display_name => friend.display_name }, { :user => user }
assert_redirected_to user_path(:display_name => friend.display_name)
assert_match /was removed from your friends/, flash[:notice]
assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
# A second POST should report that the friendship does not exist
post :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
post :remove_friend, { :display_name => friend.display_name }, { :user => user }
assert_redirected_to user_path(:display_name => friend.display_name)
assert_match /is not one of your friends/, flash[:error]
assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
@ -1256,7 +1256,7 @@ class UserControllerTest < ActionController::TestCase
assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
# The GET should preserve any referer
get :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
get :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user }
assert_response :success
assert_template :remove_friend
assert_select "form" do
@ -1266,7 +1266,7 @@ class UserControllerTest < ActionController::TestCase
assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
# When logged in a POST should remove the friendship and refer
post :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
post :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user }
assert_redirected_to "/test"
assert_match /was removed from your friends/, flash[:notice]
assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
@ -1274,7 +1274,7 @@ class UserControllerTest < ActionController::TestCase
def test_remove_friend_unkown_user
# Should error when a bogus user is specified
get :remove_friend, { :display_name => "No Such User" }, { :user => users(:normal_user).id }
get :remove_friend, { :display_name => "No Such User" }, { :user => users(:normal_user) }
assert_response :not_found
assert_template :no_such_user
end
@ -1286,12 +1286,12 @@ class UserControllerTest < ActionController::TestCase
assert_redirected_to :action => :login, :referer => set_status_user_path(:status => "suspended")
# Now try as a normal user
get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user).id }
get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user) }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
# Finally try as an administrator
get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user).id }
get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user) }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
assert_equal "suspended", User.find(users(:normal_user).id).status
@ -1304,12 +1304,12 @@ class UserControllerTest < ActionController::TestCase
assert_redirected_to :action => :login, :referer => delete_user_path(:status => "suspended")
# Now try as a normal user
get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user).id }
get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user) }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
# Finally try as an administrator
get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user).id }
get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user) }
assert_response :redirect
assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name