Move the api trace methods into a separate controller under the api namespace
[rails.git] / test / controllers / traces_controller_test.rb
1 require "test_helper"
2 require "minitest/mock"
3
4 class TracesControllerTest < ActionController::TestCase
5   def setup
6     @gpx_trace_dir = Object.send("remove_const", "GPX_TRACE_DIR")
7     Object.const_set("GPX_TRACE_DIR", Rails.root.join("test", "gpx", "traces"))
8
9     @gpx_image_dir = Object.send("remove_const", "GPX_IMAGE_DIR")
10     Object.const_set("GPX_IMAGE_DIR", Rails.root.join("test", "gpx", "images"))
11   end
12
13   def teardown
14     File.unlink(*Dir.glob(File.join(GPX_TRACE_DIR, "*.gpx")))
15     File.unlink(*Dir.glob(File.join(GPX_IMAGE_DIR, "*.gif")))
16
17     Object.send("remove_const", "GPX_TRACE_DIR")
18     Object.const_set("GPX_TRACE_DIR", @gpx_trace_dir)
19
20     Object.send("remove_const", "GPX_IMAGE_DIR")
21     Object.const_set("GPX_IMAGE_DIR", @gpx_image_dir)
22   end
23
24   ##
25   # test all routes which lead to this controller
26   def test_routes
27     assert_routing(
28       { :path => "/traces", :method => :get },
29       { :controller => "traces", :action => "index" }
30     )
31     assert_routing(
32       { :path => "/traces/page/1", :method => :get },
33       { :controller => "traces", :action => "index", :page => "1" }
34     )
35     assert_routing(
36       { :path => "/traces/tag/tagname", :method => :get },
37       { :controller => "traces", :action => "index", :tag => "tagname" }
38     )
39     assert_routing(
40       { :path => "/traces/tag/tagname/page/1", :method => :get },
41       { :controller => "traces", :action => "index", :tag => "tagname", :page => "1" }
42     )
43     assert_routing(
44       { :path => "/user/username/traces", :method => :get },
45       { :controller => "traces", :action => "index", :display_name => "username" }
46     )
47     assert_routing(
48       { :path => "/user/username/traces/page/1", :method => :get },
49       { :controller => "traces", :action => "index", :display_name => "username", :page => "1" }
50     )
51     assert_routing(
52       { :path => "/user/username/traces/tag/tagname", :method => :get },
53       { :controller => "traces", :action => "index", :display_name => "username", :tag => "tagname" }
54     )
55     assert_routing(
56       { :path => "/user/username/traces/tag/tagname/page/1", :method => :get },
57       { :controller => "traces", :action => "index", :display_name => "username", :tag => "tagname", :page => "1" }
58     )
59
60     assert_routing(
61       { :path => "/traces/mine", :method => :get },
62       { :controller => "traces", :action => "mine" }
63     )
64     assert_routing(
65       { :path => "/traces/mine/page/1", :method => :get },
66       { :controller => "traces", :action => "mine", :page => "1" }
67     )
68     assert_routing(
69       { :path => "/traces/mine/tag/tagname", :method => :get },
70       { :controller => "traces", :action => "mine", :tag => "tagname" }
71     )
72     assert_routing(
73       { :path => "/traces/mine/tag/tagname/page/1", :method => :get },
74       { :controller => "traces", :action => "mine", :tag => "tagname", :page => "1" }
75     )
76
77     assert_routing(
78       { :path => "/traces/rss", :method => :get },
79       { :controller => "traces", :action => "georss", :format => :rss }
80     )
81     assert_routing(
82       { :path => "/traces/tag/tagname/rss", :method => :get },
83       { :controller => "traces", :action => "georss", :tag => "tagname", :format => :rss }
84     )
85     assert_routing(
86       { :path => "/user/username/traces/rss", :method => :get },
87       { :controller => "traces", :action => "georss", :display_name => "username", :format => :rss }
88     )
89     assert_routing(
90       { :path => "/user/username/traces/tag/tagname/rss", :method => :get },
91       { :controller => "traces", :action => "georss", :display_name => "username", :tag => "tagname", :format => :rss }
92     )
93
94     assert_routing(
95       { :path => "/user/username/traces/1", :method => :get },
96       { :controller => "traces", :action => "show", :display_name => "username", :id => "1" }
97     )
98     assert_routing(
99       { :path => "/user/username/traces/1/picture", :method => :get },
100       { :controller => "traces", :action => "picture", :display_name => "username", :id => "1" }
101     )
102     assert_routing(
103       { :path => "/user/username/traces/1/icon", :method => :get },
104       { :controller => "traces", :action => "icon", :display_name => "username", :id => "1" }
105     )
106
107     assert_routing(
108       { :path => "/traces/new", :method => :get },
109       { :controller => "traces", :action => "new" }
110     )
111     assert_routing(
112       { :path => "/traces", :method => :post },
113       { :controller => "traces", :action => "create" }
114     )
115     assert_routing(
116       { :path => "/trace/1/data", :method => :get },
117       { :controller => "traces", :action => "data", :id => "1" }
118     )
119     assert_routing(
120       { :path => "/trace/1/data.xml", :method => :get },
121       { :controller => "traces", :action => "data", :id => "1", :format => "xml" }
122     )
123     assert_routing(
124       { :path => "/traces/1/edit", :method => :get },
125       { :controller => "traces", :action => "edit", :id => "1" }
126     )
127     assert_routing(
128       { :path => "/traces/1", :method => :put },
129       { :controller => "traces", :action => "update", :id => "1" }
130     )
131     assert_routing(
132       { :path => "/trace/1/delete", :method => :post },
133       { :controller => "traces", :action => "delete", :id => "1" }
134     )
135   end
136
137   # Check that the index of traces is displayed
138   def test_index
139     user = create(:user)
140     # The fourth test below is surpisingly sensitive to timestamp ordering when the timestamps are equal.
141     trace_a = create(:trace, :visibility => "public", :timestamp => 4.seconds.ago) do |trace|
142       create(:tracetag, :trace => trace, :tag => "London")
143     end
144     trace_b = create(:trace, :visibility => "public", :timestamp => 3.seconds.ago) do |trace|
145       create(:tracetag, :trace => trace, :tag => "Birmingham")
146     end
147     trace_c = create(:trace, :visibility => "private", :user => user, :timestamp => 2.seconds.ago) do |trace|
148       create(:tracetag, :trace => trace, :tag => "London")
149     end
150     trace_d = create(:trace, :visibility => "private", :user => user, :timestamp => 1.second.ago) do |trace|
151       create(:tracetag, :trace => trace, :tag => "Birmingham")
152     end
153
154     # First with the public index
155     get :index
156     check_trace_index [trace_b, trace_a]
157
158     # Restrict traces to those with a given tag
159     get :index, :params => { :tag => "London" }
160     check_trace_index [trace_a]
161
162     # Should see more when we are logged in
163     get :index, :session => { :user => user }
164     check_trace_index [trace_d, trace_c, trace_b, trace_a]
165
166     # Again, we should see more when we are logged in
167     get :index, :params => { :tag => "London" }, :session => { :user => user }
168     check_trace_index [trace_c, trace_a]
169   end
170
171   # Check that I can get mine
172   def test_index_mine
173     user = create(:user)
174     create(:trace, :visibility => "public") do |trace|
175       create(:tracetag, :trace => trace, :tag => "Birmingham")
176     end
177     trace_b = create(:trace, :visibility => "private", :user => user) do |trace|
178       create(:tracetag, :trace => trace, :tag => "London")
179     end
180
181     # First try to get it when not logged in
182     get :mine
183     assert_redirected_to :controller => "users", :action => "login", :referer => "/traces/mine"
184
185     # Now try when logged in
186     get :mine, :session => { :user => user }
187     assert_redirected_to :action => "index", :display_name => user.display_name
188
189     # Fetch the actual index
190     get :index, :params => { :display_name => user.display_name }, :session => { :user => user }
191     check_trace_index [trace_b]
192   end
193
194   # Check the index of traces for a specific user
195   def test_index_user
196     user = create(:user)
197     second_user = create(:user)
198     third_user = create(:user)
199     create(:trace)
200     trace_b = create(:trace, :visibility => "public", :user => user)
201     trace_c = create(:trace, :visibility => "private", :user => user) do |trace|
202       create(:tracetag, :trace => trace, :tag => "London")
203     end
204
205     # Test a user with no traces
206     get :index, :params => { :display_name => second_user.display_name }
207     check_trace_index []
208
209     # Test the user with the traces - should see only public ones
210     get :index, :params => { :display_name => user.display_name }
211     check_trace_index [trace_b]
212
213     # Should still see only public ones when authenticated as another user
214     get :index, :params => { :display_name => user.display_name }, :session => { :user => third_user }
215     check_trace_index [trace_b]
216
217     # Should see all traces when authenticated as the target user
218     get :index, :params => { :display_name => user.display_name }, :session => { :user => user }
219     check_trace_index [trace_c, trace_b]
220
221     # Should only see traces with the correct tag when a tag is specified
222     get :index, :params => { :display_name => user.display_name, :tag => "London" }, :session => { :user => user }
223     check_trace_index [trace_c]
224
225     # Should get an error if the user does not exist
226     get :index, :params => { :display_name => "UnknownUser" }
227     assert_response :not_found
228     assert_template "users/no_such_user"
229   end
230
231   # Check a multi-page index
232   def test_index_paged
233     # Create several pages worth of traces
234     create_list(:trace, 50)
235
236     # Try and get the index
237     get :index
238     assert_response :success
239     assert_select "table#trace_list tbody", :count => 1 do
240       assert_select "tr", :count => 20
241     end
242
243     # Try and get the second page
244     get :index, :params => { :page => 2 }
245     assert_response :success
246     assert_select "table#trace_list tbody", :count => 1 do
247       assert_select "tr", :count => 20
248     end
249   end
250
251   # Check the RSS feed
252   def test_rss
253     user = create(:user)
254     # The fourth test below is surpisingly sensitive to timestamp ordering when the timestamps are equal.
255     trace_a = create(:trace, :visibility => "public", :timestamp => 4.seconds.ago) do |trace|
256       create(:tracetag, :trace => trace, :tag => "London")
257     end
258     trace_b = create(:trace, :visibility => "public", :timestamp => 3.seconds.ago) do |trace|
259       create(:tracetag, :trace => trace, :tag => "Birmingham")
260     end
261     create(:trace, :visibility => "private", :user => user, :timestamp => 2.seconds.ago) do |trace|
262       create(:tracetag, :trace => trace, :tag => "London")
263     end
264     create(:trace, :visibility => "private", :user => user, :timestamp => 1.second.ago) do |trace|
265       create(:tracetag, :trace => trace, :tag => "Birmingham")
266     end
267
268     # First with the public feed
269     get :georss, :params => { :format => :rss }
270     check_trace_feed [trace_b, trace_a]
271
272     # Restrict traces to those with a given tag
273     get :georss, :params => { :tag => "London", :format => :rss }
274     check_trace_feed [trace_a]
275   end
276
277   # Check the RSS feed for a specific user
278   def test_rss_user
279     user = create(:user)
280     second_user = create(:user)
281     create(:user)
282     create(:trace)
283     trace_b = create(:trace, :visibility => "public", :timestamp => 4.seconds.ago, :user => user)
284     trace_c = create(:trace, :visibility => "public", :timestamp => 3.seconds.ago, :user => user) do |trace|
285       create(:tracetag, :trace => trace, :tag => "London")
286     end
287     create(:trace, :visibility => "private")
288
289     # Test a user with no traces
290     get :georss, :params => { :display_name => second_user.display_name, :format => :rss }
291     check_trace_feed []
292
293     # Test the user with the traces - should see only public ones
294     get :georss, :params => { :display_name => user.display_name, :format => :rss }
295     check_trace_feed [trace_c, trace_b]
296
297     # Should only see traces with the correct tag when a tag is specified
298     get :georss, :params => { :display_name => user.display_name, :tag => "London", :format => :rss }
299     check_trace_feed [trace_c]
300
301     # Should no traces if the user does not exist
302     get :georss, :params => { :display_name => "UnknownUser", :format => :rss }
303     check_trace_feed []
304   end
305
306   # Test showing a trace
307   def test_show
308     public_trace_file = create(:trace, :visibility => "public")
309
310     # First with no auth, which should work since the trace is public
311     get :show, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }
312     check_trace_show public_trace_file
313
314     # Now with some other user, which should work since the trace is public
315     get :show, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => create(:user) }
316     check_trace_show public_trace_file
317
318     # And finally we should be able to do it with the owner of the trace
319     get :show, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => public_trace_file.user }
320     check_trace_show public_trace_file
321   end
322
323   # Check an anonymous trace can't be viewed by another user
324   def test_show_anon
325     anon_trace_file = create(:trace, :visibility => "private")
326
327     # First with no auth
328     get :show, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }
329     assert_response :redirect
330     assert_redirected_to :action => :index
331
332     # Now with some other user, which should not work since the trace is anon
333     get :show, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => create(:user) }
334     assert_response :redirect
335     assert_redirected_to :action => :index
336
337     # And finally we should be able to do it with the owner of the trace
338     get :show, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => anon_trace_file.user }
339     check_trace_show anon_trace_file
340   end
341
342   # Test showing a trace that doesn't exist
343   def test_show_not_found
344     deleted_trace_file = create(:trace, :deleted)
345
346     # First with a trace that has never existed
347     get :show, :params => { :display_name => create(:user).display_name, :id => 0 }
348     assert_response :redirect
349     assert_redirected_to :action => :index
350
351     # Now with a trace that has been deleted
352     get :show, :params => { :display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file.id }, :session => { :user => deleted_trace_file.user }
353     assert_response :redirect
354     assert_redirected_to :action => :index
355   end
356
357   # Test downloading a trace
358   def test_data
359     public_trace_file = create(:trace, :visibility => "public", :fixture => "a")
360
361     # First with no auth, which should work since the trace is public
362     get :data, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }
363     check_trace_data public_trace_file, "848caa72f2f456d1bd6a0fdf228aa1b9"
364
365     # Now with some other user, which should work since the trace is public
366     get :data, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => create(:user) }
367     check_trace_data public_trace_file, "848caa72f2f456d1bd6a0fdf228aa1b9"
368
369     # And finally we should be able to do it with the owner of the trace
370     get :data, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => public_trace_file.user }
371     check_trace_data public_trace_file, "848caa72f2f456d1bd6a0fdf228aa1b9"
372   end
373
374   # Test downloading a compressed trace
375   def test_data_compressed
376     identifiable_trace_file = create(:trace, :visibility => "identifiable", :fixture => "d")
377
378     # First get the data as is
379     get :data, :params => { :display_name => identifiable_trace_file.user.display_name, :id => identifiable_trace_file.id }
380     check_trace_data identifiable_trace_file, "c6422a3d8750faae49ed70e7e8a51b93", "application/x-gzip", "gpx.gz"
381
382     # Now ask explicitly for XML format
383     get :data, :params => { :display_name => identifiable_trace_file.user.display_name, :id => identifiable_trace_file.id, :format => "xml" }
384     check_trace_data identifiable_trace_file, "abd6675fdf3024a84fc0a1deac147c0d", "application/xml", "xml"
385
386     # Now ask explicitly for GPX format
387     get :data, :params => { :display_name => identifiable_trace_file.user.display_name, :id => identifiable_trace_file.id, :format => "gpx" }
388     check_trace_data identifiable_trace_file, "abd6675fdf3024a84fc0a1deac147c0d"
389   end
390
391   # Check an anonymous trace can't be downloaded by another user
392   def test_data_anon
393     anon_trace_file = create(:trace, :visibility => "private", :fixture => "b")
394
395     # First with no auth
396     get :data, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }
397     assert_response :not_found
398
399     # Now with some other user, which shouldn't work since the trace is anon
400     get :data, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => create(:user) }
401     assert_response :not_found
402
403     # And finally we should be able to do it with the owner of the trace
404     get :data, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => anon_trace_file.user }
405     check_trace_data anon_trace_file, "66179ca44f1e93d8df62e2b88cbea732"
406   end
407
408   # Test downloading a trace that doesn't exist
409   def test_data_not_found
410     deleted_trace_file = create(:trace, :deleted)
411
412     # First with a trace that has never existed
413     get :data, :params => { :display_name => create(:user).display_name, :id => 0 }
414     assert_response :not_found
415
416     # Now with a trace that has been deleted
417     get :data, :params => { :display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file.id }, :session => { :user => deleted_trace_file.user }
418     assert_response :not_found
419   end
420
421   # Test downloading the picture for a trace
422   def test_picture
423     public_trace_file = create(:trace, :visibility => "public", :fixture => "a")
424
425     # First with no auth, which should work since the trace is public
426     get :picture, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }
427     check_trace_picture public_trace_file
428
429     # Now with some other user, which should work since the trace is public
430     get :picture, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => create(:user) }
431     check_trace_picture public_trace_file
432
433     # And finally we should be able to do it with the owner of the trace
434     get :picture, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => public_trace_file.user }
435     check_trace_picture public_trace_file
436   end
437
438   # Check the picture for an anonymous trace can't be downloaded by another user
439   def test_picture_anon
440     anon_trace_file = create(:trace, :visibility => "private", :fixture => "b")
441
442     # First with no auth
443     get :picture, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }
444     assert_response :forbidden
445
446     # Now with some other user, which shouldn't work since the trace is anon
447     get :picture, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => create(:user) }
448     assert_response :forbidden
449
450     # And finally we should be able to do it with the owner of the trace
451     get :picture, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => anon_trace_file.user }
452     check_trace_picture anon_trace_file
453   end
454
455   # Test downloading the picture for a trace that doesn't exist
456   def test_picture_not_found
457     deleted_trace_file = create(:trace, :deleted)
458
459     # First with a trace that has never existed
460     get :picture, :params => { :display_name => create(:user).display_name, :id => 0 }
461     assert_response :not_found
462
463     # Now with a trace that has been deleted
464     get :picture, :params => { :display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file.id }, :session => { :user => deleted_trace_file.user }
465     assert_response :not_found
466   end
467
468   # Test downloading the icon for a trace
469   def test_icon
470     public_trace_file = create(:trace, :visibility => "public", :fixture => "a")
471
472     # First with no auth, which should work since the trace is public
473     get :icon, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }
474     check_trace_icon public_trace_file
475
476     # Now with some other user, which should work since the trace is public
477     get :icon, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => create(:user) }
478     check_trace_icon public_trace_file
479
480     # And finally we should be able to do it with the owner of the trace
481     get :icon, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => public_trace_file.user }
482     check_trace_icon public_trace_file
483   end
484
485   # Check the icon for an anonymous trace can't be downloaded by another user
486   def test_icon_anon
487     anon_trace_file = create(:trace, :visibility => "private", :fixture => "b")
488
489     # First with no auth
490     get :icon, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }
491     assert_response :forbidden
492
493     # Now with some other user, which shouldn't work since the trace is anon
494     get :icon, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => create(:user) }
495     assert_response :forbidden
496
497     # And finally we should be able to do it with the owner of the trace
498     get :icon, :params => { :display_name => anon_trace_file.user.display_name, :id => anon_trace_file.id }, :session => { :user => anon_trace_file.user }
499     check_trace_icon anon_trace_file
500   end
501
502   # Test downloading the icon for a trace that doesn't exist
503   def test_icon_not_found
504     deleted_trace_file = create(:trace, :deleted)
505
506     # First with a trace that has never existed
507     get :icon, :params => { :display_name => create(:user).display_name, :id => 0 }
508     assert_response :not_found
509
510     # Now with a trace that has been deleted
511     get :icon, :params => { :display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file.id }, :session => { :user => deleted_trace_file.user }
512     assert_response :not_found
513   end
514
515   # Test fetching the new trace page
516   def test_new_get
517     # First with no auth
518     get :new
519     assert_response :redirect
520     assert_redirected_to :controller => :users, :action => :login, :referer => new_trace_path
521
522     # Now authenticated as a user with gps.trace.visibility set
523     user = create(:user)
524     create(:user_preference, :user => user, :k => "gps.trace.visibility", :v => "identifiable")
525     get :new, :session => { :user => user }
526     assert_response :success
527     assert_template :new
528     assert_select "select#trace_visibility option[value=identifiable][selected]", 1
529
530     # Now authenticated as a user with gps.trace.public set
531     second_user = create(:user)
532     create(:user_preference, :user => second_user, :k => "gps.trace.public", :v => "default")
533     get :new, :session => { :user => second_user }
534     assert_response :success
535     assert_template :new
536     assert_select "select#trace_visibility option[value=public][selected]", 1
537
538     # Now authenticated as a user with no preferences
539     third_user = create(:user)
540     get :new, :session => { :user => third_user }
541     assert_response :success
542     assert_template :new
543     assert_select "select#trace_visibility option[value=private][selected]", 1
544   end
545
546   # Test creating a trace
547   def test_create_post
548     # Get file to use
549     fixture = Rails.root.join("test", "gpx", "fixtures", "a.gpx")
550     file = Rack::Test::UploadedFile.new(fixture, "application/gpx+xml")
551     user = create(:user)
552
553     # First with no auth
554     post :create, :params => { :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" } }
555     assert_response :forbidden
556
557     # Rewind the file
558     file.rewind
559
560     # Now authenticated
561     create(:user_preference, :user => user, :k => "gps.trace.visibility", :v => "identifiable")
562     assert_not_equal "trackable", user.preferences.where(:k => "gps.trace.visibility").first.v
563     post :create, :params => { :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" } }, :session => { :user => user }
564     assert_response :redirect
565     assert_redirected_to :action => :index, :display_name => user.display_name
566     assert_match(/file has been uploaded/, flash[:notice])
567     trace = Trace.order(:id => :desc).first
568     assert_equal "a.gpx", trace.name
569     assert_equal "New Trace", trace.description
570     assert_equal %w[new trace], trace.tags.order(:tag).collect(&:tag)
571     assert_equal "trackable", trace.visibility
572     assert_equal false, trace.inserted
573     assert_equal File.new(fixture).read, File.new(trace.trace_name).read
574     trace.destroy
575     assert_equal "trackable", user.preferences.where(:k => "gps.trace.visibility").first.v
576   end
577
578   # Test creating a trace with validation errors
579   def test_create_post_with_validation_errors
580     # Get file to use
581     fixture = Rails.root.join("test", "gpx", "fixtures", "a.gpx")
582     file = Rack::Test::UploadedFile.new(fixture, "application/gpx+xml")
583     user = create(:user)
584
585     # Now authenticated
586     create(:user_preference, :user => user, :k => "gps.trace.visibility", :v => "identifiable")
587     assert_not_equal "trackable", user.preferences.where(:k => "gps.trace.visibility").first.v
588     post :create, :params => { :trace => { :gpx_file => file, :description => "", :tagstring => "new,trace", :visibility => "trackable" } }, :session => { :user => user }
589     assert_template :new
590     assert_match "Description is too short (minimum is 1 character)", response.body
591   end
592
593   # Test fetching the edit page for a trace using GET
594   def test_edit_get
595     public_trace_file = create(:trace, :visibility => "public")
596     deleted_trace_file = create(:trace, :deleted)
597
598     # First with no auth
599     get :edit, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }
600     assert_response :redirect
601     assert_redirected_to :controller => :users, :action => :login, :referer => edit_trace_path(:display_name => public_trace_file.user.display_name, :id => public_trace_file.id)
602
603     # Now with some other user, which should fail
604     get :edit, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => create(:user) }
605     assert_response :forbidden
606
607     # Now with a trace which doesn't exist
608     get :edit, :params => { :display_name => create(:user).display_name, :id => 0 }, :session => { :user => create(:user) }
609     assert_response :not_found
610
611     # Now with a trace which has been deleted
612     get :edit, :params => { :display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file.id }, :session => { :user => deleted_trace_file.user }
613     assert_response :not_found
614
615     # Finally with a trace that we are allowed to edit
616     get :edit, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => public_trace_file.user }
617     assert_response :success
618   end
619
620   # Test saving edits to a trace
621   def test_update
622     public_trace_file = create(:trace, :visibility => "public")
623     deleted_trace_file = create(:trace, :deleted)
624
625     # New details
626     new_details = { :description => "Changed description", :tagstring => "new_tag", :visibility => "private" }
627
628     # First with no auth
629     put :update, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id, :trace => new_details }
630     assert_response :forbidden
631
632     # Now with some other user, which should fail
633     put :update, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id, :trace => new_details }, :session => { :user => create(:user) }
634     assert_response :forbidden
635
636     # Now with a trace which doesn't exist
637     put :update, :params => { :display_name => create(:user).display_name, :id => 0 }, :session => { :user => create(:user), :trace => new_details }
638     assert_response :not_found
639
640     # Now with a trace which has been deleted
641     put :update, :params => { :display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file.id, :trace => new_details }, :session => { :user => deleted_trace_file.user }
642     assert_response :not_found
643
644     # Finally with a trace that we are allowed to edit
645     put :update, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id, :trace => new_details }, :session => { :user => public_trace_file.user }
646     assert_response :redirect
647     assert_redirected_to :action => :show, :display_name => public_trace_file.user.display_name
648     trace = Trace.find(public_trace_file.id)
649     assert_equal new_details[:description], trace.description
650     assert_equal new_details[:tagstring], trace.tagstring
651     assert_equal new_details[:visibility], trace.visibility
652   end
653
654   # Test deleting a trace
655   def test_delete
656     public_trace_file = create(:trace, :visibility => "public")
657     deleted_trace_file = create(:trace, :deleted)
658
659     # First with no auth
660     post :delete, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }
661     assert_response :forbidden
662
663     # Now with some other user, which should fail
664     post :delete, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => create(:user) }
665     assert_response :forbidden
666
667     # Now with a trace which doesn't exist
668     post :delete, :params => { :display_name => create(:user).display_name, :id => 0 }, :session => { :user => create(:user) }
669     assert_response :not_found
670
671     # Now with a trace has already been deleted
672     post :delete, :params => { :display_name => deleted_trace_file.user.display_name, :id => deleted_trace_file.id }, :session => { :user => deleted_trace_file.user }
673     assert_response :not_found
674
675     # Now with a trace that we are allowed to delete
676     post :delete, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => public_trace_file.user }
677     assert_response :redirect
678     assert_redirected_to :action => :index, :display_name => public_trace_file.user.display_name
679     trace = Trace.find(public_trace_file.id)
680     assert_equal false, trace.visible
681
682     # Finally with a trace that is deleted by an admin
683     public_trace_file = create(:trace, :visibility => "public")
684     admin = create(:administrator_user)
685
686     post :delete, :params => { :display_name => public_trace_file.user.display_name, :id => public_trace_file.id }, :session => { :user => admin }
687     assert_response :redirect
688     assert_redirected_to :action => :index, :display_name => public_trace_file.user.display_name
689     trace = Trace.find(public_trace_file.id)
690     assert_equal false, trace.visible
691   end
692
693   private
694
695   def check_trace_feed(traces)
696     assert_response :success
697     assert_template "georss"
698     assert_equal "application/rss+xml", @response.content_type
699     assert_select "rss", :count => 1 do
700       assert_select "channel", :count => 1 do
701         assert_select "title"
702         assert_select "description"
703         assert_select "link"
704         assert_select "image"
705         assert_select "item", :count => traces.length do |items|
706           traces.zip(items).each do |trace, item|
707             assert_select item, "title", trace.name
708             assert_select item, "link", "http://test.host/user/#{ERB::Util.u(trace.user.display_name)}/traces/#{trace.id}"
709             assert_select item, "guid", "http://test.host/user/#{ERB::Util.u(trace.user.display_name)}/traces/#{trace.id}"
710             assert_select item, "description"
711             # assert_select item, "dc:creator", trace.user.display_name
712             assert_select item, "pubDate", trace.timestamp.rfc822
713           end
714         end
715       end
716     end
717   end
718
719   def check_trace_index(traces)
720     assert_response :success
721     assert_template "index"
722
723     if !traces.empty?
724       assert_select "table#trace_list tbody", :count => 1 do
725         assert_select "tr", :count => traces.length do |rows|
726           traces.zip(rows).each do |trace, row|
727             assert_select row, "a", Regexp.new(Regexp.escape(trace.name))
728             assert_select row, "span.trace_summary", Regexp.new(Regexp.escape("(#{trace.size} points)")) if trace.inserted?
729             assert_select row, "td", Regexp.new(Regexp.escape(trace.description))
730             assert_select row, "td", Regexp.new(Regexp.escape("by #{trace.user.display_name}"))
731           end
732         end
733       end
734     else
735       assert_select "h4", /Nothing here yet/
736     end
737   end
738
739   def check_trace_show(trace)
740     assert_response :success
741     assert_template "show"
742
743     assert_select "table", :count => 1 do
744       assert_select "td", /^#{Regexp.quote(trace.name)} /
745       assert_select "td", trace.user.display_name
746       assert_select "td", trace.description
747     end
748   end
749
750   def check_trace_data(trace, digest, content_type = "application/gpx+xml", extension = "gpx")
751     assert_response :success
752     assert_equal digest, Digest::MD5.hexdigest(response.body)
753     assert_equal content_type, response.content_type
754     assert_equal "attachment; filename=\"#{trace.id}.#{extension}\"", @response.header["Content-Disposition"]
755   end
756
757   def check_trace_picture(trace)
758     assert_response :success
759     assert_equal "image/gif", response.content_type
760     assert_equal trace.large_picture, response.body
761   end
762
763   def check_trace_icon(trace)
764     assert_response :success
765     assert_equal "image/gif", response.content_type
766     assert_equal trace.icon_picture, response.body
767   end
768 end