Replace trace-related fixtures with factories.
authorAndy Allan <git@gravitystorm.co.uk>
Sat, 29 Oct 2016 14:21:52 +0000 (16:21 +0200)
committerAndy Allan <git@gravitystorm.co.uk>
Sat, 29 Oct 2016 14:23:04 +0000 (16:23 +0200)
The mocking and stubbing in the controller tests is
unfortunate, but the models interact directly with the filesystem
using the trace id so that's hard to control any other way.

17 files changed:
test/controllers/amf_controller_test.rb
test/controllers/api_controller_test.rb
test/controllers/site_controller_test.rb
test/controllers/swf_controller_test.rb
test/controllers/trace_controller_test.rb
test/controllers/user_controller_test.rb
test/factories/tracepoints.rb [new file with mode: 0644]
test/factories/traces.rb [new file with mode: 0644]
test/factories/tracetags.rb [new file with mode: 0644]
test/fixtures/gps_points.yml [deleted file]
test/fixtures/gpx_file_tags.yml [deleted file]
test/fixtures/gpx_files.yml [deleted file]
test/integration/oauth_test.rb
test/models/trace_test.rb
test/models/tracepoint_test.rb
test/models/tracetag_test.rb
test/test_helper.rb

index 7c8c64ba085813f597d7353a9f86a8c49e5a024b..8f58aa980fb3c8aef0b4e9f6ee1e5c2ad8febe14 100644 (file)
@@ -473,7 +473,7 @@ class AmfControllerTest < ActionController::TestCase
   end
 
   def test_findgpx_by_id
-    trace = gpx_files(:anon_trace_file)
+    trace = create(:trace, :visibility => "private", :user => users(:public_user))
 
     amf_content "findgpx", "/1", [trace.id, "test@example.com:test"]
     post :amf_read
index 0a185baae3ebed1808a3bc7a5ea47814b8727132..67469d094772dcedf621232a7e5ff7633d17f336 100644 (file)
@@ -132,7 +132,9 @@ class ApiControllerTest < ActionController::TestCase
   end
 
   def test_tracepoints
-    point = gpx_files(:public_trace_file)
+    point = create(:trace, :visibility => "public", :latitude => 1, :longitude => 1) do |trace|
+      create(:tracepoint, :trace => trace, :latitude => 1 * GeoRecord::SCALE, :longitude => 1 * GeoRecord::SCALE)
+    end
     minlon = point.longitude - 0.001
     minlat = point.latitude - 0.001
     maxlon = point.longitude + 0.001
@@ -148,7 +150,10 @@ class ApiControllerTest < ActionController::TestCase
   end
 
   def test_tracepoints_trackable
-    point = gpx_files(:trackable_trace_file)
+    point = create(:trace, :visibility => "trackable", :latitude => 51.51, :longitude => -0.14) do |trace|
+      create(:tracepoint, :trace => trace, :trackid => 1, :latitude => (51.510 * GeoRecord::SCALE).to_i, :longitude => (-0.140 * GeoRecord::SCALE).to_i)
+      create(:tracepoint, :trace => trace, :trackid => 2, :latitude => (51.511 * GeoRecord::SCALE).to_i, :longitude => (-0.141 * GeoRecord::SCALE).to_i)
+    end
     minlon = point.longitude - 0.002
     minlat = point.latitude - 0.002
     maxlon = point.longitude + 0.002
@@ -170,7 +175,9 @@ class ApiControllerTest < ActionController::TestCase
   end
 
   def test_tracepoints_identifiable
-    point = gpx_files(:identifiable_trace_file)
+    point = create(:trace, :visibility => "identifiable", :latitude => 51.512, :longitude => 0.142) do |trace|
+      create(:tracepoint, :trace => trace, :latitude => (51.512 * GeoRecord::SCALE).to_i, :longitude => (0.142 * GeoRecord::SCALE).to_i)
+    end
     minlon = point.longitude - 0.002
     minlat = point.latitude - 0.002
     maxlon = point.longitude + 0.002
index 70eacb3aa9bbb6868b57e8528658fa7201e97874..7e387f684f288c3873b4f770411b241328265f2d 100644 (file)
@@ -280,7 +280,7 @@ class SiteControllerTest < ActionController::TestCase
   # Test editing a specific GPX trace
   def test_edit_with_gpx
     user = users(:public_user)
-    gpx  = gpx_files(:public_trace_file)
+    gpx  = create(:trace, :latitude => 1, :longitude => 1)
 
     get :edit, { :gpx => gpx.id }, { :user => user.id }
     assert_response :success
index 25ed4194793634c9297119e58594aef87507961f..13322c6b58ecae982db1ce117793b567308c58d3 100644 (file)
@@ -15,6 +15,14 @@ class SwfControllerTest < ActionController::TestCase
   ##
   # basic test that trackpoints at least returns some sort of flash movie
   def test_trackpoints
+    create(:trace, :visibility => "trackable", :latitude => 51.51, :longitude => -0.14, :user => users(:public_user)) do |trace|
+      create(:tracepoint, :trace => trace, :trackid => 1, :latitude => (51.510 * GeoRecord::SCALE).to_i, :longitude => (-0.140 * GeoRecord::SCALE).to_i)
+      create(:tracepoint, :trace => trace, :trackid => 2, :latitude => (51.511 * GeoRecord::SCALE).to_i, :longitude => (-0.141 * GeoRecord::SCALE).to_i)
+    end
+    create(:trace, :visibility => "identifiable", :latitude => 51.512, :longitude => 0.142) do |trace|
+      create(:tracepoint, :trace => trace, :latitude => (51.512 * GeoRecord::SCALE).to_i, :longitude => (0.142 * GeoRecord::SCALE).to_i)
+    end
+
     get :trackpoints, :xmin => -1, :xmax => 1, :ymin => 51, :ymax => 52, :baselong => 0, :basey => 0, :masterscale => 1
     assert_response :success
     assert_equal "application/x-shockwave-flash", response.content_type
index 5a5234cb5c4b92e6a0caeafbfb3ea4ca1d16ea7c..9170d6e2e70837fbe4633197cbef856c5f33105d 100644 (file)
@@ -1,8 +1,8 @@
 require "test_helper"
+require "minitest/mock"
 
 class TraceControllerTest < ActionController::TestCase
-  fixtures :users, :gpx_files
-  set_fixture_class :gpx_files => Trace
+  fixtures :users
 
   def setup
     @gpx_trace_dir = Object.send("remove_const", "GPX_TRACE_DIR")
@@ -249,97 +249,119 @@ class TraceControllerTest < ActionController::TestCase
 
   # Test viewing a trace
   def test_view
+    public_trace_file = create(:trace, :visibility => "public")
+
     # First with no auth, which should work since the trace is public
-    get :view, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
-    check_trace_view gpx_files(:public_trace_file)
+    get :view, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
+    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 => gpx_files(:public_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_view gpx_files(:public_trace_file)
+    get :view, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:public_user).id }
+    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 => gpx_files(:public_trace_file).id }, { :user => users(:normal_user).id }
-    check_trace_view gpx_files(:public_trace_file)
+    get :view, { :display_name => users(:normal_user).display_name, :id => public_trace_file.id }, { :user => users(:normal_user).id }
+    check_trace_view public_trace_file
   end
 
   # Check an anonymous trace can't be viewed by another user
   def test_view_anon
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+
     # First with no auth
-    get :view, :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id
+    get :view, :display_name => users(:public_user).display_name, :id => anon_trace_file.id
     assert_response :redirect
     assert_redirected_to :action => :list
 
-    # Now with some other user, which should work since the trace is anon
-    get :view, { :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id }, { :user => users(:normal_user).id }
+    # 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 }
     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 => gpx_files(:anon_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_view gpx_files(:anon_trace_file)
+    get :view, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
+    check_trace_view anon_trace_file
   end
 
   # Test viewing a trace that doesn't exist
   def test_view_not_found
-    # First with no auth, which should work since the trace is public
+    # First with no auth
     get :view, :display_name => users(:public_user).display_name, :id => 0
     assert_response :redirect
     assert_redirected_to :action => :list
 
-    # Now with some other user, which should work since the trace is public
+    # Now with some other user
     get :view, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
     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 => 5 }, { :user => users(:public_user).id }
+    # And finally we should not be able to view a deleted trace
+    deleted_trace_file = create(:trace, :deleted)
+    get :view, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
     assert_response :redirect
     assert_redirected_to :action => :list
   end
 
   # Test downloading a trace
   def test_data
-    # First with no auth, which should work since the trace is public
-    get :data, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
-    check_trace_data gpx_files(: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 => gpx_files(:public_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_data gpx_files(: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 => gpx_files(:public_trace_file).id }, { :user => users(:normal_user).id }
-    check_trace_data gpx_files(:public_trace_file)
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    # We need to stub both the trace_name, to control which file from test/traces is used,
+    # and also the Trace.find method so that our stubbed object is used by the controller.
+    public_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/1.gpx" do
+      Trace.stub :find, public_trace_file do
+        # First with no auth, which should work since the trace is public
+        get :data, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
+        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 }
+        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 }
+        check_trace_data public_trace_file
+      end
+    end
   end
 
   # Test downloading a compressed trace
   def test_data_compressed
-    # First get the data as is
-    get :data, :display_name => users(:public_user).display_name, :id => gpx_files(:identifiable_trace_file).id
-    check_trace_data gpx_files(:identifiable_trace_file), "application/x-gzip", "gpx.gz"
-
-    # Now ask explicitly for XML format
-    get :data, :display_name => users(:public_user).display_name, :id => gpx_files(:identifiable_trace_file).id, :format => "xml"
-    check_trace_data gpx_files(:identifiable_trace_file), "application/xml", "xml"
-
-    # Now ask explicitly for GPX format
-    get :data, :display_name => users(:public_user).display_name, :id => gpx_files(:identifiable_trace_file).id, :format => "gpx"
-    check_trace_data gpx_files(:identifiable_trace_file)
+    identifiable_trace_file = create(:trace, :visibility => "identifiable")
+    identifiable_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/4.gpx" do
+      Trace.stub :find, identifiable_trace_file do
+        # First get the data as is
+        get :data, :display_name => users(:public_user).display_name, :id => identifiable_trace_file.id
+        check_trace_data identifiable_trace_file, "application/x-gzip", "gpx.gz"
+
+        # Now ask explicitly for XML format
+        get :data, :display_name => users(:public_user).display_name, :id => identifiable_trace_file.id, :format => "xml"
+        check_trace_data identifiable_trace_file, "application/xml", "xml"
+
+        # Now ask explicitly for GPX format
+        get :data, :display_name => users(:public_user).display_name, :id => identifiable_trace_file.id, :format => "gpx"
+        check_trace_data identifiable_trace_file
+      end
+    end
   end
 
   # Check an anonymous trace can't be downloaded by another user
   def test_data_anon
-    # First with no auth
-    get :data, :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id
-    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 => gpx_files(:anon_trace_file).id }, { :user => users(:normal_user).id }
-    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 => gpx_files(:anon_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_data gpx_files(:anon_trace_file)
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+    anon_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/2.gpx" do
+      # First with no auth
+      get :data, :display_name => users(:public_user).display_name, :id => anon_trace_file.id
+      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 }
+      assert_response :not_found
+
+      # And finally we should be able to do it with the owner of the trace
+      Trace.stub :find, anon_trace_file do
+        get :data, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
+        check_trace_data anon_trace_file
+      end
+    end
   end
 
   # Test downloading a trace that doesn't exist
@@ -353,38 +375,49 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :not_found
 
     # Now with a trace that has been deleted
-    get :data, { :display_name => users(:public_user).display_name, :id => 5 }, { :user => users(:public_user).id }
+    deleted_trace_file = create(:trace, :deleted)
+    get :data, { :display_name => users(:public_user).display_name, :id => deleted_trace_file.id }, { :user => users(:public_user).id }
     assert_response :not_found
   end
 
   # Test downloading the picture for a trace
   def test_picture
-    # First with no auth, which should work since the trace is public
-    get :picture, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
-    check_trace_picture gpx_files(: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 => gpx_files(:public_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_picture gpx_files(: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 => gpx_files(:public_trace_file).id }, { :user => users(:normal_user).id }
-    check_trace_picture gpx_files(:public_trace_file)
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    public_trace_file.stub :large_picture_name, "#{GPX_TRACE_DIR}/1.gif" do
+      Trace.stub :find, public_trace_file do
+        # First with no auth, which should work since the trace is public
+        get :picture, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
+        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 }
+        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 }
+        check_trace_picture public_trace_file
+      end
+    end
   end
 
   # Check the picture for an anonymous trace can't be downloaded by another user
   def test_picture_anon
-    # First with no auth
-    get :picture, :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id
-    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 => gpx_files(:anon_trace_file).id }, { :user => users(:normal_user).id }
-    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 => gpx_files(:anon_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_picture gpx_files(:anon_trace_file)
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+    anon_trace_file.stub :large_picture_name, "#{GPX_TRACE_DIR}/2.gif" do
+      # First with no auth
+      get :picture, :display_name => users(:public_user).display_name, :id => anon_trace_file.id
+      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 }
+      assert_response :forbidden
+
+      # And finally we should be able to do it with the owner of the trace
+      Trace.stub :find, anon_trace_file do
+        get :picture, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
+        check_trace_picture anon_trace_file
+      end
+    end
   end
 
   # Test downloading the picture for a trace that doesn't exist
@@ -397,53 +430,65 @@ class TraceControllerTest < ActionController::TestCase
     get :picture, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
     assert_response :not_found
 
-    # 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 => 5 }, { :user => users(:public_user).id }
+    # 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 }
     assert_response :not_found
   end
 
   # Test downloading the icon for a trace
   def test_icon
-    # First with no auth, which should work since the trace is public
-    get :icon, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
-    check_trace_icon gpx_files(: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 => gpx_files(:public_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_icon gpx_files(: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 => gpx_files(:public_trace_file).id }, { :user => users(:normal_user).id }
-    check_trace_icon gpx_files(:public_trace_file)
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    public_trace_file.stub :icon_picture_name, "#{GPX_TRACE_DIR}/1_icon.gif" do
+      Trace.stub :find, public_trace_file do
+        # First with no auth, which should work since the trace is public
+        get :icon, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
+        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 }
+        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 }
+        check_trace_icon public_trace_file
+      end
+    end
   end
 
   # Check the icon for an anonymous trace can't be downloaded by another user
   def test_icon_anon
-    # First with no auth
-    get :icon, :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id
-    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 => gpx_files(:anon_trace_file).id }, { :user => users(:normal_user).id }
-    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 => gpx_files(:anon_trace_file).id }, { :user => users(:public_user).id }
-    check_trace_icon gpx_files(:anon_trace_file)
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+    anon_trace_file.stub :icon_picture_name, "#{GPX_TRACE_DIR}/2_icon.gif" do
+      # First with no auth
+      get :icon, :display_name => users(:public_user).display_name, :id => anon_trace_file.id
+      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 }
+      assert_response :forbidden
+
+      # And finally we should be able to do it with the owner of the trace
+      Trace.stub :find, anon_trace_file do
+        get :icon, { :display_name => users(:public_user).display_name, :id => anon_trace_file.id }, { :user => users(:public_user).id }
+        check_trace_icon anon_trace_file
+      end
+    end
   end
 
   # Test downloading the icon for a trace that doesn't exist
   def test_icon_not_found
-    # First with no auth, which should work since the trace is public
+    # First with no auth
     get :icon, :display_name => users(:public_user).display_name, :id => 0
     assert_response :not_found
 
-    # Now with some other user, which should work since the trace is public
+    # Now with some other user
     get :icon, { :display_name => users(:public_user).display_name, :id => 0 }, { :user => users(:public_user).id }
     assert_response :not_found
 
-    # 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 => 5 }, { :user => users(:public_user).id }
+    # 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 }
     assert_response :not_found
   end
 
@@ -477,40 +522,46 @@ class TraceControllerTest < ActionController::TestCase
 
   # Test creating a trace
   def test_create_post
-    # Get file to use
-    file = Rack::Test::UploadedFile.new(gpx_files(:public_trace_file).trace_name, "application/gpx+xml")
-
-    # First with no auth
-    post :create, :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" }
-    assert_response :forbidden
-
-    # 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 }
-    assert_response :redirect
-    assert_redirected_to :action => :list, :display_name => users(:public_user).display_name
-    assert_match /file has been uploaded/, flash[:notice]
-    trace = Trace.order(:id => :desc).first
-    assert_equal "1.gpx", trace.name
-    assert_equal "New Trace", trace.description
-    assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
-    assert_equal "trackable", trace.visibility
-    assert_equal false, trace.inserted
-    assert_equal File.new(gpx_files(:public_trace_file).trace_name).read, File.new(trace.trace_name).read
-    trace.destroy
-    assert_equal "trackable", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
+    public_trace_file = create(:trace, :visibility => "public")
+    public_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/1.gpx" do
+      # Get file to use
+      file = Rack::Test::UploadedFile.new(public_trace_file.trace_name, "application/gpx+xml")
+
+      # First with no auth
+      post :create, :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" }
+      assert_response :forbidden
+
+      # 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 }
+      assert_response :redirect
+      assert_redirected_to :action => :list, :display_name => users(:public_user).display_name
+      assert_match /file has been uploaded/, flash[:notice]
+      trace = Trace.order(:id => :desc).first
+      assert_equal "1.gpx", trace.name
+      assert_equal "New Trace", trace.description
+      assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
+      assert_equal "trackable", trace.visibility
+      assert_equal false, trace.inserted
+      assert_equal File.new(public_trace_file.trace_name).read, File.new(trace.trace_name).read
+      trace.destroy
+      assert_equal "trackable", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
+    end
   end
 
   # Test fetching the edit page for a trace
   def test_edit_get
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    deleted_trace_file = create(:trace, :deleted, :user => users(:public_user))
+
     # First with no auth
-    get :edit, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
+    get :edit, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
     assert_response :redirect
-    assert_redirected_to :controller => :user, :action => :login, :referer => trace_edit_path(:display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id)
+    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 => gpx_files(: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).id }
     assert_response :forbidden
 
     # Now with a trace which doesn't exist
@@ -518,25 +569,27 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :not_found
 
     # Now with a trace which has been deleted
-    get :edit, { :display_name => users(:public_user).display_name, :id => gpx_files(: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).id }
     assert_response :not_found
 
     # Finally with a trace that we are allowed to edit
-    get :edit, { :display_name => users(:normal_user).display_name, :id => gpx_files(: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).id }
     assert_response :success
   end
 
   # Test saving edits to a trace
   def test_edit_post
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    deleted_trace_file = create(:trace, :deleted, :user => users(:public_user))
     # New details
     new_details = { :description => "Changed description", :tagstring => "new_tag", :visibility => "private" }
 
     # First with no auth
-    post :edit, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id, :trace => new_details
+    post :edit, :display_name => users(:normal_user).display_name, :id => public_trace_file.id, :trace => new_details
     assert_response :forbidden
 
     # Now with some other user, which should fail
-    post :edit, { :display_name => users(:normal_user).display_name, :id => gpx_files(: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).id }
     assert_response :forbidden
 
     # Now with a trace which doesn't exist
@@ -544,14 +597,14 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :not_found
 
     # Now with a trace which has been deleted
-    post :edit, { :display_name => users(:public_user).display_name, :id => gpx_files(: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).id }
     assert_response :not_found
 
     # Finally with a trace that we are allowed to edit
-    post :edit, { :display_name => users(:normal_user).display_name, :id => gpx_files(: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).id }
     assert_response :redirect
     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
-    trace = Trace.find(gpx_files(:public_trace_file).id)
+    trace = Trace.find(public_trace_file.id)
     assert_equal new_details[:description], trace.description
     assert_equal new_details[:tagstring], trace.tagstring
     assert_equal new_details[:visibility], trace.visibility
@@ -559,12 +612,15 @@ class TraceControllerTest < ActionController::TestCase
 
   # Test deleting a trace
   def test_delete
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    deleted_trace_file = create(:trace, :deleted, :user => users(:public_user))
+
     # First with no auth
-    post :delete, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
+    post :delete, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
     assert_response :forbidden
 
     # Now with some other user, which should fail
-    post :delete, { :display_name => users(:normal_user).display_name, :id => gpx_files(: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).id }
     assert_response :forbidden
 
     # Now with a trace which doesn't exist
@@ -572,54 +628,60 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :not_found
 
     # Now with a trace has already been deleted
-    post :delete, { :display_name => users(:public_user).display_name, :id => gpx_files(: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).id }
     assert_response :not_found
 
     # Finally with a trace that we are allowed to delete
-    post :delete, { :display_name => users(:normal_user).display_name, :id => gpx_files(: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).id }
     assert_response :redirect
     assert_redirected_to :action => :list, :display_name => users(:normal_user).display_name
-    trace = Trace.find(gpx_files(:public_trace_file).id)
+    trace = Trace.find(public_trace_file.id)
     assert_equal false, trace.visible
   end
 
   # Check getting a specific trace through the api
   def test_api_read
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+
     # First with no auth
-    get :api_read, :id => gpx_files(:public_trace_file).id
+    get :api_read, :id => public_trace_file.id
     assert_response :unauthorized
 
     # Now with some other user, which should work since the trace is public
     basic_authorization(users(:public_user).display_name, "test")
-    get :api_read, :id => gpx_files(:public_trace_file).id
+    get :api_read, :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(users(:normal_user).display_name, "test")
-    get :api_read, :id => gpx_files(:public_trace_file).id
+    get :api_read, :id => public_trace_file.id
     assert_response :success
   end
 
   # Check an anoymous trace can't be specifically fetched by another user
   def test_api_read_anon
-    # Furst with no auth
-    get :api_read, :id => gpx_files(:anon_trace_file).id
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+
+    # First with no auth
+    get :api_read, :id => anon_trace_file.id
     assert_response :unauthorized
 
     # Now try with another user, which shouldn't work since the trace is anon
     basic_authorization(users(:normal_user).display_name, "test")
-    get :api_read, :id => gpx_files(:anon_trace_file).id
+    get :api_read, :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(users(:public_user).display_name, "test")
-    get :api_read, :id => gpx_files(:anon_trace_file).id
+    get :api_read, :id => anon_trace_file.id
     assert_response :success
   end
 
   # Check the api details for a trace that doesn't exist
   def test_api_read_not_found
-    # Try first with no auth, as it should requure it
+    deleted_trace_file = create(:trace, :deleted, :user => users(:public_user))
+
+    # Try first with no auth, as it should require it
     get :api_read, :id => 0
     assert_response :unauthorized
 
@@ -630,60 +692,85 @@ class TraceControllerTest < ActionController::TestCase
 
     # Now try a trace which did exist but has been deleted
     basic_authorization(users(:public_user).display_name, "test")
-    get :api_read, :id => 5
+    get :api_read, :id => deleted_trace_file.id
     assert_response :not_found
   end
 
   # Test downloading a trace through the api
   def test_api_data
-    # First with no auth
-    get :api_data, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
-    assert_response :unauthorized
-
-    # Now with some other user, which should work since the trace is public
-    basic_authorization(users(:public_user).display_name, "test")
-    get :api_data, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
-    check_trace_data gpx_files(:public_trace_file)
-
-    # And finally we should be able to do it with the owner of the trace
-    basic_authorization(users(:normal_user).display_name, "test")
-    get :api_data, :display_name => users(:normal_user).display_name, :id => gpx_files(:public_trace_file).id
-    check_trace_data gpx_files(:public_trace_file)
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    public_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/1.gpx" do
+      visible = MiniTest::Mock.new
+      visible.expect :find, public_trace_file, [String]
+      visible.expect :find, public_trace_file, [String]
+      Trace.stub :visible, visible do
+        # First with no auth
+        get :api_data, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
+        assert_response :unauthorized
+
+        # Now with some other user, which should work since the trace is public
+        basic_authorization(users(:public_user).display_name, "test")
+        get :api_data, :display_name => users(:normal_user).display_name, :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(users(:normal_user).display_name, "test")
+        get :api_data, :display_name => users(:normal_user).display_name, :id => public_trace_file.id
+        check_trace_data public_trace_file
+      end
+    end
   end
 
   # Test downloading a compressed trace through the api
   def test_api_data_compressed
-    # Authenticate as the owner of the trace we will be using
-    basic_authorization(users(:public_user).display_name, "test")
-
-    # First get the data as is
-    get :api_data, :display_name => users(:public_user).display_name, :id => gpx_files(:identifiable_trace_file).id
-    check_trace_data gpx_files(:identifiable_trace_file), "application/x-gzip", "gpx.gz"
-
-    # Now ask explicitly for XML format
-    get :api_data, :display_name => users(:public_user).display_name, :id => gpx_files(:identifiable_trace_file).id, :format => "xml"
-    check_trace_data gpx_files(:identifiable_trace_file), "application/xml", "xml"
-
-    # Now ask explicitly for GPX format
-    get :api_data, :display_name => users(:public_user).display_name, :id => gpx_files(:identifiable_trace_file).id, :format => "gpx"
-    check_trace_data gpx_files(:identifiable_trace_file)
+    identifiable_trace_file = create(:trace, :visibility => "identifiable", :user => users(:public_user))
+    identifiable_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/4.gpx" do
+      visible = MiniTest::Mock.new
+      visible.expect :find, identifiable_trace_file, [String]
+      visible.expect :find, identifiable_trace_file, [String]
+      visible.expect :find, identifiable_trace_file, [String]
+      Trace.stub :visible, visible do
+        # Authenticate as the owner of the trace we will be using
+        basic_authorization(users(:public_user).display_name, "test")
+
+        # First get the data as is
+        get :api_data, :display_name => users(:public_user).display_name, :id => identifiable_trace_file.id
+        check_trace_data identifiable_trace_file, "application/x-gzip", "gpx.gz"
+
+        # Now ask explicitly for XML format
+        get :api_data, :display_name => users(:public_user).display_name, :id => identifiable_trace_file.id, :format => "xml"
+        check_trace_data identifiable_trace_file, "application/xml", "xml"
+
+        # # Now ask explicitly for GPX format
+        get :api_data, :display_name => users(:public_user).display_name, :id => identifiable_trace_file.id, :format => "gpx"
+        check_trace_data identifiable_trace_file
+      end
+    end
   end
 
   # Check an anonymous trace can't be downloaded by another user through the api
   def test_api_data_anon
-    # First with no auth
-    get :api_data, :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id
-    assert_response :unauthorized
-
-    # Now with some other user, which shouldn't work since the trace is anon
-    basic_authorization(users(:normal_user).display_name, "test")
-    get :api_data, :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id
-    assert_response :forbidden
-
-    # And finally we should be able to do it with the owner of the trace
-    basic_authorization(users(:public_user).display_name, "test")
-    get :api_data, :display_name => users(:public_user).display_name, :id => gpx_files(:anon_trace_file).id
-    check_trace_data gpx_files(:anon_trace_file)
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+    anon_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/2.gpx" do
+      visible = MiniTest::Mock.new
+      visible.expect :find, anon_trace_file, [String]
+      visible.expect :find, anon_trace_file, [String]
+      Trace.stub :visible, visible do
+        # First with no auth
+        get :api_data, :display_name => users(:public_user).display_name, :id => anon_trace_file.id
+        assert_response :unauthorized
+
+        # Now with some other user, which shouldn't work since the trace is anon
+        basic_authorization(users(:normal_user).display_name, "test")
+        get :api_data, :display_name => users(:public_user).display_name, :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(users(:public_user).display_name, "test")
+        get :api_data, :display_name => users(:public_user).display_name, :id => anon_trace_file.id
+        check_trace_data anon_trace_file
+      end
+    end
   end
 
   # Test downloading a trace that doesn't exist through the api
@@ -698,127 +785,139 @@ class TraceControllerTest < ActionController::TestCase
     assert_response :not_found
 
     # Now with a trace that has been deleted
+    deleted_trace_file = create(:trace, :deleted)
     basic_authorization(users(:public_user).display_name, "test")
-    get :api_data, :display_name => users(:public_user).display_name, :id => 5
+    get :api_data, :display_name => users(:public_user).display_name, :id => deleted_trace_file.id
     assert_response :not_found
   end
 
   # Test creating a trace through the api
   def test_api_create
-    # Get file to use
-    file = Rack::Test::UploadedFile.new(gpx_files(:public_trace_file).trace_name, "application/gpx+xml")
-
-    # First with no auth
-    post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :visibility => "trackable"
-    assert_response :unauthorized
-
-    # 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
-    basic_authorization(users(:public_user).display_name, "test")
-    post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :visibility => "trackable"
-    assert_response :success
-    trace = Trace.find(response.body.to_i)
-    assert_equal "1.gpx", trace.name
-    assert_equal "New Trace", trace.description
-    assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
-    assert_equal "trackable", trace.visibility
-    assert_equal false, trace.inserted
-    assert_equal File.new(gpx_files(:public_trace_file).trace_name).read, File.new(trace.trace_name).read
-    trace.destroy
-    assert_equal "trackable", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
-
-    # Rewind the file
-    file.rewind
-
-    # Now authenticated, with the legacy public flag
-    assert_not_equal "public", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
-    basic_authorization(users(:public_user).display_name, "test")
-    post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :public => 1
-    assert_response :success
-    trace = Trace.find(response.body.to_i)
-    assert_equal "1.gpx", trace.name
-    assert_equal "New Trace", trace.description
-    assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
-    assert_equal "public", trace.visibility
-    assert_equal false, trace.inserted
-    assert_equal File.new(gpx_files(:public_trace_file).trace_name).read, File.new(trace.trace_name).read
-    trace.destroy
-    assert_equal "public", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
-
-    # Rewind the file
-    file.rewind
-
-    # Now authenticated, with the legacy private flag
-    assert_nil users(:second_public_user).preferences.where(:k => "gps.trace.visibility").first
-    basic_authorization(users(:second_public_user).display_name, "test")
-    post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :public => 0
-    assert_response :success
-    trace = Trace.find(response.body.to_i)
-    assert_equal "1.gpx", trace.name
-    assert_equal "New Trace", trace.description
-    assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
-    assert_equal "private", trace.visibility
-    assert_equal false, trace.inserted
-    assert_equal File.new(gpx_files(:public_trace_file).trace_name).read, File.new(trace.trace_name).read
-    trace.destroy
-    assert_equal "private", users(:second_public_user).preferences.where(:k => "gps.trace.visibility").first.v
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    public_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/1.gpx" do
+      # Get file to use
+      file = Rack::Test::UploadedFile.new(public_trace_file.trace_name, "application/gpx+xml")
+
+      # First with no auth
+      post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :visibility => "trackable"
+      assert_response :unauthorized
+
+      # 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
+      basic_authorization(users(:public_user).display_name, "test")
+      post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :visibility => "trackable"
+      assert_response :success
+      trace = Trace.find(response.body.to_i)
+      assert_equal "1.gpx", trace.name
+      assert_equal "New Trace", trace.description
+      assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
+      assert_equal "trackable", trace.visibility
+      assert_equal false, trace.inserted
+      assert_equal File.new(public_trace_file.trace_name).read, File.new(trace.trace_name).read
+      trace.destroy
+      assert_equal "trackable", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
+
+      # Rewind the file
+      file.rewind
+
+      # Now authenticated, with the legacy public flag
+      assert_not_equal "public", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
+      basic_authorization(users(:public_user).display_name, "test")
+      post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :public => 1
+      assert_response :success
+      trace = Trace.find(response.body.to_i)
+      assert_equal "1.gpx", trace.name
+      assert_equal "New Trace", trace.description
+      assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
+      assert_equal "public", trace.visibility
+      assert_equal false, trace.inserted
+      assert_equal File.new(public_trace_file.trace_name).read, File.new(trace.trace_name).read
+      trace.destroy
+      assert_equal "public", users(:public_user).preferences.where(:k => "gps.trace.visibility").first.v
+
+      # Rewind the file
+      file.rewind
+
+      # Now authenticated, with the legacy private flag
+      assert_nil users(:second_public_user).preferences.where(:k => "gps.trace.visibility").first
+      basic_authorization(users(:second_public_user).display_name, "test")
+      post :api_create, :file => file, :description => "New Trace", :tags => "new,trace", :public => 0
+      assert_response :success
+      trace = Trace.find(response.body.to_i)
+      assert_equal "1.gpx", trace.name
+      assert_equal "New Trace", trace.description
+      assert_equal %w(new trace), trace.tags.order(:tag).collect(&:tag)
+      assert_equal "private", trace.visibility
+      assert_equal false, trace.inserted
+      assert_equal File.new(public_trace_file.trace_name).read, File.new(trace.trace_name).read
+      trace.destroy
+      assert_equal "private", users(:second_public_user).preferences.where(:k => "gps.trace.visibility").first.v
+    end
   end
 
   # Check updating a trace through the api
   def test_api_update
-    # First with no auth
-    content gpx_files(:public_trace_file).to_xml
-    put :api_update, :id => gpx_files(:public_trace_file).id
-    assert_response :unauthorized
-
-    # Now with some other user, which should fail
-    basic_authorization(users(:public_user).display_name, "test")
-    content gpx_files(:public_trace_file).to_xml
-    put :api_update, :id => gpx_files(:public_trace_file).id
-    assert_response :forbidden
-
-    # Now with a trace which doesn't exist
-    basic_authorization(users(:public_user).display_name, "test")
-    content gpx_files(:public_trace_file).to_xml
-    put :api_update, :id => 0
-    assert_response :not_found
-
-    # Now with a trace which did exist but has been deleted
-    basic_authorization(users(:public_user).display_name, "test")
-    content gpx_files(:deleted_trace_file).to_xml
-    put :api_update, :id => gpx_files(:deleted_trace_file).id
-    assert_response :not_found
-
-    # Now try an update with the wrong ID
-    basic_authorization(users(:normal_user).display_name, "test")
-    content gpx_files(:anon_trace_file).to_xml
-    put :api_update, :id => gpx_files(: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(users(:normal_user).display_name, "test")
-    t = gpx_files(:public_trace_file)
-    t.description = "Changed description"
-    t.visibility = "private"
-    content t.to_xml
-    put :api_update, :id => t.id
-    assert_response :success
-    nt = Trace.find(t.id)
-    assert_equal nt.description, t.description
-    assert_equal nt.visibility, t.visibility
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    deleted_trace_file = create(:trace, :deleted, :user => users(:public_user))
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+
+    public_trace_file.stub :trace_name, "#{GPX_TRACE_DIR}/1.gpx" do
+      # First with no auth
+      content public_trace_file.to_xml
+      put :api_update, :id => public_trace_file.id
+      assert_response :unauthorized
+
+      # Now with some other user, which should fail
+      basic_authorization(users(:public_user).display_name, "test")
+      content public_trace_file.to_xml
+      put :api_update, :id => public_trace_file.id
+      assert_response :forbidden
+
+      # Now with a trace which doesn't exist
+      basic_authorization(users(:public_user).display_name, "test")
+      content public_trace_file.to_xml
+      put :api_update, :id => 0
+      assert_response :not_found
+
+      # Now with a trace which did exist but has been deleted
+      basic_authorization(users(:public_user).display_name, "test")
+      content deleted_trace_file.to_xml
+      put :api_update, :id => deleted_trace_file.id
+      assert_response :not_found
+
+      # Now try an update with the wrong ID
+      basic_authorization(users(:normal_user).display_name, "test")
+      content anon_trace_file.to_xml
+      put :api_update, :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(users(:normal_user).display_name, "test")
+      t = public_trace_file
+      t.description = "Changed description"
+      t.visibility = "private"
+      content t.to_xml
+      put :api_update, :id => t.id
+      assert_response :success
+      nt = Trace.find(t.id)
+      assert_equal nt.description, t.description
+      assert_equal nt.visibility, t.visibility
+    end
   end
 
   # Check deleting a trace through the api
   def test_api_delete
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+
     # First with no auth
-    delete :api_delete, :id => gpx_files(:public_trace_file).id
+    delete :api_delete, :id => public_trace_file.id
     assert_response :unauthorized
 
     # Now with some other user, which should fail
     basic_authorization(users(:public_user).display_name, "test")
-    delete :api_delete, :id => gpx_files(:public_trace_file).id
+    delete :api_delete, :id => public_trace_file.id
     assert_response :forbidden
 
     # Now with a trace which doesn't exist
@@ -828,12 +927,12 @@ class TraceControllerTest < ActionController::TestCase
 
     # And finally we should be able to do it with the owner of the trace
     basic_authorization(users(:normal_user).display_name, "test")
-    delete :api_delete, :id => gpx_files(:public_trace_file).id
+    delete :api_delete, :id => public_trace_file.id
     assert_response :success
 
     # Try it a second time, which should fail
     basic_authorization(users(:normal_user).display_name, "test")
-    delete :api_delete, :id => gpx_files(:public_trace_file).id
+    delete :api_delete, :id => public_trace_file.id
     assert_response :not_found
   end
 
index 409a93b4e26b61b52ea56e99f18b18713b6173f1..717089b64ca841d7a282fef263187be7c9ecb93b 100644 (file)
@@ -1085,6 +1085,12 @@ class UserControllerTest < ActionController::TestCase
   end
 
   def test_api_gpx_files
+    trace1 = create(:trace, :user => users(:normal_user)) do |trace|
+      create(:tracetag, :trace => trace, :tag => "London")
+    end
+    trace2 = create(:trace, :user => users(:normal_user)) do |trace|
+      create(:tracetag, :trace => trace, :tag => "Birmingham")
+    end
     # check that nothing is returned when not logged in
     get :api_gpx_files
     assert_response :unauthorized
@@ -1096,10 +1102,10 @@ class UserControllerTest < ActionController::TestCase
     assert_equal "text/xml", response.content_type
 
     # check the data that is returned
-    assert_select "gpx_file[id='1']", 1 do
+    assert_select "gpx_file[id='#{trace1.id}']", 1 do
       assert_select "tag", "London"
     end
-    assert_select "gpx_file[id='4']", 1 do
+    assert_select "gpx_file[id='#{trace2.id}']", 1 do
       assert_select "tag", "Birmingham"
     end
   end
diff --git a/test/factories/tracepoints.rb b/test/factories/tracepoints.rb
new file mode 100644 (file)
index 0000000..c47b793
--- /dev/null
@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :tracepoint do
+    trackid 1
+    latitude 1 * GeoRecord::SCALE
+    longitude 1 * GeoRecord::SCALE
+    # tile QuadTile.tile_for_point(1,1)
+    timestamp Time.now
+
+    trace
+  end
+end
diff --git a/test/factories/traces.rb b/test/factories/traces.rb
new file mode 100644 (file)
index 0000000..3f409b3
--- /dev/null
@@ -0,0 +1,16 @@
+FactoryGirl.define do
+  factory :trace do
+    sequence(:name) { |n| "Trace #{n}.gpx" }
+    sequence(:description) { |n| "This is trace #{n}" }
+
+    # Fixme requires User Factory
+    user_id 1
+
+    timestamp Time.now
+    inserted true
+
+    trait :deleted do
+      visible false
+    end
+  end
+end
diff --git a/test/factories/tracetags.rb b/test/factories/tracetags.rb
new file mode 100644 (file)
index 0000000..3dbeeb8
--- /dev/null
@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :tracetag do
+    sequence(:tag) { |n| "Tag #{n}" }
+
+    trace
+  end
+end
diff --git a/test/fixtures/gps_points.yml b/test/fixtures/gps_points.yml
deleted file mode 100644 (file)
index b3171ac..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-<% SCALE = 10000000 unless defined?(SCALE) %>
-
-first_trace_1:
-  altitude: 134
-  trackid: 1
-  latitude: <%= 1 * SCALE %>
-  longitude: <%= 1 * SCALE %>
-  gpx_id: 1
-  timestamp: "2008-10-01 10:10:10"
-  tile: <%= QuadTile.tile_for_point(1, 1) %>
-  
-trackable_trace_1:
-  trackid: 1
-  latitude: <%= (51.510 * SCALE).to_i %>
-  longitude: <%= (-0.140 * SCALE).to_i %>
-  gpx_id: 3
-  timestamp: "2009-07-30 17:46:00"
-  tile: <%= QuadTile.tile_for_point(51.510, -0.140) %>
-
-trackable_trace_2:
-  trackid: 2
-  latitude: <%= (51.511 * SCALE).to_i %>
-  longitude: <%= (-0.141 * SCALE).to_i %>
-  gpx_id: 3
-  timestamp: "2009-07-30 17:47:00"
-  tile: <%= QuadTile.tile_for_point(51.511, -0.141) %>
-
-identifiable_trace_1:
-  trackid: 1
-  latitude: <%= (51.512 * SCALE).to_i %>
-  longitude: <%= (0.142 * SCALE).to_i %>
-  gpx_id: 4
-  timestamp: "2009-07-30 17:46:00"
-  tile: <%= QuadTile.tile_for_point(51.512, 0.142) %>
-
diff --git a/test/fixtures/gpx_file_tags.yml b/test/fixtures/gpx_file_tags.yml
deleted file mode 100644 (file)
index 1dac0f2..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-first_trace_1:
-  gpx_id: 1
-  tag: London
-  id: 1
-
-second_trace_1:
-  gpx_id: 2
-  tag: London
-  id: 2
-
-second_trace_2:
-  gpx_id: 2
-  tag: Birmingham
-  id: 3
-
-third_trace_1:
-  gpx_id: 4
-  tag: Birmingham
-  id: 4
diff --git a/test/fixtures/gpx_files.yml b/test/fixtures/gpx_files.yml
deleted file mode 100644 (file)
index 4af266c..0000000
+++ /dev/null
@@ -1,129 +0,0 @@
-public_trace_file:
-  id: 1
-  user_id: 1
-  visible: true
-  name: Fist Trace.gpx
-  size:
-  latitude: 1
-  longitude: 1
-  timestamp: "2008-10-29 10:10:10"
-  visibility: "public"
-  description: This is a trace
-  inserted: true
-
-anon_trace_file:
-  id: 2
-  user_id: 2
-  visible: true
-  name: Private Trace.gpx
-  size: 123
-  latitude: 51.3
-  longitude: -0.56
-  timestamp: "2009-05-06 13:34:34"
-  visibility: "private"
-  description: This is an anonymous trace
-  inserted: true
-
-trackable_trace_file:
-  id: 3
-  user_id: 2
-  visible: true
-  name: Trackable Trace.gpx
-  size: 123
-  latitude: 51.51
-  longitude: -0.14
-  timestamp: "2009-07-30 17:48:34"
-  visibility: "trackable"
-  description: This trace shows trksegs and timestamps, but no user details.
-  inserted: true
-
-identifiable_trace_file:
-  id: 4
-  user_id: 1
-  visible: true
-  name: Identifiable Trace.gpx
-  size: 123
-  latitude: 51.512
-  longitude: 0.142
-  timestamp: "2009-07-30 17:48:34"
-  visibility: "identifiable"
-  description: This trace shows trksegs, timestamps and user details.
-  inserted: true
-
-deleted_trace_file:
-  id: 5
-  user_id: 2
-  visible: false
-  name: Deleted Trace.gpx
-  size: 123
-  latitude: 51.512
-  longitude: 0.142
-  timestamp: "2009-07-30 17:48:34"
-  visibility: "public"
-  description: This is a trace that has been deleted.
-  inserted: true
-
-zipped_trace_file:
-  id: 6
-  user_id: 4
-  visible: true
-  name: Zipped Trace.gpx
-  size:
-  latitude: 1
-  longitude: 1
-  timestamp: "2008-10-29 10:10:10"
-  visibility: "private"
-  description: This is a zipped trace
-  inserted: true
-
-tar_trace_file:
-  id: 7
-  user_id: 4
-  visible: true
-  name: Tarred Trace.gpx
-  size:
-  latitude: 1
-  longitude: 1
-  timestamp: "2008-10-29 10:10:10"
-  visibility: "private"
-  description: This is a tarred trace
-  inserted: true
-
-tar_gzip_trace_file:
-  id: 8
-  user_id: 4
-  visible: true
-  name: Gzipped Tarred Trace.gpx
-  size:
-  latitude: 1
-  longitude: 1
-  timestamp: "2008-10-29 10:10:10"
-  visibility: "private"
-  description: This is a gzipped tarred trace
-  inserted: true
-
-tar_bzip_trace_file:
-  id: 9
-  user_id: 4
-  visible: true
-  name: Bzipped Tarred Trace.gpx
-  size:
-  latitude: 1
-  longitude: 1
-  timestamp: "2008-10-29 10:10:10"
-  visibility: "private"
-  description: This is a bzipped tarred trace
-  inserted: true
-
-pending_trace_file:
-  id: 10
-  user_id: 2
-  visible: true
-  name: Pending Trace.gpx
-  size: 123
-  latitude: 51.3
-  longitude: -0.56
-  timestamp: "2009-05-06 13:34:34"
-  visibility: "public"
-  description: This is a pending trace
-  inserted: false
index 00a9ae06d50a0e40b6722966f36206a44fb7092c..ad3d5383dba05ee151c6e27a0cd4658a38acfc31 100644 (file)
@@ -1,8 +1,7 @@
 require "test_helper"
 
 class OAuthTest < ActionDispatch::IntegrationTest
-  fixtures :users, :client_applications, :gpx_files
-  set_fixture_class :gpx_files => Trace
+  fixtures :users, :client_applications
 
   include OAuth::Helper
 
@@ -164,7 +163,8 @@ class OAuthTest < ActionDispatch::IntegrationTest
     assert_nil token.invalidated_at
     assert_allowed token, [:allow_write_api, :allow_read_gpx]
 
-    signed_get "/api/0.6/gpx/2", :consumer => client, :token => token
+    trace = create(:trace, :user => users(:public_user))
+    signed_get "/api/0.6/gpx/#{trace.id}", :consumer => client, :token => token
     assert_response :success
 
     signed_get "/api/0.6/user/details", :consumer => client, :token => token
@@ -226,7 +226,8 @@ class OAuthTest < ActionDispatch::IntegrationTest
     signed_get "/api/0.6/user/preferences", :consumer => client, :token => token
     assert_response :success
 
-    signed_get "/api/0.6/gpx/2", :consumer => client, :token => token
+    trace = create(:trace, :user => users(:public_user))
+    signed_get "/api/0.6/gpx/#{trace.id}", :consumer => client, :token => token
     assert_response :forbidden
 
     post "/oauth/revoke", :token => token.token
@@ -274,7 +275,8 @@ class OAuthTest < ActionDispatch::IntegrationTest
     assert_nil token.invalidated_at
     assert_allowed token, [:allow_write_api, :allow_read_gpx]
 
-    signed_get "/api/0.6/gpx/2", :consumer => client, :token => token
+    trace = create(:trace, :user => users(:public_user))
+    signed_get "/api/0.6/gpx/#{trace.id}", :consumer => client, :token => token
     assert_response :success
 
     signed_get "/api/0.6/user/details", :consumer => client, :token => token
index 32d98c9ebdb8588cfc6136138555b9259711ae5f..1cb94aeef247eb1e3b4b7d28cc1ad4cb1415bc2b 100644 (file)
@@ -1,8 +1,9 @@
 require "test_helper"
 require "digest"
+require "minitest/mock"
 
 class TraceTest < ActiveSupport::TestCase
-  api_fixtures
+  fixtures :users
 
   def setup
     @gpx_trace_dir = Object.send("remove_const", "GPX_TRACE_DIR")
@@ -20,41 +21,55 @@ class TraceTest < ActiveSupport::TestCase
     Object.const_set("GPX_IMAGE_DIR", @gpx_image_dir)
   end
 
-  def test_trace_count
-    assert_equal 10, Trace.count
-  end
-
   def test_visible
-    check_query(Trace.visible, [
-                  :public_trace_file, :anon_trace_file, :trackable_trace_file,
-                  :identifiable_trace_file, :zipped_trace_file, :tar_trace_file,
-                  :tar_gzip_trace_file, :tar_bzip_trace_file, :pending_trace_file
-                ])
+    public_trace_file = create(:trace)
+    create(:trace, :deleted)
+    check_query(Trace.visible, [public_trace_file])
   end
 
   def test_visible_to
-    check_query(Trace.visible_to(1), [
-                  :public_trace_file, :identifiable_trace_file, :pending_trace_file
+    public_trace_file = create(:trace, :visibility => "public", :user => users(:normal_user))
+    anon_trace_file = create(:trace, :visibility => "private", :user => users(:public_user))
+    identifiable_trace_file = create(:trace, :visibility => "identifiable", :user => users(:normal_user))
+    pending_trace_file = create(:trace, :visibility => "public", :user => users(:public_user), :inserted => false)
+    trackable_trace_file = create(:trace, :visibility => "trackable", :user => users(:public_user))
+    _other_trace_file = create(:trace, :visibility => "private", :user => users(:second_public_user))
+
+    check_query(Trace.visible_to(users(:normal_user).id), [
+                  public_trace_file, identifiable_trace_file, pending_trace_file
                 ])
-    check_query(Trace.visible_to(2), [
-                  :public_trace_file, :anon_trace_file, :trackable_trace_file,
-                  :identifiable_trace_file, :pending_trace_file
+    check_query(Trace.visible_to(users(:public_user)), [
+                  public_trace_file, anon_trace_file, trackable_trace_file,
+                  identifiable_trace_file, pending_trace_file
                 ])
-    check_query(Trace.visible_to(3), [
-                  :public_trace_file, :identifiable_trace_file, :pending_trace_file
+    check_query(Trace.visible_to(users(:inactive_user)), [
+                  public_trace_file, identifiable_trace_file, pending_trace_file
                 ])
   end
 
   def test_visible_to_all
+    public_trace_file = create(:trace, :visibility => "public")
+    _private_trace_file = create(:trace, :visibility => "private")
+    identifiable_trace_file = create(:trace, :visibility => "identifiable")
+    _trackable_trace_file = create(:trace, :visibility => "trackable")
+    deleted_trace_file = create(:trace, :deleted, :visibility => "public")
+    pending_trace_file = create(:trace, :visibility => "public", :inserted => false)
+
     check_query(Trace.visible_to_all, [
-                  :public_trace_file, :identifiable_trace_file,
-                  :deleted_trace_file, :pending_trace_file
+                  public_trace_file, identifiable_trace_file,
+                  deleted_trace_file, pending_trace_file
                 ])
   end
 
   def test_tagged
-    check_query(Trace.tagged("London"), [:public_trace_file, :anon_trace_file])
-    check_query(Trace.tagged("Birmingham"), [:anon_trace_file, :identifiable_trace_file])
+    london_trace_file = create(:trace) do |trace|
+      create(:tracetag, :trace => trace, :tag => "London")
+    end
+    birmingham_trace_file = create(:trace) do |trace|
+      create(:tracetag, :trace => trace, :tag => "Birmingham")
+    end
+    check_query(Trace.tagged("London"), [london_trace_file])
+    check_query(Trace.tagged("Birmingham"), [birmingham_trace_file])
     check_query(Trace.tagged("Unknown"), [])
   end
 
@@ -74,7 +89,7 @@ class TraceTest < ActiveSupport::TestCase
   end
 
   def test_tagstring
-    trace = Trace.new(gpx_files(:public_trace_file).attributes)
+    trace = build(:trace)
     trace.tagstring = "foo bar baz"
     assert trace.valid?
     assert_equal 3, trace.tags.length
@@ -92,66 +107,71 @@ class TraceTest < ActiveSupport::TestCase
   end
 
   def test_public?
-    assert_equal true, gpx_files(:public_trace_file).public?
-    assert_equal false, gpx_files(:anon_trace_file).public?
-    assert_equal false, gpx_files(:trackable_trace_file).public?
-    assert_equal true, gpx_files(:identifiable_trace_file).public?
-    assert_equal true, gpx_files(:deleted_trace_file).public?
+    assert_equal true, build(:trace, :visibility => "public").public?
+    assert_equal false, build(:trace, :visibility => "private").public?
+    assert_equal false, build(:trace, :visibility => "trackable").public?
+    assert_equal true, build(:trace, :visibility => "identifiable").public?
+    assert_equal true, build(:trace, :deleted, :visibility => "public").public?
   end
 
   def test_trackable?
-    assert_equal false, gpx_files(:public_trace_file).trackable?
-    assert_equal false, gpx_files(:anon_trace_file).trackable?
-    assert_equal true, gpx_files(:trackable_trace_file).trackable?
-    assert_equal true, gpx_files(:identifiable_trace_file).trackable?
-    assert_equal false, gpx_files(:deleted_trace_file).trackable?
+    assert_equal false, build(:trace, :visibility => "public").trackable?
+    assert_equal false, build(:trace, :visibility => "private").trackable?
+    assert_equal true, build(:trace, :visibility => "trackable").trackable?
+    assert_equal true, build(:trace, :visibility => "identifiable").trackable?
+    assert_equal false, build(:trace, :deleted, :visibility => "public").trackable?
   end
 
   def test_identifiable?
-    assert_equal false, gpx_files(:public_trace_file).identifiable?
-    assert_equal false, gpx_files(:anon_trace_file).identifiable?
-    assert_equal false, gpx_files(:trackable_trace_file).identifiable?
-    assert_equal true, gpx_files(:identifiable_trace_file).identifiable?
-    assert_equal false, gpx_files(:deleted_trace_file).identifiable?
+    assert_equal false, build(:trace, :visibility => "public").identifiable?
+    assert_equal false, build(:trace, :visibility => "private").identifiable?
+    assert_equal false, build(:trace, :visibility => "trackable").identifiable?
+    assert_equal true, build(:trace, :visibility => "identifiable").identifiable?
+    assert_equal false, build(:trace, :deleted, :visibility => "public").identifiable?
   end
 
   def test_mime_type
-    assert_equal "application/gpx+xml", gpx_files(:public_trace_file).mime_type
-    assert_equal "application/gpx+xml", gpx_files(:anon_trace_file).mime_type
-    assert_equal "application/x-bzip2", gpx_files(:trackable_trace_file).mime_type
-    assert_equal "application/x-gzip", gpx_files(:identifiable_trace_file).mime_type
-    assert_equal "application/x-zip", gpx_files(:zipped_trace_file).mime_type
-    assert_equal "application/x-tar", gpx_files(:tar_trace_file).mime_type
-    assert_equal "application/x-gzip", gpx_files(:tar_gzip_trace_file).mime_type
-    assert_equal "application/x-bzip2", gpx_files(:tar_bzip_trace_file).mime_type
+    # The ids refer to the .gpx fixtures in test/traces
+    check_mime_type(1, "application/gpx+xml")
+    check_mime_type(2, "application/gpx+xml")
+    check_mime_type(3, "application/x-bzip2")
+    check_mime_type(4, "application/x-gzip")
+    check_mime_type(6, "application/x-zip")
+    check_mime_type(7, "application/x-tar")
+    check_mime_type(8, "application/x-gzip")
+    check_mime_type(9, "application/x-bzip2")
   end
 
   def test_extension_name
-    assert_equal ".gpx", gpx_files(:public_trace_file).extension_name
-    assert_equal ".gpx", gpx_files(:anon_trace_file).extension_name
-    assert_equal ".gpx.bz2", gpx_files(:trackable_trace_file).extension_name
-    assert_equal ".gpx.gz", gpx_files(:identifiable_trace_file).extension_name
-    assert_equal ".zip", gpx_files(:zipped_trace_file).extension_name
-    assert_equal ".tar", gpx_files(:tar_trace_file).extension_name
-    assert_equal ".tar.gz", gpx_files(:tar_gzip_trace_file).extension_name
-    assert_equal ".tar.bz2", gpx_files(:tar_bzip_trace_file).extension_name
+    # The ids refer to the .gpx fixtures in test/traces
+    check_extension_name(1, ".gpx")
+    check_extension_name(2, ".gpx")
+    check_extension_name(3, ".gpx.bz2")
+    check_extension_name(4, ".gpx.gz")
+    check_extension_name(6, ".zip")
+    check_extension_name(7, ".tar")
+    check_extension_name(8, ".tar.gz")
+    check_extension_name(9, ".tar.bz2")
   end
 
   def test_xml_file
-    assert_equal "848caa72f2f456d1bd6a0fdf228aa1b9", md5sum(gpx_files(:public_trace_file).xml_file)
-    assert_equal "66179ca44f1e93d8df62e2b88cbea732", md5sum(gpx_files(:anon_trace_file).xml_file)
-    assert_equal "848caa72f2f456d1bd6a0fdf228aa1b9", md5sum(gpx_files(:trackable_trace_file).xml_file)
-    assert_equal "abd6675fdf3024a84fc0a1deac147c0d", md5sum(gpx_files(:identifiable_trace_file).xml_file)
-    assert_equal "848caa72f2f456d1bd6a0fdf228aa1b9", md5sum(gpx_files(:zipped_trace_file).xml_file)
-    assert_equal "848caa72f2f456d1bd6a0fdf228aa1b9", md5sum(gpx_files(:tar_trace_file).xml_file)
-    assert_equal "848caa72f2f456d1bd6a0fdf228aa1b9", md5sum(gpx_files(:tar_gzip_trace_file).xml_file)
-    assert_equal "848caa72f2f456d1bd6a0fdf228aa1b9", md5sum(gpx_files(:tar_bzip_trace_file).xml_file)
+    check_xml_file(1, "848caa72f2f456d1bd6a0fdf228aa1b9")
+    check_xml_file(2, "66179ca44f1e93d8df62e2b88cbea732")
+    check_xml_file(3, "848caa72f2f456d1bd6a0fdf228aa1b9")
+    check_xml_file(4, "abd6675fdf3024a84fc0a1deac147c0d")
+    check_xml_file(6, "848caa72f2f456d1bd6a0fdf228aa1b9")
+    check_xml_file(7, "848caa72f2f456d1bd6a0fdf228aa1b9")
+    check_xml_file(8, "848caa72f2f456d1bd6a0fdf228aa1b9")
+    check_xml_file(9, "848caa72f2f456d1bd6a0fdf228aa1b9")
   end
 
   def test_large_picture
-    picture = gpx_files(:public_trace_file).large_picture
-    trace = Trace.create
+    trace = create(:trace)
+    picture = trace.stub :large_picture_name, "#{GPX_IMAGE_DIR}/1.gif" do
+      trace.large_picture
+    end
 
+    trace = Trace.create
     trace.large_picture = picture
     assert_equal "7c841749e084ee4a5d13f12cd3bef456", md5sum(File.new(trace.large_picture_name))
     assert_equal picture, trace.large_picture
@@ -160,9 +180,12 @@ class TraceTest < ActiveSupport::TestCase
   end
 
   def test_icon_picture
-    picture = gpx_files(:public_trace_file).icon_picture
-    trace = Trace.create
+    trace = create(:trace)
+    picture = trace.stub :icon_picture_name, "#{GPX_IMAGE_DIR}/1_icon.gif" do
+      trace.icon_picture
+    end
 
+    trace = Trace.create
     trace.icon_picture = picture
     assert_equal "b47baf22ed0e85d77e808694fad0ee27", md5sum(File.new(trace.icon_picture_name))
     assert_equal picture, trace.icon_picture
@@ -173,12 +196,33 @@ class TraceTest < ActiveSupport::TestCase
   private
 
   def check_query(query, traces)
-    traces = traces.map { |t| gpx_files(t).id }.sort
+    traces = traces.map { |t| t.id }.sort
     assert_equal traces, query.order(:id).ids
   end
 
+  def check_mime_type(id, mime_type)
+    trace = create(:trace)
+    trace.stub :trace_name, "#{GPX_TRACE_DIR}/#{id}.gpx" do
+      assert_equal mime_type, trace.mime_type
+    end
+  end
+
+  def check_extension_name(id, extension_name)
+    trace = create(:trace)
+    trace.stub :trace_name, "#{GPX_TRACE_DIR}/#{id}.gpx" do
+      assert_equal extension_name, trace.extension_name
+    end
+  end
+
+  def check_xml_file(id, md5sum)
+    trace = create(:trace)
+    trace.stub :trace_name, "#{GPX_TRACE_DIR}/#{id}.gpx" do
+      assert_equal md5sum, md5sum(trace.xml_file)
+    end
+  end
+
   def trace_valid(attrs, result = true)
-    entry = Trace.new(gpx_files(:public_trace_file).attributes)
+    entry = build(:trace)
     entry.assign_attributes(attrs)
     assert_equal result, entry.valid?, "Expected #{attrs.inspect} to be #{result}"
   end
index e24a833cf06f93a0b88649c4389d05435705a4eb..45dd7496f838f836bf301b082b7d1eb772f29802 100644 (file)
@@ -1,9 +1,10 @@
 require "test_helper"
 
 class TracepointTest < ActiveSupport::TestCase
-  api_fixtures
-
-  def test_tracepoint_count
-    assert_equal 4, Tracepoint.count
+  def test_timestamp_required
+    tracepoint = create(:tracepoint)
+    assert tracepoint.valid?
+    tracepoint.timestamp = nil
+    assert !tracepoint.valid?
   end
 end
index a13d41e4a0f4876130e7a4cd6979891a652d8219..04263dbb74e905e3a65128fdb01409aaf3493564 100644 (file)
@@ -1,12 +1,6 @@
 require "test_helper"
 
 class TracetagTest < ActiveSupport::TestCase
-  api_fixtures
-
-  def test_tracetag_count
-    assert_equal 4, Tracetag.count
-  end
-
   def test_validations
     tracetag_valid({})
     tracetag_valid({ :tag => nil }, false)
@@ -24,7 +18,7 @@ class TracetagTest < ActiveSupport::TestCase
   private
 
   def tracetag_valid(attrs, result = true)
-    entry = Tracetag.new(gpx_file_tags(:first_trace_1).attributes)
+    entry = build(:tracetag)
     entry.assign_attributes(attrs)
     assert_equal result, entry.valid?, "Expected #{attrs.inspect} to be #{result}"
   end
index 0cf7c4afba2037bff098d1613079b9c26a7a97ec..77674147f6c346a7c6349aef27aca890fba1f01e 100644 (file)
@@ -52,11 +52,6 @@ module ActiveSupport
       set_fixture_class :relation_members => OldRelationMember
       set_fixture_class :relation_tags => OldRelationTag
 
-      fixtures :gpx_files, :gps_points, :gpx_file_tags
-      set_fixture_class :gpx_files => Trace
-      set_fixture_class :gps_points => Tracepoint
-      set_fixture_class :gpx_file_tags => Tracetag
-
       fixtures :client_applications
 
       fixtures :redactions