Improve user_image_url test

[rails.git] / test / controllers / trace_controller_test.rb

diff --git a/test/controllers/trace_controller_test.rb b/test/controllers/trace_controller_test.rb
index 1e7642e3629b73b730675dd1bd23ccbe69bc5c0b..a23b5947359506b2f659ef211663066f86572739 100644 (file)
--- a/test/controllers/trace_controller_test.rb
+++ b/test/controllers/trace_controller_test.rb
@@ -257,6 +257,26 @@ class TraceControllerTest < ActionController::TestCase
     assert_template "user/no_such_user"
   end
 
+  # Check a multi-page list
+  def test_list_paged
+    # Create several pages worth of traces
+    create_list(:trace, 50)
+
+    # Try and get the list
+    get :list
+    assert_response :success
+    assert_select "table#trace_list tbody", :count => 1 do
+      assert_select "tr", :count => 20
+    end
+
+    # Try and get the second page
+    get :list, :params => { :page => 2 }
+    assert_response :success
+    assert_select "table#trace_list tbody", :count => 1 do
+      assert_select "tr", :count => 20
+    end
+  end
+
   # Check that the rss loads
   def test_rss
     user = create(:user)
@@ -672,12 +692,12 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Now with some other user, which should work since the trace is public
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     get :api_read, :params => { :id => public_trace_file.id }
     assert_response :success
 
     # And finally we should be able to do it with the owner of the trace
-    basic_authorization(public_trace_file.user.display_name, "test")
+    basic_authorization public_trace_file.user.display_name, "test"
     get :api_read, :params => { :id => public_trace_file.id }
     assert_response :success
   end
@@ -691,12 +711,12 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Now try with another user, which shouldn't work since the trace is anon
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     get :api_read, :params => { :id => anon_trace_file.id }
     assert_response :forbidden
 
     # And finally we should be able to get the trace details with the trace owner
-    basic_authorization(anon_trace_file.user.display_name, "test")
+    basic_authorization anon_trace_file.user.display_name, "test"
     get :api_read, :params => { :id => anon_trace_file.id }
     assert_response :success
   end
@@ -710,12 +730,12 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Login, and try again
-    basic_authorization(deleted_trace_file.user.display_name, "test")
+    basic_authorization deleted_trace_file.user.display_name, "test"
     get :api_read, :params => { :id => 0 }
     assert_response :not_found
 
     # Now try a trace which did exist but has been deleted
-    basic_authorization(deleted_trace_file.user.display_name, "test")
+    basic_authorization deleted_trace_file.user.display_name, "test"
     get :api_read, :params => { :id => deleted_trace_file.id }
     assert_response :not_found
   end
@@ -729,12 +749,12 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Now with some other user, which should work since the trace is public
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     get :api_data, :params => { :id => public_trace_file.id }
     check_trace_data public_trace_file
 
     # And finally we should be able to do it with the owner of the trace
-    basic_authorization(public_trace_file.user.display_name, "test")
+    basic_authorization public_trace_file.user.display_name, "test"
     get :api_data, :params => { :id => public_trace_file.id }
     check_trace_data public_trace_file
   end
@@ -744,7 +764,7 @@ class TraceControllerTest < ActionController::TestCase
     identifiable_trace_file = create(:trace, :visibility => "identifiable", :fixture => "d")
 
     # Authenticate as the owner of the trace we will be using
-    basic_authorization(identifiable_trace_file.user.display_name, "test")
+    basic_authorization identifiable_trace_file.user.display_name, "test"
 
     # First get the data as is
     get :api_data, :params => { :id => identifiable_trace_file.id }
@@ -768,12 +788,12 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Now with some other user, which shouldn't work since the trace is anon
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     get :api_data, :params => { :id => anon_trace_file.id }
     assert_response :forbidden
 
     # And finally we should be able to do it with the owner of the trace
-    basic_authorization(anon_trace_file.user.display_name, "test")
+    basic_authorization anon_trace_file.user.display_name, "test"
     get :api_data, :params => { :id => anon_trace_file.id }
     check_trace_data anon_trace_file
   end
@@ -787,12 +807,12 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Login, and try again
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     get :api_data, :params => { :id => 0 }
     assert_response :not_found
 
     # Now try a trace which did exist but has been deleted
-    basic_authorization(deleted_trace_file.user.display_name, "test")
+    basic_authorization deleted_trace_file.user.display_name, "test"
     get :api_data, :params => { :id => deleted_trace_file.id }
     assert_response :not_found
   end
@@ -811,7 +831,7 @@ class TraceControllerTest < ActionController::TestCase
     # Now authenticated
     create(:user_preference, :user => user, :k => "gps.trace.visibility", :v => "identifiable")
     assert_not_equal "trackable", user.preferences.where(:k => "gps.trace.visibility").first.v
-    basic_authorization(user.display_name, "test")
+    basic_authorization user.display_name, "test"
     post :api_create, :params => { :file => file, :description => "New Trace", :tags => "new,trace", :visibility => "trackable" }
     assert_response :success
     trace = Trace.find(response.body.to_i)
@@ -829,7 +849,7 @@ class TraceControllerTest < ActionController::TestCase
 
     # Now authenticated, with the legacy public flag
     assert_not_equal "public", user.preferences.where(:k => "gps.trace.visibility").first.v
-    basic_authorization(user.display_name, "test")
+    basic_authorization user.display_name, "test"
     post :api_create, :params => { :file => file, :description => "New Trace", :tags => "new,trace", :public => 1 }
     assert_response :success
     trace = Trace.find(response.body.to_i)
@@ -848,7 +868,7 @@ class TraceControllerTest < ActionController::TestCase
     # Now authenticated, with the legacy private flag
     second_user = create(:user)
     assert_nil second_user.preferences.where(:k => "gps.trace.visibility").first
-    basic_authorization(second_user.display_name, "test")
+    basic_authorization second_user.display_name, "test"
     post :api_create, :params => { :file => file, :description => "New Trace", :tags => "new,trace", :public => 0 }
     assert_response :success
     trace = Trace.find(response.body.to_i)
@@ -874,32 +894,32 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Now with some other user, which should fail
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     content public_trace_file.to_xml
     put :api_update, :params => { :id => public_trace_file.id }
     assert_response :forbidden
 
     # Now with a trace which doesn't exist
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     content public_trace_file.to_xml
     put :api_update, :params => { :id => 0 }
     assert_response :not_found
 
     # Now with a trace which did exist but has been deleted
-    basic_authorization(deleted_trace_file.user.display_name, "test")
+    basic_authorization deleted_trace_file.user.display_name, "test"
     content deleted_trace_file.to_xml
     put :api_update, :params => { :id => deleted_trace_file.id }
     assert_response :not_found
 
     # Now try an update with the wrong ID
-    basic_authorization(public_trace_file.user.display_name, "test")
+    basic_authorization public_trace_file.user.display_name, "test"
     content anon_trace_file.to_xml
     put :api_update, :params => { :id => public_trace_file.id }
     assert_response :bad_request,
                     "should not be able to update a trace with a different ID from the XML"
 
     # And finally try an update that should work
-    basic_authorization(public_trace_file.user.display_name, "test")
+    basic_authorization public_trace_file.user.display_name, "test"
     t = public_trace_file
     t.description = "Changed description"
     t.visibility = "private"
@@ -911,6 +931,23 @@ class TraceControllerTest < ActionController::TestCase
     assert_equal nt.visibility, t.visibility
   end
 
+  # Test that updating a trace doesn't duplicate the tags
+  def test_api_update_tags
+    tracetag = create(:tracetag)
+    trace = tracetag.trace
+    basic_authorization trace.user.display_name, "test"
+
+    content trace.to_xml
+    put :api_update, :params => { :id => trace.id }
+    assert_response :success
+
+    updated = Trace.find(trace.id)
+    # Ensure there's only one tag in the database after updating
+    assert_equal Tracetag.count, 1
+    # The new tag object might have a different id, so check the string representation
+    assert_equal trace.tagstring, updated.tagstring
+  end
+
   # Check deleting a trace through the api
   def test_api_delete
     public_trace_file = create(:trace, :visibility => "public")
@@ -920,22 +957,22 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :unauthorized
 
     # Now with some other user, which should fail
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     delete :api_delete, :params => { :id => public_trace_file.id }
     assert_response :forbidden
 
     # Now with a trace which doesn't exist
-    basic_authorization(create(:user).display_name, "test")
+    basic_authorization create(:user).display_name, "test"
     delete :api_delete, :params => { :id => 0 }
     assert_response :not_found
 
     # And finally we should be able to do it with the owner of the trace
-    basic_authorization(public_trace_file.user.display_name, "test")
+    basic_authorization public_trace_file.user.display_name, "test"
     delete :api_delete, :params => { :id => public_trace_file.id }
     assert_response :success
 
     # Try it a second time, which should fail
-    basic_authorization(public_trace_file.user.display_name, "test")
+    basic_authorization public_trace_file.user.display_name, "test"
     delete :api_delete, :params => { :id => public_trace_file.id }
     assert_response :not_found
   end