]> git.openstreetmap.org Git - rails.git/blob - test/controllers/api/notes_controller_test.rb
Merge remote-tracking branch 'upstream/pull/1926'
[rails.git] / test / controllers / api / notes_controller_test.rb
1 require "test_helper"
2
3 module Api
4   class NotesControllerTest < ActionController::TestCase
5     def setup
6       # Stub nominatim response for note locations
7       stub_request(:get, %r{^https://nominatim\.openstreetmap\.org/reverse\?})
8         .to_return(:status => 404)
9     end
10
11     ##
12     # test all routes which lead to this controller
13     def test_routes
14       assert_routing(
15         { :path => "/api/0.6/notes", :method => :post },
16         { :controller => "api/notes", :action => "create", :format => "xml" }
17       )
18       assert_routing(
19         { :path => "/api/0.6/notes/1", :method => :get },
20         { :controller => "api/notes", :action => "show", :id => "1", :format => "xml" }
21       )
22       assert_recognizes(
23         { :controller => "api/notes", :action => "show", :id => "1", :format => "xml" },
24         { :path => "/api/0.6/notes/1.xml", :method => :get }
25       )
26       assert_routing(
27         { :path => "/api/0.6/notes/1.rss", :method => :get },
28         { :controller => "api/notes", :action => "show", :id => "1", :format => "rss" }
29       )
30       assert_routing(
31         { :path => "/api/0.6/notes/1.json", :method => :get },
32         { :controller => "api/notes", :action => "show", :id => "1", :format => "json" }
33       )
34       assert_routing(
35         { :path => "/api/0.6/notes/1.gpx", :method => :get },
36         { :controller => "api/notes", :action => "show", :id => "1", :format => "gpx" }
37       )
38       assert_routing(
39         { :path => "/api/0.6/notes/1/comment", :method => :post },
40         { :controller => "api/notes", :action => "comment", :id => "1", :format => "xml" }
41       )
42       assert_routing(
43         { :path => "/api/0.6/notes/1/close", :method => :post },
44         { :controller => "api/notes", :action => "close", :id => "1", :format => "xml" }
45       )
46       assert_routing(
47         { :path => "/api/0.6/notes/1/reopen", :method => :post },
48         { :controller => "api/notes", :action => "reopen", :id => "1", :format => "xml" }
49       )
50       assert_routing(
51         { :path => "/api/0.6/notes/1", :method => :delete },
52         { :controller => "api/notes", :action => "destroy", :id => "1", :format => "xml" }
53       )
54
55       assert_routing(
56         { :path => "/api/0.6/notes", :method => :get },
57         { :controller => "api/notes", :action => "index", :format => "xml" }
58       )
59       assert_recognizes(
60         { :controller => "api/notes", :action => "index", :format => "xml" },
61         { :path => "/api/0.6/notes.xml", :method => :get }
62       )
63       assert_routing(
64         { :path => "/api/0.6/notes.rss", :method => :get },
65         { :controller => "api/notes", :action => "index", :format => "rss" }
66       )
67       assert_routing(
68         { :path => "/api/0.6/notes.json", :method => :get },
69         { :controller => "api/notes", :action => "index", :format => "json" }
70       )
71       assert_routing(
72         { :path => "/api/0.6/notes.gpx", :method => :get },
73         { :controller => "api/notes", :action => "index", :format => "gpx" }
74       )
75
76       assert_routing(
77         { :path => "/api/0.6/notes/search", :method => :get },
78         { :controller => "api/notes", :action => "search", :format => "xml" }
79       )
80       assert_recognizes(
81         { :controller => "api/notes", :action => "search", :format => "xml" },
82         { :path => "/api/0.6/notes/search.xml", :method => :get }
83       )
84       assert_routing(
85         { :path => "/api/0.6/notes/search.rss", :method => :get },
86         { :controller => "api/notes", :action => "search", :format => "rss" }
87       )
88       assert_routing(
89         { :path => "/api/0.6/notes/search.json", :method => :get },
90         { :controller => "api/notes", :action => "search", :format => "json" }
91       )
92       assert_routing(
93         { :path => "/api/0.6/notes/search.gpx", :method => :get },
94         { :controller => "api/notes", :action => "search", :format => "gpx" }
95       )
96
97       assert_routing(
98         { :path => "/api/0.6/notes/feed", :method => :get },
99         { :controller => "api/notes", :action => "feed", :format => "rss" }
100       )
101
102       assert_recognizes(
103         { :controller => "api/notes", :action => "create" },
104         { :path => "/api/0.6/notes/addPOIexec", :method => :post }
105       )
106       assert_recognizes(
107         { :controller => "api/notes", :action => "close" },
108         { :path => "/api/0.6/notes/closePOIexec", :method => :post }
109       )
110       assert_recognizes(
111         { :controller => "api/notes", :action => "comment" },
112         { :path => "/api/0.6/notes/editPOIexec", :method => :post }
113       )
114       assert_recognizes(
115         { :controller => "api/notes", :action => "index", :format => "gpx" },
116         { :path => "/api/0.6/notes/getGPX", :method => :get }
117       )
118       assert_recognizes(
119         { :controller => "api/notes", :action => "feed", :format => "rss" },
120         { :path => "/api/0.6/notes/getRSSfeed", :method => :get }
121       )
122     end
123
124     def test_create_success
125       assert_difference "Note.count", 1 do
126         assert_difference "NoteComment.count", 1 do
127           post :create, :params => { :lat => -1.0, :lon => -1.0, :text => "This is a comment", :format => "json" }
128         end
129       end
130       assert_response :success
131       js = ActiveSupport::JSON.decode(@response.body)
132       assert_not_nil js
133       assert_equal "Feature", js["type"]
134       assert_equal "Point", js["geometry"]["type"]
135       assert_equal [-1.0, -1.0], js["geometry"]["coordinates"]
136       assert_equal "open", js["properties"]["status"]
137       assert_equal 1, js["properties"]["comments"].count
138       assert_equal "opened", js["properties"]["comments"].last["action"]
139       assert_equal "This is a comment", js["properties"]["comments"].last["text"]
140       assert_nil js["properties"]["comments"].last["user"]
141       id = js["properties"]["id"]
142
143       get :show, :params => { :id => id, :format => "json" }
144       assert_response :success
145       js = ActiveSupport::JSON.decode(@response.body)
146       assert_not_nil js
147       assert_equal "Feature", js["type"]
148       assert_equal "Point", js["geometry"]["type"]
149       assert_equal [-1.0, -1.0], js["geometry"]["coordinates"]
150       assert_equal id, js["properties"]["id"]
151       assert_equal "open", js["properties"]["status"]
152       assert_equal 1, js["properties"]["comments"].count
153       assert_equal "opened", js["properties"]["comments"].last["action"]
154       assert_equal "This is a comment", js["properties"]["comments"].last["text"]
155       assert_nil js["properties"]["comments"].last["user"]
156     end
157
158     def test_create_fail
159       assert_no_difference "Note.count" do
160         assert_no_difference "NoteComment.count" do
161           post :create, :params => { :lon => -1.0, :text => "This is a comment" }
162         end
163       end
164       assert_response :bad_request
165
166       assert_no_difference "Note.count" do
167         assert_no_difference "NoteComment.count" do
168           post :create, :params => { :lat => -1.0, :text => "This is a comment" }
169         end
170       end
171       assert_response :bad_request
172
173       assert_no_difference "Note.count" do
174         assert_no_difference "NoteComment.count" do
175           post :create, :params => { :lat => -1.0, :lon => -1.0 }
176         end
177       end
178       assert_response :bad_request
179
180       assert_no_difference "Note.count" do
181         assert_no_difference "NoteComment.count" do
182           post :create, :params => { :lat => -1.0, :lon => -1.0, :text => "" }
183         end
184       end
185       assert_response :bad_request
186
187       assert_no_difference "Note.count" do
188         assert_no_difference "NoteComment.count" do
189           post :create, :params => { :lat => -100.0, :lon => -1.0, :text => "This is a comment" }
190         end
191       end
192       assert_response :bad_request
193
194       assert_no_difference "Note.count" do
195         assert_no_difference "NoteComment.count" do
196           post :create, :params => { :lat => -1.0, :lon => -200.0, :text => "This is a comment" }
197         end
198       end
199       assert_response :bad_request
200
201       assert_no_difference "Note.count" do
202         assert_no_difference "NoteComment.count" do
203           post :create, :params => { :lat => "abc", :lon => -1.0, :text => "This is a comment" }
204         end
205       end
206       assert_response :bad_request
207
208       assert_no_difference "Note.count" do
209         assert_no_difference "NoteComment.count" do
210           post :create, :params => { :lat => -1.0, :lon => "abc", :text => "This is a comment" }
211         end
212       end
213       assert_response :bad_request
214
215       assert_no_difference "Note.count" do
216         assert_no_difference "NoteComment.count" do
217           post :create, :params => { :lat => -1.0, :lon => -1.0, :text => "x\u0000y" }
218         end
219       end
220       assert_response :bad_request
221     end
222
223     def test_comment_success
224       open_note_with_comment = create(:note_with_comments)
225       user = create(:user)
226       basic_authorization user.email, "test"
227       assert_difference "NoteComment.count", 1 do
228         assert_no_difference "ActionMailer::Base.deliveries.size" do
229           perform_enqueued_jobs do
230             post :comment, :params => { :id => open_note_with_comment.id, :text => "This is an additional comment", :format => "json" }
231           end
232         end
233       end
234       assert_response :success
235       js = ActiveSupport::JSON.decode(@response.body)
236       assert_not_nil js
237       assert_equal "Feature", js["type"]
238       assert_equal open_note_with_comment.id, js["properties"]["id"]
239       assert_equal "open", js["properties"]["status"]
240       assert_equal 2, js["properties"]["comments"].count
241       assert_equal "commented", js["properties"]["comments"].last["action"]
242       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
243       assert_equal user.display_name, js["properties"]["comments"].last["user"]
244
245       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
246       assert_response :success
247       js = ActiveSupport::JSON.decode(@response.body)
248       assert_not_nil js
249       assert_equal "Feature", js["type"]
250       assert_equal open_note_with_comment.id, js["properties"]["id"]
251       assert_equal "open", js["properties"]["status"]
252       assert_equal 2, js["properties"]["comments"].count
253       assert_equal "commented", js["properties"]["comments"].last["action"]
254       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
255       assert_equal user.display_name, js["properties"]["comments"].last["user"]
256
257       # Ensure that emails are sent to users
258       first_user = create(:user)
259       second_user = create(:user)
260       third_user = create(:user)
261
262       note_with_comments_by_users = create(:note) do |note|
263         create(:note_comment, :note => note, :author => first_user)
264         create(:note_comment, :note => note, :author => second_user)
265       end
266
267       basic_authorization third_user.email, "test"
268
269       assert_difference "NoteComment.count", 1 do
270         assert_difference "ActionMailer::Base.deliveries.size", 2 do
271           perform_enqueued_jobs do
272             post :comment, :params => { :id => note_with_comments_by_users.id, :text => "This is an additional comment", :format => "json" }
273           end
274         end
275       end
276       assert_response :success
277       js = ActiveSupport::JSON.decode(@response.body)
278       assert_not_nil js
279       assert_equal "Feature", js["type"]
280       assert_equal note_with_comments_by_users.id, js["properties"]["id"]
281       assert_equal "open", js["properties"]["status"]
282       assert_equal 3, js["properties"]["comments"].count
283       assert_equal "commented", js["properties"]["comments"].last["action"]
284       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
285       assert_equal third_user.display_name, js["properties"]["comments"].last["user"]
286
287       email = ActionMailer::Base.deliveries.find { |e| e.to.first == first_user.email }
288       assert_not_nil email
289       assert_equal 1, email.to.length
290       assert_equal "[OpenStreetMap] #{third_user.display_name} has commented on one of your notes", email.subject
291       assert_equal first_user.email, email.to.first
292
293       email = ActionMailer::Base.deliveries.find { |e| e.to.first == second_user.email }
294       assert_not_nil email
295       assert_equal 1, email.to.length
296       assert_equal "[OpenStreetMap] #{third_user.display_name} has commented on a note you are interested in", email.subject
297
298       get :show, :params => { :id => note_with_comments_by_users.id, :format => "json" }
299       assert_response :success
300       js = ActiveSupport::JSON.decode(@response.body)
301       assert_not_nil js
302       assert_equal "Feature", js["type"]
303       assert_equal note_with_comments_by_users.id, js["properties"]["id"]
304       assert_equal "open", js["properties"]["status"]
305       assert_equal 3, js["properties"]["comments"].count
306       assert_equal "commented", js["properties"]["comments"].last["action"]
307       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
308       assert_equal third_user.display_name, js["properties"]["comments"].last["user"]
309
310       ActionMailer::Base.deliveries.clear
311     end
312
313     def test_comment_fail
314       open_note_with_comment = create(:note_with_comments)
315
316       user = create(:user)
317
318       assert_no_difference "NoteComment.count" do
319         post :comment, :params => { :text => "This is an additional comment" }
320         assert_response :unauthorized
321       end
322
323       basic_authorization user.email, "test"
324
325       assert_no_difference "NoteComment.count" do
326         post :comment, :params => { :text => "This is an additional comment" }
327       end
328       assert_response :bad_request
329
330       assert_no_difference "NoteComment.count" do
331         post :comment, :params => { :id => open_note_with_comment.id }
332       end
333       assert_response :bad_request
334
335       assert_no_difference "NoteComment.count" do
336         post :comment, :params => { :id => open_note_with_comment.id, :text => "" }
337       end
338       assert_response :bad_request
339
340       assert_no_difference "NoteComment.count" do
341         post :comment, :params => { :id => 12345, :text => "This is an additional comment" }
342       end
343       assert_response :not_found
344
345       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
346
347       assert_no_difference "NoteComment.count" do
348         post :comment, :params => { :id => hidden_note_with_comment.id, :text => "This is an additional comment" }
349       end
350       assert_response :gone
351
352       closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
353
354       assert_no_difference "NoteComment.count" do
355         post :comment, :params => { :id => closed_note_with_comment.id, :text => "This is an additional comment" }
356       end
357       assert_response :conflict
358
359       assert_no_difference "NoteComment.count" do
360         post :comment, :params => { :id => open_note_with_comment.id, :text => "x\u0000y" }
361       end
362       assert_response :bad_request
363     end
364
365     def test_close_success
366       open_note_with_comment = create(:note_with_comments)
367       user = create(:user)
368
369       post :close, :params => { :id => open_note_with_comment.id, :text => "This is a close comment", :format => "json" }
370       assert_response :unauthorized
371
372       basic_authorization user.email, "test"
373
374       post :close, :params => { :id => open_note_with_comment.id, :text => "This is a close comment", :format => "json" }
375       assert_response :success
376       js = ActiveSupport::JSON.decode(@response.body)
377       assert_not_nil js
378       assert_equal "Feature", js["type"]
379       assert_equal open_note_with_comment.id, js["properties"]["id"]
380       assert_equal "closed", js["properties"]["status"]
381       assert_equal 2, js["properties"]["comments"].count
382       assert_equal "closed", js["properties"]["comments"].last["action"]
383       assert_equal "This is a close comment", js["properties"]["comments"].last["text"]
384       assert_equal user.display_name, js["properties"]["comments"].last["user"]
385
386       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
387       assert_response :success
388       js = ActiveSupport::JSON.decode(@response.body)
389       assert_not_nil js
390       assert_equal "Feature", js["type"]
391       assert_equal open_note_with_comment.id, js["properties"]["id"]
392       assert_equal "closed", js["properties"]["status"]
393       assert_equal 2, js["properties"]["comments"].count
394       assert_equal "closed", js["properties"]["comments"].last["action"]
395       assert_equal "This is a close comment", js["properties"]["comments"].last["text"]
396       assert_equal user.display_name, js["properties"]["comments"].last["user"]
397     end
398
399     def test_close_fail
400       post :close
401       assert_response :unauthorized
402
403       basic_authorization create(:user).email, "test"
404
405       post :close
406       assert_response :bad_request
407
408       post :close, :params => { :id => 12345 }
409       assert_response :not_found
410
411       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
412
413       post :close, :params => { :id => hidden_note_with_comment.id }
414       assert_response :gone
415
416       closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
417
418       post :close, :params => { :id => closed_note_with_comment.id }
419       assert_response :conflict
420     end
421
422     def test_reopen_success
423       closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
424       user = create(:user)
425
426       post :reopen, :params => { :id => closed_note_with_comment.id, :text => "This is a reopen comment", :format => "json" }
427       assert_response :unauthorized
428
429       basic_authorization user.email, "test"
430
431       post :reopen, :params => { :id => closed_note_with_comment.id, :text => "This is a reopen comment", :format => "json" }
432       assert_response :success
433       js = ActiveSupport::JSON.decode(@response.body)
434       assert_not_nil js
435       assert_equal "Feature", js["type"]
436       assert_equal closed_note_with_comment.id, js["properties"]["id"]
437       assert_equal "open", js["properties"]["status"]
438       assert_equal 2, js["properties"]["comments"].count
439       assert_equal "reopened", js["properties"]["comments"].last["action"]
440       assert_equal "This is a reopen comment", js["properties"]["comments"].last["text"]
441       assert_equal user.display_name, js["properties"]["comments"].last["user"]
442
443       get :show, :params => { :id => closed_note_with_comment.id, :format => "json" }
444       assert_response :success
445       js = ActiveSupport::JSON.decode(@response.body)
446       assert_not_nil js
447       assert_equal "Feature", js["type"]
448       assert_equal closed_note_with_comment.id, js["properties"]["id"]
449       assert_equal "open", js["properties"]["status"]
450       assert_equal 2, js["properties"]["comments"].count
451       assert_equal "reopened", js["properties"]["comments"].last["action"]
452       assert_equal "This is a reopen comment", js["properties"]["comments"].last["text"]
453       assert_equal user.display_name, js["properties"]["comments"].last["user"]
454     end
455
456     def test_reopen_fail
457       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
458
459       post :reopen, :params => { :id => hidden_note_with_comment.id }
460       assert_response :unauthorized
461
462       basic_authorization create(:user).email, "test"
463
464       post :reopen, :params => { :id => 12345 }
465       assert_response :not_found
466
467       post :reopen, :params => { :id => hidden_note_with_comment.id }
468       assert_response :gone
469
470       open_note_with_comment = create(:note_with_comments)
471
472       post :reopen, :params => { :id => open_note_with_comment.id }
473       assert_response :conflict
474     end
475
476     def test_show_success
477       open_note = create(:note_with_comments)
478
479       get :show, :params => { :id => open_note.id, :format => "xml" }
480       assert_response :success
481       assert_equal "application/xml", @response.content_type
482       assert_select "osm", :count => 1 do
483         assert_select "note[lat='#{open_note.lat}'][lon='#{open_note.lon}']", :count => 1 do
484           assert_select "id", open_note.id.to_s
485           assert_select "url", note_url(open_note, :format => "xml")
486           assert_select "comment_url", comment_note_url(open_note, :format => "xml")
487           assert_select "close_url", close_note_url(open_note, :format => "xml")
488           assert_select "date_created", open_note.created_at.to_s
489           assert_select "status", open_note.status
490           assert_select "comments", :count => 1 do
491             assert_select "comment", :count => 1
492           end
493         end
494       end
495
496       get :show, :params => { :id => open_note.id, :format => "rss" }
497       assert_response :success
498       assert_equal "application/rss+xml", @response.content_type
499       assert_select "rss", :count => 1 do
500         assert_select "channel", :count => 1 do
501           assert_select "item", :count => 1 do
502             assert_select "link", browse_note_url(open_note)
503             assert_select "guid", note_url(open_note)
504             assert_select "pubDate", open_note.created_at.to_s(:rfc822)
505             #          assert_select "geo:lat", open_note.lat.to_s
506             #          assert_select "geo:long", open_note.lon
507             #          assert_select "georss:point", "#{open_note.lon} #{open_note.lon}"
508           end
509         end
510       end
511
512       get :show, :params => { :id => open_note.id, :format => "json" }
513       assert_response :success
514       assert_equal "application/json", @response.content_type
515       js = ActiveSupport::JSON.decode(@response.body)
516       assert_not_nil js
517       assert_equal "Feature", js["type"]
518       assert_equal "Point", js["geometry"]["type"]
519       assert_equal open_note.lat, js["geometry"]["coordinates"][0]
520       assert_equal open_note.lon, js["geometry"]["coordinates"][1]
521       assert_equal open_note.id, js["properties"]["id"]
522       assert_equal note_url(open_note, :format => "json"), js["properties"]["url"]
523       assert_equal comment_note_url(open_note, :format => "json"), js["properties"]["comment_url"]
524       assert_equal close_note_url(open_note, :format => "json"), js["properties"]["close_url"]
525       assert_equal open_note.created_at.to_s, js["properties"]["date_created"]
526       assert_equal open_note.status, js["properties"]["status"]
527
528       get :show, :params => { :id => open_note.id, :format => "gpx" }
529       assert_response :success
530       assert_equal "application/gpx+xml", @response.content_type
531       assert_select "gpx", :count => 1 do
532         assert_select "wpt[lat='#{open_note.lat}'][lon='#{open_note.lon}']", :count => 1 do
533           assert_select "time", :count => 1
534           assert_select "name", "Note: #{open_note.id}"
535           assert_select "desc", :count => 1
536           assert_select "link[href='http://test.host/note/#{open_note.id}']", :count => 1
537           assert_select "extensions", :count => 1 do
538             assert_select "id", open_note.id.to_s
539             assert_select "url", note_url(open_note, :format => "gpx")
540             assert_select "comment_url", comment_note_url(open_note, :format => "gpx")
541             assert_select "close_url", close_note_url(open_note, :format => "gpx")
542           end
543         end
544       end
545     end
546
547     def test_show_hidden_comment
548       note_with_hidden_comment = create(:note) do |note|
549         create(:note_comment, :note => note, :body => "Valid comment for hidden note")
550         create(:note_comment, :note => note, :visible => false)
551         create(:note_comment, :note => note, :body => "Another valid comment for hidden note")
552       end
553
554       get :show, :params => { :id => note_with_hidden_comment.id, :format => "json" }
555       assert_response :success
556       js = ActiveSupport::JSON.decode(@response.body)
557       assert_not_nil js
558       assert_equal "Feature", js["type"]
559       assert_equal note_with_hidden_comment.id, js["properties"]["id"]
560       assert_equal 2, js["properties"]["comments"].count
561       assert_equal "Valid comment for hidden note", js["properties"]["comments"][0]["text"]
562       assert_equal "Another valid comment for hidden note", js["properties"]["comments"][1]["text"]
563     end
564
565     def test_show_fail
566       get :show, :params => { :id => 12345 }
567       assert_response :not_found
568
569       get :show, :params => { :id => create(:note, :status => "hidden").id }
570       assert_response :gone
571     end
572
573     def test_destroy_success
574       open_note_with_comment = create(:note_with_comments)
575       user = create(:user)
576       moderator_user = create(:moderator_user)
577
578       delete :destroy, :params => { :id => open_note_with_comment.id, :text => "This is a hide comment", :format => "json" }
579       assert_response :unauthorized
580
581       basic_authorization user.email, "test"
582
583       delete :destroy, :params => { :id => open_note_with_comment.id, :text => "This is a hide comment", :format => "json" }
584       assert_response :forbidden
585
586       basic_authorization moderator_user.email, "test"
587
588       delete :destroy, :params => { :id => open_note_with_comment.id, :text => "This is a hide comment", :format => "json" }
589       assert_response :success
590       js = ActiveSupport::JSON.decode(@response.body)
591       assert_not_nil js
592       assert_equal "Feature", js["type"]
593       assert_equal open_note_with_comment.id, js["properties"]["id"]
594       assert_equal "hidden", js["properties"]["status"]
595       assert_equal 2, js["properties"]["comments"].count
596       assert_equal "hidden", js["properties"]["comments"].last["action"]
597       assert_equal "This is a hide comment", js["properties"]["comments"].last["text"]
598       assert_equal moderator_user.display_name, js["properties"]["comments"].last["user"]
599
600       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
601       assert_response :success
602
603       basic_authorization user.email, "test"
604       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
605       assert_response :gone
606     end
607
608     def test_destroy_fail
609       user = create(:user)
610       moderator_user = create(:moderator_user)
611
612       delete :destroy, :params => { :id => 12345, :format => "json" }
613       assert_response :unauthorized
614
615       basic_authorization user.email, "test"
616
617       delete :destroy, :params => { :id => 12345, :format => "json" }
618       assert_response :forbidden
619
620       basic_authorization moderator_user.email, "test"
621
622       delete :destroy, :params => { :id => 12345, :format => "json" }
623       assert_response :not_found
624
625       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
626
627       delete :destroy, :params => { :id => hidden_note_with_comment.id, :format => "json" }
628       assert_response :gone
629     end
630
631     def test_index_success
632       position = (1.1 * GeoRecord::SCALE).to_i
633       create(:note_with_comments, :latitude => position, :longitude => position)
634       create(:note_with_comments, :latitude => position, :longitude => position)
635
636       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "rss" }
637       assert_response :success
638       assert_equal "application/rss+xml", @response.content_type
639       assert_select "rss", :count => 1 do
640         assert_select "channel", :count => 1 do
641           assert_select "item", :count => 2
642         end
643       end
644
645       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "json" }
646       assert_response :success
647       assert_equal "application/json", @response.content_type
648       js = ActiveSupport::JSON.decode(@response.body)
649       assert_not_nil js
650       assert_equal "FeatureCollection", js["type"]
651       assert_equal 2, js["features"].count
652
653       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "xml" }
654       assert_response :success
655       assert_equal "application/xml", @response.content_type
656       assert_select "osm", :count => 1 do
657         assert_select "note", :count => 2
658       end
659
660       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "gpx" }
661       assert_response :success
662       assert_equal "application/gpx+xml", @response.content_type
663       assert_select "gpx", :count => 1 do
664         assert_select "wpt", :count => 2
665       end
666     end
667
668     def test_index_limit
669       position = (1.1 * GeoRecord::SCALE).to_i
670       create(:note_with_comments, :latitude => position, :longitude => position)
671       create(:note_with_comments, :latitude => position, :longitude => position)
672
673       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "rss" }
674       assert_response :success
675       assert_equal "application/rss+xml", @response.content_type
676       assert_select "rss", :count => 1 do
677         assert_select "channel", :count => 1 do
678           assert_select "item", :count => 1
679         end
680       end
681
682       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "json" }
683       assert_response :success
684       assert_equal "application/json", @response.content_type
685       js = ActiveSupport::JSON.decode(@response.body)
686       assert_not_nil js
687       assert_equal "FeatureCollection", js["type"]
688       assert_equal 1, js["features"].count
689
690       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "xml" }
691       assert_response :success
692       assert_equal "application/xml", @response.content_type
693       assert_select "osm", :count => 1 do
694         assert_select "note", :count => 1
695       end
696
697       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "gpx" }
698       assert_response :success
699       assert_equal "application/gpx+xml", @response.content_type
700       assert_select "gpx", :count => 1 do
701         assert_select "wpt", :count => 1
702       end
703     end
704
705     def test_index_empty_area
706       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "rss" }
707       assert_response :success
708       assert_equal "application/rss+xml", @response.content_type
709       assert_select "rss", :count => 1 do
710         assert_select "channel", :count => 1 do
711           assert_select "item", :count => 0
712         end
713       end
714
715       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "json" }
716       assert_response :success
717       assert_equal "application/json", @response.content_type
718       js = ActiveSupport::JSON.decode(@response.body)
719       assert_not_nil js
720       assert_equal "FeatureCollection", js["type"]
721       assert_equal 0, js["features"].count
722
723       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "xml" }
724       assert_response :success
725       assert_equal "application/xml", @response.content_type
726       assert_select "osm", :count => 1 do
727         assert_select "note", :count => 0
728       end
729
730       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "gpx" }
731       assert_response :success
732       assert_equal "application/gpx+xml", @response.content_type
733       assert_select "gpx", :count => 1 do
734         assert_select "wpt", :count => 0
735       end
736     end
737
738     def test_index_large_area
739       get :index, :params => { :bbox => "-2.5,-2.5,2.5,2.5", :format => :json }
740       assert_response :success
741       assert_equal "application/json", @response.content_type
742
743       get :index, :params => { :l => "-2.5", :b => "-2.5", :r => "2.5", :t => "2.5", :format => :json }
744       assert_response :success
745       assert_equal "application/json", @response.content_type
746
747       get :index, :params => { :bbox => "-10,-10,12,12", :format => :json }
748       assert_response :bad_request
749       assert_equal "application/json", @response.content_type
750
751       get :index, :params => { :l => "-10", :b => "-10", :r => "12", :t => "12", :format => :json }
752       assert_response :bad_request
753       assert_equal "application/json", @response.content_type
754     end
755
756     def test_index_closed
757       create(:note_with_comments, :status => "closed", :closed_at => Time.now - 5.days)
758       create(:note_with_comments, :status => "closed", :closed_at => Time.now - 100.days)
759       create(:note_with_comments, :status => "hidden")
760       create(:note_with_comments)
761
762       # Open notes + closed in last 7 days
763       get :index, :params => { :bbox => "1,1,1.7,1.7", :closed => "7", :format => "json" }
764       assert_response :success
765       assert_equal "application/json", @response.content_type
766       js = ActiveSupport::JSON.decode(@response.body)
767       assert_not_nil js
768       assert_equal "FeatureCollection", js["type"]
769       assert_equal 2, js["features"].count
770
771       # Only open notes
772       get :index, :params => { :bbox => "1,1,1.7,1.7", :closed => "0", :format => "json" }
773       assert_response :success
774       assert_equal "application/json", @response.content_type
775       js = ActiveSupport::JSON.decode(@response.body)
776       assert_not_nil js
777       assert_equal "FeatureCollection", js["type"]
778       assert_equal 1, js["features"].count
779
780       # Open notes + all closed notes
781       get :index, :params => { :bbox => "1,1,1.7,1.7", :closed => "-1", :format => "json" }
782       assert_response :success
783       assert_equal "application/json", @response.content_type
784       js = ActiveSupport::JSON.decode(@response.body)
785       assert_not_nil js
786       assert_equal "FeatureCollection", js["type"]
787       assert_equal 3, js["features"].count
788     end
789
790     def test_index_bad_params
791       get :index, :params => { :bbox => "-2.5,-2.5,2.5" }
792       assert_response :bad_request
793
794       get :index, :params => { :bbox => "-2.5,-2.5,2.5,2.5,2.5" }
795       assert_response :bad_request
796
797       get :index, :params => { :b => "-2.5", :r => "2.5", :t => "2.5" }
798       assert_response :bad_request
799
800       get :index, :params => { :l => "-2.5", :r => "2.5", :t => "2.5" }
801       assert_response :bad_request
802
803       get :index, :params => { :l => "-2.5", :b => "-2.5", :t => "2.5" }
804       assert_response :bad_request
805
806       get :index, :params => { :l => "-2.5", :b => "-2.5", :r => "2.5" }
807       assert_response :bad_request
808
809       get :index, :params => { :bbox => "1,1,1.7,1.7", :limit => "0", :format => "json" }
810       assert_response :bad_request
811
812       get :index, :params => { :bbox => "1,1,1.7,1.7", :limit => "10001", :format => "json" }
813       assert_response :bad_request
814     end
815
816     def test_search_success
817       create(:note_with_comments)
818
819       get :search, :params => { :q => "note comment", :format => "xml" }
820       assert_response :success
821       assert_equal "application/xml", @response.content_type
822       assert_select "osm", :count => 1 do
823         assert_select "note", :count => 1
824       end
825
826       get :search, :params => { :q => "note comment", :format => "json" }
827       assert_response :success
828       assert_equal "application/json", @response.content_type
829       js = ActiveSupport::JSON.decode(@response.body)
830       assert_not_nil js
831       assert_equal "FeatureCollection", js["type"]
832       assert_equal 1, js["features"].count
833
834       get :search, :params => { :q => "note comment", :format => "rss" }
835       assert_response :success
836       assert_equal "application/rss+xml", @response.content_type
837       assert_select "rss", :count => 1 do
838         assert_select "channel", :count => 1 do
839           assert_select "item", :count => 1
840         end
841       end
842
843       get :search, :params => { :q => "note comment", :format => "gpx" }
844       assert_response :success
845       assert_equal "application/gpx+xml", @response.content_type
846       assert_select "gpx", :count => 1 do
847         assert_select "wpt", :count => 1
848       end
849     end
850
851     def test_search_by_display_name_success
852       user = create(:user)
853
854       create(:note) do |note|
855         create(:note_comment, :note => note, :author => user)
856       end
857
858       get :search, :params => { :display_name => user.display_name, :format => "xml" }
859       assert_response :success
860       assert_equal "application/xml", @response.content_type
861       assert_select "osm", :count => 1 do
862         assert_select "note", :count => 1
863       end
864
865       get :search, :params => { :display_name => user.display_name, :format => "json" }
866       assert_response :success
867       assert_equal "application/json", @response.content_type
868       js = ActiveSupport::JSON.decode(@response.body)
869       assert_not_nil js
870       assert_equal "FeatureCollection", js["type"]
871       assert_equal 1, js["features"].count
872
873       get :search, :params => { :display_name => user.display_name, :format => "rss" }
874       assert_response :success
875       assert_equal "application/rss+xml", @response.content_type
876       assert_select "rss", :count => 1 do
877         assert_select "channel", :count => 1 do
878           assert_select "item", :count => 1
879         end
880       end
881
882       get :search, :params => { :display_name => user.display_name, :format => "gpx" }
883       assert_response :success
884       assert_equal "application/gpx+xml", @response.content_type
885       assert_select "gpx", :count => 1 do
886         assert_select "wpt", :count => 1
887       end
888     end
889
890     def test_search_by_user_success
891       user = create(:user)
892
893       create(:note) do |note|
894         create(:note_comment, :note => note, :author => user)
895       end
896
897       get :search, :params => { :user => user.id, :format => "xml" }
898       assert_response :success
899       assert_equal "application/xml", @response.content_type
900       assert_select "osm", :count => 1 do
901         assert_select "note", :count => 1
902       end
903
904       get :search, :params => { :user => user.id, :format => "json" }
905       assert_response :success
906       assert_equal "application/json", @response.content_type
907       js = ActiveSupport::JSON.decode(@response.body)
908       assert_not_nil js
909       assert_equal "FeatureCollection", js["type"]
910       assert_equal 1, js["features"].count
911
912       get :search, :params => { :user => user.id, :format => "rss" }
913       assert_response :success
914       assert_equal "application/rss+xml", @response.content_type
915       assert_select "rss", :count => 1 do
916         assert_select "channel", :count => 1 do
917           assert_select "item", :count => 1
918         end
919       end
920
921       get :search, :params => { :user => user.id, :format => "gpx" }
922       assert_response :success
923       assert_equal "application/gpx+xml", @response.content_type
924       assert_select "gpx", :count => 1 do
925         assert_select "wpt", :count => 1
926       end
927     end
928
929     def test_search_no_match
930       create(:note_with_comments)
931
932       get :search, :params => { :q => "no match", :format => "xml" }
933       assert_response :success
934       assert_equal "application/xml", @response.content_type
935       assert_select "osm", :count => 1 do
936         assert_select "note", :count => 0
937       end
938
939       get :search, :params => { :q => "no match", :format => "json" }
940       assert_response :success
941       assert_equal "application/json", @response.content_type
942       js = ActiveSupport::JSON.decode(@response.body)
943       assert_not_nil js
944       assert_equal "FeatureCollection", js["type"]
945       assert_equal 0, js["features"].count
946
947       get :search, :params => { :q => "no match", :format => "rss" }
948       assert_response :success
949       assert_equal "application/rss+xml", @response.content_type
950       assert_select "rss", :count => 1 do
951         assert_select "channel", :count => 1 do
952           assert_select "item", :count => 0
953         end
954       end
955
956       get :search, :params => { :q => "no match", :format => "gpx" }
957       assert_response :success
958       assert_equal "application/gpx+xml", @response.content_type
959       assert_select "gpx", :count => 1 do
960         assert_select "wpt", :count => 0
961       end
962     end
963
964     def test_search_by_time_no_match
965       create(:note_with_comments)
966
967       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "xml" }
968       assert_response :success
969       assert_equal "application/xml", @response.content_type
970       assert_select "osm", :count => 1 do
971         assert_select "note", :count => 0
972       end
973
974       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "json" }
975       assert_response :success
976       assert_equal "application/json", @response.content_type
977       js = ActiveSupport::JSON.decode(@response.body)
978       assert_not_nil js
979       assert_equal "FeatureCollection", js["type"]
980       assert_equal 0, js["features"].count
981
982       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "rss" }
983       assert_response :success
984       assert_equal "application/rss+xml", @response.content_type
985       assert_select "rss", :count => 1 do
986         assert_select "channel", :count => 1 do
987           assert_select "item", :count => 0
988         end
989       end
990
991       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "gpx" }
992       assert_response :success
993       assert_equal "application/gpx+xml", @response.content_type
994       assert_select "gpx", :count => 1 do
995         assert_select "wpt", :count => 0
996       end
997     end
998
999     def test_search_bad_params
1000       get :search, :params => { :q => "no match", :limit => "0", :format => "json" }
1001       assert_response :bad_request
1002
1003       get :search, :params => { :q => "no match", :limit => "10001", :format => "json" }
1004       assert_response :bad_request
1005
1006       get :search, :params => { :display_name => "non-existent" }
1007       assert_response :bad_request
1008
1009       get :search, :params => { :user => "-1" }
1010       assert_response :bad_request
1011
1012       get :search, :params => { :from => "wrong-date", :to => "wrong-date" }
1013       assert_response :bad_request
1014
1015       get :search, :params => { :from => "01.01.2010", :to => "2010.01.2010" }
1016       assert_response :bad_request
1017     end
1018
1019     def test_feed_success
1020       position = (1.1 * GeoRecord::SCALE).to_i
1021       create(:note_with_comments, :latitude => position, :longitude => position)
1022       create(:note_with_comments, :latitude => position, :longitude => position)
1023       position = (1.5 * GeoRecord::SCALE).to_i
1024       create(:note_with_comments, :latitude => position, :longitude => position)
1025       create(:note_with_comments, :latitude => position, :longitude => position)
1026
1027       get :feed, :params => { :format => "rss" }
1028       assert_response :success
1029       assert_equal "application/rss+xml", @response.content_type
1030       assert_select "rss", :count => 1 do
1031         assert_select "channel", :count => 1 do
1032           assert_select "item", :count => 4
1033         end
1034       end
1035
1036       get :feed, :params => { :bbox => "1,1,1.2,1.2", :format => "rss" }
1037       assert_response :success
1038       assert_equal "application/rss+xml", @response.content_type
1039       assert_select "rss", :count => 1 do
1040         assert_select "channel", :count => 1 do
1041           assert_select "item", :count => 2
1042         end
1043       end
1044     end
1045
1046     def test_feed_fail
1047       get :feed, :params => { :bbox => "1,1,1.2", :format => "rss" }
1048       assert_response :bad_request
1049
1050       get :feed, :params => { :bbox => "1,1,1.2,1.2,1.2", :format => "rss" }
1051       assert_response :bad_request
1052
1053       get :feed, :params => { :bbox => "1,1,1.2,1.2", :limit => "0", :format => "rss" }
1054       assert_response :bad_request
1055
1056       get :feed, :params => { :bbox => "1,1,1.2,1.2", :limit => "10001", :format => "rss" }
1057       assert_response :bad_request
1058     end
1059   end
1060 end