From: Andy Allan <git@gravitystorm.co.uk>
Date: Wed, 22 Feb 2017 09:57:18 +0000 (+0000)
Subject: Pass the user object, rather than the id, for sessions.
X-Git-Tag: live~3557
X-Git-Url: https://git.openstreetmap.org/rails.git/commitdiff_plain/7d9d496da2a66c0a56aadd1bab72ede1a1b0359c?hp=1dc2ff7d576ebfb5a2889a4e49ede620f4d2faec

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

This simplifies the code slightly.
---

diff --git a/test/controllers/changeset_controller_test.rb b/test/controllers/changeset_controller_test.rb
index ca2ff8e15..96c12e145 100644
--- a/test/controllers/changeset_controller_test.rb
+++ b/test/controllers/changeset_controller_test.rb
@@ -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]
 
diff --git a/test/controllers/diary_entry_controller_test.rb b/test/controllers/diary_entry_controller_test.rb
index 045ec2048..379ec3a29 100644
--- a/test/controllers/diary_entry_controller_test.rb
+++ b/test/controllers/diary_entry_controller_test.rb
@@ -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
 
diff --git a/test/controllers/site_controller_test.rb b/test/controllers/site_controller_test.rb
index e1eeac294..37f457523 100644
--- a/test/controllers/site_controller_test.rb
+++ b/test/controllers/site_controller_test.rb
@@ -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
diff --git a/test/controllers/trace_controller_test.rb b/test/controllers/trace_controller_test.rb
index b238df04c..9ef79d1fa 100644
--- a/test/controllers/trace_controller_test.rb
+++ b/test/controllers/trace_controller_test.rb
@@ -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)
diff --git a/test/controllers/user_controller_test.rb b/test/controllers/user_controller_test.rb
index 027618631..686a86070 100644
--- a/test/controllers/user_controller_test.rb
+++ b/test/controllers/user_controller_test.rb
@@ -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