Use jquery
[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       assert_difference "NoteComment.count", 1 do
226         assert_no_difference "ActionMailer::Base.deliveries.size" do
227           perform_enqueued_jobs do
228             post :comment, :params => { :id => open_note_with_comment.id, :text => "This is an additional comment", :format => "json" }
229           end
230         end
231       end
232       assert_response :success
233       js = ActiveSupport::JSON.decode(@response.body)
234       assert_not_nil js
235       assert_equal "Feature", js["type"]
236       assert_equal open_note_with_comment.id, js["properties"]["id"]
237       assert_equal "open", js["properties"]["status"]
238       assert_equal 2, js["properties"]["comments"].count
239       assert_equal "commented", js["properties"]["comments"].last["action"]
240       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
241       assert_nil js["properties"]["comments"].last["user"]
242
243       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
244       assert_response :success
245       js = ActiveSupport::JSON.decode(@response.body)
246       assert_not_nil js
247       assert_equal "Feature", js["type"]
248       assert_equal open_note_with_comment.id, js["properties"]["id"]
249       assert_equal "open", js["properties"]["status"]
250       assert_equal 2, js["properties"]["comments"].count
251       assert_equal "commented", js["properties"]["comments"].last["action"]
252       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
253       assert_nil js["properties"]["comments"].last["user"]
254
255       # Ensure that emails are sent to users
256       first_user = create(:user)
257       second_user = create(:user)
258       third_user = create(:user)
259
260       note_with_comments_by_users = create(:note) do |note|
261         create(:note_comment, :note => note, :author => first_user)
262         create(:note_comment, :note => note, :author => second_user)
263       end
264       assert_difference "NoteComment.count", 1 do
265         assert_difference "ActionMailer::Base.deliveries.size", 2 do
266           perform_enqueued_jobs do
267             post :comment, :params => { :id => note_with_comments_by_users.id, :text => "This is an additional comment", :format => "json" }
268           end
269         end
270       end
271       assert_response :success
272       js = ActiveSupport::JSON.decode(@response.body)
273       assert_not_nil js
274       assert_equal "Feature", js["type"]
275       assert_equal note_with_comments_by_users.id, js["properties"]["id"]
276       assert_equal "open", js["properties"]["status"]
277       assert_equal 3, js["properties"]["comments"].count
278       assert_equal "commented", js["properties"]["comments"].last["action"]
279       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
280       assert_nil js["properties"]["comments"].last["user"]
281
282       email = ActionMailer::Base.deliveries.find { |e| e.to.first == first_user.email }
283       assert_not_nil email
284       assert_equal 1, email.to.length
285       assert_equal "[OpenStreetMap] An anonymous user has commented on one of your notes", email.subject
286
287       email = ActionMailer::Base.deliveries.find { |e| e.to.first == second_user.email }
288       assert_not_nil email
289       assert_equal 1, email.to.length
290       assert_equal "[OpenStreetMap] An anonymous user has commented on a note you are interested in", email.subject
291
292       get :show, :params => { :id => note_with_comments_by_users.id, :format => "json" }
293       assert_response :success
294       js = ActiveSupport::JSON.decode(@response.body)
295       assert_not_nil js
296       assert_equal "Feature", js["type"]
297       assert_equal note_with_comments_by_users.id, js["properties"]["id"]
298       assert_equal "open", js["properties"]["status"]
299       assert_equal 3, js["properties"]["comments"].count
300       assert_equal "commented", js["properties"]["comments"].last["action"]
301       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
302       assert_nil js["properties"]["comments"].last["user"]
303
304       ActionMailer::Base.deliveries.clear
305
306       basic_authorization third_user.email, "test"
307
308       assert_difference "NoteComment.count", 1 do
309         assert_difference "ActionMailer::Base.deliveries.size", 2 do
310           perform_enqueued_jobs do
311             post :comment, :params => { :id => note_with_comments_by_users.id, :text => "This is an additional comment", :format => "json" }
312           end
313         end
314       end
315       assert_response :success
316       js = ActiveSupport::JSON.decode(@response.body)
317       assert_not_nil js
318       assert_equal "Feature", js["type"]
319       assert_equal note_with_comments_by_users.id, js["properties"]["id"]
320       assert_equal "open", js["properties"]["status"]
321       assert_equal 4, js["properties"]["comments"].count
322       assert_equal "commented", js["properties"]["comments"].last["action"]
323       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
324       assert_equal third_user.display_name, js["properties"]["comments"].last["user"]
325
326       email = ActionMailer::Base.deliveries.find { |e| e.to.first == first_user.email }
327       assert_not_nil email
328       assert_equal 1, email.to.length
329       assert_equal "[OpenStreetMap] #{third_user.display_name} has commented on one of your notes", email.subject
330       assert_equal first_user.email, email.to.first
331
332       email = ActionMailer::Base.deliveries.find { |e| e.to.first == second_user.email }
333       assert_not_nil email
334       assert_equal 1, email.to.length
335       assert_equal "[OpenStreetMap] #{third_user.display_name} has commented on a note you are interested in", email.subject
336
337       get :show, :params => { :id => note_with_comments_by_users.id, :format => "json" }
338       assert_response :success
339       js = ActiveSupport::JSON.decode(@response.body)
340       assert_not_nil js
341       assert_equal "Feature", js["type"]
342       assert_equal note_with_comments_by_users.id, js["properties"]["id"]
343       assert_equal "open", js["properties"]["status"]
344       assert_equal 4, js["properties"]["comments"].count
345       assert_equal "commented", js["properties"]["comments"].last["action"]
346       assert_equal "This is an additional comment", js["properties"]["comments"].last["text"]
347       assert_equal third_user.display_name, js["properties"]["comments"].last["user"]
348
349       ActionMailer::Base.deliveries.clear
350     end
351
352     def test_comment_fail
353       open_note_with_comment = create(:note_with_comments)
354
355       assert_no_difference "NoteComment.count" do
356         post :comment, :params => { :text => "This is an additional comment" }
357       end
358       assert_response :bad_request
359
360       assert_no_difference "NoteComment.count" do
361         post :comment, :params => { :id => open_note_with_comment.id }
362       end
363       assert_response :bad_request
364
365       assert_no_difference "NoteComment.count" do
366         post :comment, :params => { :id => open_note_with_comment.id, :text => "" }
367       end
368       assert_response :bad_request
369
370       assert_no_difference "NoteComment.count" do
371         post :comment, :params => { :id => 12345, :text => "This is an additional comment" }
372       end
373       assert_response :not_found
374
375       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
376
377       assert_no_difference "NoteComment.count" do
378         post :comment, :params => { :id => hidden_note_with_comment.id, :text => "This is an additional comment" }
379       end
380       assert_response :gone
381
382       closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
383
384       assert_no_difference "NoteComment.count" do
385         post :comment, :params => { :id => closed_note_with_comment.id, :text => "This is an additional comment" }
386       end
387       assert_response :conflict
388
389       assert_no_difference "NoteComment.count" do
390         post :comment, :params => { :id => open_note_with_comment.id, :text => "x\u0000y" }
391       end
392       assert_response :bad_request
393     end
394
395     def test_close_success
396       open_note_with_comment = create(:note_with_comments)
397       user = create(:user)
398
399       post :close, :params => { :id => open_note_with_comment.id, :text => "This is a close comment", :format => "json" }
400       assert_response :unauthorized
401
402       basic_authorization user.email, "test"
403
404       post :close, :params => { :id => open_note_with_comment.id, :text => "This is a close comment", :format => "json" }
405       assert_response :success
406       js = ActiveSupport::JSON.decode(@response.body)
407       assert_not_nil js
408       assert_equal "Feature", js["type"]
409       assert_equal open_note_with_comment.id, js["properties"]["id"]
410       assert_equal "closed", js["properties"]["status"]
411       assert_equal 2, js["properties"]["comments"].count
412       assert_equal "closed", js["properties"]["comments"].last["action"]
413       assert_equal "This is a close comment", js["properties"]["comments"].last["text"]
414       assert_equal user.display_name, js["properties"]["comments"].last["user"]
415
416       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
417       assert_response :success
418       js = ActiveSupport::JSON.decode(@response.body)
419       assert_not_nil js
420       assert_equal "Feature", js["type"]
421       assert_equal open_note_with_comment.id, js["properties"]["id"]
422       assert_equal "closed", js["properties"]["status"]
423       assert_equal 2, js["properties"]["comments"].count
424       assert_equal "closed", js["properties"]["comments"].last["action"]
425       assert_equal "This is a close comment", js["properties"]["comments"].last["text"]
426       assert_equal user.display_name, js["properties"]["comments"].last["user"]
427     end
428
429     def test_close_fail
430       post :close
431       assert_response :unauthorized
432
433       basic_authorization create(:user).email, "test"
434
435       post :close
436       assert_response :bad_request
437
438       post :close, :params => { :id => 12345 }
439       assert_response :not_found
440
441       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
442
443       post :close, :params => { :id => hidden_note_with_comment.id }
444       assert_response :gone
445
446       closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
447
448       post :close, :params => { :id => closed_note_with_comment.id }
449       assert_response :conflict
450     end
451
452     def test_reopen_success
453       closed_note_with_comment = create(:note_with_comments, :status => "closed", :closed_at => Time.now)
454       user = create(:user)
455
456       post :reopen, :params => { :id => closed_note_with_comment.id, :text => "This is a reopen comment", :format => "json" }
457       assert_response :unauthorized
458
459       basic_authorization user.email, "test"
460
461       post :reopen, :params => { :id => closed_note_with_comment.id, :text => "This is a reopen comment", :format => "json" }
462       assert_response :success
463       js = ActiveSupport::JSON.decode(@response.body)
464       assert_not_nil js
465       assert_equal "Feature", js["type"]
466       assert_equal closed_note_with_comment.id, js["properties"]["id"]
467       assert_equal "open", js["properties"]["status"]
468       assert_equal 2, js["properties"]["comments"].count
469       assert_equal "reopened", js["properties"]["comments"].last["action"]
470       assert_equal "This is a reopen comment", js["properties"]["comments"].last["text"]
471       assert_equal user.display_name, js["properties"]["comments"].last["user"]
472
473       get :show, :params => { :id => closed_note_with_comment.id, :format => "json" }
474       assert_response :success
475       js = ActiveSupport::JSON.decode(@response.body)
476       assert_not_nil js
477       assert_equal "Feature", js["type"]
478       assert_equal closed_note_with_comment.id, js["properties"]["id"]
479       assert_equal "open", js["properties"]["status"]
480       assert_equal 2, js["properties"]["comments"].count
481       assert_equal "reopened", js["properties"]["comments"].last["action"]
482       assert_equal "This is a reopen comment", js["properties"]["comments"].last["text"]
483       assert_equal user.display_name, js["properties"]["comments"].last["user"]
484     end
485
486     def test_reopen_fail
487       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
488
489       post :reopen, :params => { :id => hidden_note_with_comment.id }
490       assert_response :unauthorized
491
492       basic_authorization create(:user).email, "test"
493
494       post :reopen, :params => { :id => 12345 }
495       assert_response :not_found
496
497       post :reopen, :params => { :id => hidden_note_with_comment.id }
498       assert_response :gone
499
500       open_note_with_comment = create(:note_with_comments)
501
502       post :reopen, :params => { :id => open_note_with_comment.id }
503       assert_response :conflict
504     end
505
506     def test_show_success
507       open_note = create(:note_with_comments)
508
509       get :show, :params => { :id => open_note.id, :format => "xml" }
510       assert_response :success
511       assert_equal "application/xml", @response.content_type
512       assert_select "osm", :count => 1 do
513         assert_select "note[lat='#{open_note.lat}'][lon='#{open_note.lon}']", :count => 1 do
514           assert_select "id", open_note.id.to_s
515           assert_select "url", note_url(open_note, :format => "xml")
516           assert_select "comment_url", comment_note_url(open_note, :format => "xml")
517           assert_select "close_url", close_note_url(open_note, :format => "xml")
518           assert_select "date_created", open_note.created_at.to_s
519           assert_select "status", open_note.status
520           assert_select "comments", :count => 1 do
521             assert_select "comment", :count => 1
522           end
523         end
524       end
525
526       get :show, :params => { :id => open_note.id, :format => "rss" }
527       assert_response :success
528       assert_equal "application/rss+xml", @response.content_type
529       assert_select "rss", :count => 1 do
530         assert_select "channel", :count => 1 do
531           assert_select "item", :count => 1 do
532             assert_select "link", browse_note_url(open_note)
533             assert_select "guid", note_url(open_note)
534             assert_select "pubDate", open_note.created_at.to_s(:rfc822)
535             #          assert_select "geo:lat", open_note.lat.to_s
536             #          assert_select "geo:long", open_note.lon
537             #          assert_select "georss:point", "#{open_note.lon} #{open_note.lon}"
538           end
539         end
540       end
541
542       get :show, :params => { :id => open_note.id, :format => "json" }
543       assert_response :success
544       assert_equal "application/json", @response.content_type
545       js = ActiveSupport::JSON.decode(@response.body)
546       assert_not_nil js
547       assert_equal "Feature", js["type"]
548       assert_equal "Point", js["geometry"]["type"]
549       assert_equal open_note.lat, js["geometry"]["coordinates"][0]
550       assert_equal open_note.lon, js["geometry"]["coordinates"][1]
551       assert_equal open_note.id, js["properties"]["id"]
552       assert_equal note_url(open_note, :format => "json"), js["properties"]["url"]
553       assert_equal comment_note_url(open_note, :format => "json"), js["properties"]["comment_url"]
554       assert_equal close_note_url(open_note, :format => "json"), js["properties"]["close_url"]
555       assert_equal open_note.created_at.to_s, js["properties"]["date_created"]
556       assert_equal open_note.status, js["properties"]["status"]
557
558       get :show, :params => { :id => open_note.id, :format => "gpx" }
559       assert_response :success
560       assert_equal "application/gpx+xml", @response.content_type
561       assert_select "gpx", :count => 1 do
562         assert_select "wpt[lat='#{open_note.lat}'][lon='#{open_note.lon}']", :count => 1 do
563           assert_select "time", :count => 1
564           assert_select "name", "Note: #{open_note.id}"
565           assert_select "desc", :count => 1
566           assert_select "link[href='http://test.host/note/#{open_note.id}']", :count => 1
567           assert_select "extensions", :count => 1 do
568             assert_select "id", open_note.id.to_s
569             assert_select "url", note_url(open_note, :format => "gpx")
570             assert_select "comment_url", comment_note_url(open_note, :format => "gpx")
571             assert_select "close_url", close_note_url(open_note, :format => "gpx")
572           end
573         end
574       end
575     end
576
577     def test_show_hidden_comment
578       note_with_hidden_comment = create(:note) do |note|
579         create(:note_comment, :note => note, :body => "Valid comment for hidden note")
580         create(:note_comment, :note => note, :visible => false)
581         create(:note_comment, :note => note, :body => "Another valid comment for hidden note")
582       end
583
584       get :show, :params => { :id => note_with_hidden_comment.id, :format => "json" }
585       assert_response :success
586       js = ActiveSupport::JSON.decode(@response.body)
587       assert_not_nil js
588       assert_equal "Feature", js["type"]
589       assert_equal note_with_hidden_comment.id, js["properties"]["id"]
590       assert_equal 2, js["properties"]["comments"].count
591       assert_equal "Valid comment for hidden note", js["properties"]["comments"][0]["text"]
592       assert_equal "Another valid comment for hidden note", js["properties"]["comments"][1]["text"]
593     end
594
595     def test_show_fail
596       get :show, :params => { :id => 12345 }
597       assert_response :not_found
598
599       get :show, :params => { :id => create(:note, :status => "hidden").id }
600       assert_response :gone
601     end
602
603     def test_destroy_success
604       open_note_with_comment = create(:note_with_comments)
605       user = create(:user)
606       moderator_user = create(:moderator_user)
607
608       delete :destroy, :params => { :id => open_note_with_comment.id, :text => "This is a hide comment", :format => "json" }
609       assert_response :unauthorized
610
611       basic_authorization user.email, "test"
612
613       delete :destroy, :params => { :id => open_note_with_comment.id, :text => "This is a hide comment", :format => "json" }
614       assert_response :forbidden
615
616       basic_authorization moderator_user.email, "test"
617
618       delete :destroy, :params => { :id => open_note_with_comment.id, :text => "This is a hide comment", :format => "json" }
619       assert_response :success
620       js = ActiveSupport::JSON.decode(@response.body)
621       assert_not_nil js
622       assert_equal "Feature", js["type"]
623       assert_equal open_note_with_comment.id, js["properties"]["id"]
624       assert_equal "hidden", js["properties"]["status"]
625       assert_equal 2, js["properties"]["comments"].count
626       assert_equal "hidden", js["properties"]["comments"].last["action"]
627       assert_equal "This is a hide comment", js["properties"]["comments"].last["text"]
628       assert_equal moderator_user.display_name, js["properties"]["comments"].last["user"]
629
630       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
631       assert_response :success
632
633       basic_authorization user.email, "test"
634       get :show, :params => { :id => open_note_with_comment.id, :format => "json" }
635       assert_response :gone
636     end
637
638     def test_destroy_fail
639       user = create(:user)
640       moderator_user = create(:moderator_user)
641
642       delete :destroy, :params => { :id => 12345, :format => "json" }
643       assert_response :unauthorized
644
645       basic_authorization user.email, "test"
646
647       delete :destroy, :params => { :id => 12345, :format => "json" }
648       assert_response :forbidden
649
650       basic_authorization moderator_user.email, "test"
651
652       delete :destroy, :params => { :id => 12345, :format => "json" }
653       assert_response :not_found
654
655       hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
656
657       delete :destroy, :params => { :id => hidden_note_with_comment.id, :format => "json" }
658       assert_response :gone
659     end
660
661     def test_index_success
662       position = (1.1 * GeoRecord::SCALE).to_i
663       create(:note_with_comments, :latitude => position, :longitude => position)
664       create(:note_with_comments, :latitude => position, :longitude => position)
665
666       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "rss" }
667       assert_response :success
668       assert_equal "application/rss+xml", @response.content_type
669       assert_select "rss", :count => 1 do
670         assert_select "channel", :count => 1 do
671           assert_select "item", :count => 2
672         end
673       end
674
675       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "json" }
676       assert_response :success
677       assert_equal "application/json", @response.content_type
678       js = ActiveSupport::JSON.decode(@response.body)
679       assert_not_nil js
680       assert_equal "FeatureCollection", js["type"]
681       assert_equal 2, js["features"].count
682
683       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "xml" }
684       assert_response :success
685       assert_equal "application/xml", @response.content_type
686       assert_select "osm", :count => 1 do
687         assert_select "note", :count => 2
688       end
689
690       get :index, :params => { :bbox => "1,1,1.2,1.2", :format => "gpx" }
691       assert_response :success
692       assert_equal "application/gpx+xml", @response.content_type
693       assert_select "gpx", :count => 1 do
694         assert_select "wpt", :count => 2
695       end
696     end
697
698     def test_index_limit
699       position = (1.1 * GeoRecord::SCALE).to_i
700       create(:note_with_comments, :latitude => position, :longitude => position)
701       create(:note_with_comments, :latitude => position, :longitude => position)
702
703       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "rss" }
704       assert_response :success
705       assert_equal "application/rss+xml", @response.content_type
706       assert_select "rss", :count => 1 do
707         assert_select "channel", :count => 1 do
708           assert_select "item", :count => 1
709         end
710       end
711
712       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "json" }
713       assert_response :success
714       assert_equal "application/json", @response.content_type
715       js = ActiveSupport::JSON.decode(@response.body)
716       assert_not_nil js
717       assert_equal "FeatureCollection", js["type"]
718       assert_equal 1, js["features"].count
719
720       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "xml" }
721       assert_response :success
722       assert_equal "application/xml", @response.content_type
723       assert_select "osm", :count => 1 do
724         assert_select "note", :count => 1
725       end
726
727       get :index, :params => { :bbox => "1,1,1.2,1.2", :limit => 1, :format => "gpx" }
728       assert_response :success
729       assert_equal "application/gpx+xml", @response.content_type
730       assert_select "gpx", :count => 1 do
731         assert_select "wpt", :count => 1
732       end
733     end
734
735     def test_index_empty_area
736       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "rss" }
737       assert_response :success
738       assert_equal "application/rss+xml", @response.content_type
739       assert_select "rss", :count => 1 do
740         assert_select "channel", :count => 1 do
741           assert_select "item", :count => 0
742         end
743       end
744
745       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "json" }
746       assert_response :success
747       assert_equal "application/json", @response.content_type
748       js = ActiveSupport::JSON.decode(@response.body)
749       assert_not_nil js
750       assert_equal "FeatureCollection", js["type"]
751       assert_equal 0, js["features"].count
752
753       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "xml" }
754       assert_response :success
755       assert_equal "application/xml", @response.content_type
756       assert_select "osm", :count => 1 do
757         assert_select "note", :count => 0
758       end
759
760       get :index, :params => { :bbox => "5,5,5.1,5.1", :format => "gpx" }
761       assert_response :success
762       assert_equal "application/gpx+xml", @response.content_type
763       assert_select "gpx", :count => 1 do
764         assert_select "wpt", :count => 0
765       end
766     end
767
768     def test_index_large_area
769       get :index, :params => { :bbox => "-2.5,-2.5,2.5,2.5", :format => :json }
770       assert_response :success
771       assert_equal "application/json", @response.content_type
772
773       get :index, :params => { :l => "-2.5", :b => "-2.5", :r => "2.5", :t => "2.5", :format => :json }
774       assert_response :success
775       assert_equal "application/json", @response.content_type
776
777       get :index, :params => { :bbox => "-10,-10,12,12", :format => :json }
778       assert_response :bad_request
779       assert_equal "application/json", @response.content_type
780
781       get :index, :params => { :l => "-10", :b => "-10", :r => "12", :t => "12", :format => :json }
782       assert_response :bad_request
783       assert_equal "application/json", @response.content_type
784     end
785
786     def test_index_closed
787       create(:note_with_comments, :status => "closed", :closed_at => Time.now - 5.days)
788       create(:note_with_comments, :status => "closed", :closed_at => Time.now - 100.days)
789       create(:note_with_comments, :status => "hidden")
790       create(:note_with_comments)
791
792       # Open notes + closed in last 7 days
793       get :index, :params => { :bbox => "1,1,1.7,1.7", :closed => "7", :format => "json" }
794       assert_response :success
795       assert_equal "application/json", @response.content_type
796       js = ActiveSupport::JSON.decode(@response.body)
797       assert_not_nil js
798       assert_equal "FeatureCollection", js["type"]
799       assert_equal 2, js["features"].count
800
801       # Only open notes
802       get :index, :params => { :bbox => "1,1,1.7,1.7", :closed => "0", :format => "json" }
803       assert_response :success
804       assert_equal "application/json", @response.content_type
805       js = ActiveSupport::JSON.decode(@response.body)
806       assert_not_nil js
807       assert_equal "FeatureCollection", js["type"]
808       assert_equal 1, js["features"].count
809
810       # Open notes + all closed notes
811       get :index, :params => { :bbox => "1,1,1.7,1.7", :closed => "-1", :format => "json" }
812       assert_response :success
813       assert_equal "application/json", @response.content_type
814       js = ActiveSupport::JSON.decode(@response.body)
815       assert_not_nil js
816       assert_equal "FeatureCollection", js["type"]
817       assert_equal 3, js["features"].count
818     end
819
820     def test_index_bad_params
821       get :index, :params => { :bbox => "-2.5,-2.5,2.5" }
822       assert_response :bad_request
823
824       get :index, :params => { :bbox => "-2.5,-2.5,2.5,2.5,2.5" }
825       assert_response :bad_request
826
827       get :index, :params => { :b => "-2.5", :r => "2.5", :t => "2.5" }
828       assert_response :bad_request
829
830       get :index, :params => { :l => "-2.5", :r => "2.5", :t => "2.5" }
831       assert_response :bad_request
832
833       get :index, :params => { :l => "-2.5", :b => "-2.5", :t => "2.5" }
834       assert_response :bad_request
835
836       get :index, :params => { :l => "-2.5", :b => "-2.5", :r => "2.5" }
837       assert_response :bad_request
838
839       get :index, :params => { :bbox => "1,1,1.7,1.7", :limit => "0", :format => "json" }
840       assert_response :bad_request
841
842       get :index, :params => { :bbox => "1,1,1.7,1.7", :limit => "10001", :format => "json" }
843       assert_response :bad_request
844     end
845
846     def test_search_success
847       create(:note_with_comments)
848
849       get :search, :params => { :q => "note comment", :format => "xml" }
850       assert_response :success
851       assert_equal "application/xml", @response.content_type
852       assert_select "osm", :count => 1 do
853         assert_select "note", :count => 1
854       end
855
856       get :search, :params => { :q => "note comment", :format => "json" }
857       assert_response :success
858       assert_equal "application/json", @response.content_type
859       js = ActiveSupport::JSON.decode(@response.body)
860       assert_not_nil js
861       assert_equal "FeatureCollection", js["type"]
862       assert_equal 1, js["features"].count
863
864       get :search, :params => { :q => "note comment", :format => "rss" }
865       assert_response :success
866       assert_equal "application/rss+xml", @response.content_type
867       assert_select "rss", :count => 1 do
868         assert_select "channel", :count => 1 do
869           assert_select "item", :count => 1
870         end
871       end
872
873       get :search, :params => { :q => "note comment", :format => "gpx" }
874       assert_response :success
875       assert_equal "application/gpx+xml", @response.content_type
876       assert_select "gpx", :count => 1 do
877         assert_select "wpt", :count => 1
878       end
879     end
880
881     def test_search_by_display_name_success
882       user = create(:user)
883
884       create(:note) do |note|
885         create(:note_comment, :note => note, :author => user)
886       end
887
888       get :search, :params => { :display_name => user.display_name, :format => "xml" }
889       assert_response :success
890       assert_equal "application/xml", @response.content_type
891       assert_select "osm", :count => 1 do
892         assert_select "note", :count => 1
893       end
894
895       get :search, :params => { :display_name => user.display_name, :format => "json" }
896       assert_response :success
897       assert_equal "application/json", @response.content_type
898       js = ActiveSupport::JSON.decode(@response.body)
899       assert_not_nil js
900       assert_equal "FeatureCollection", js["type"]
901       assert_equal 1, js["features"].count
902
903       get :search, :params => { :display_name => user.display_name, :format => "rss" }
904       assert_response :success
905       assert_equal "application/rss+xml", @response.content_type
906       assert_select "rss", :count => 1 do
907         assert_select "channel", :count => 1 do
908           assert_select "item", :count => 1
909         end
910       end
911
912       get :search, :params => { :display_name => user.display_name, :format => "gpx" }
913       assert_response :success
914       assert_equal "application/gpx+xml", @response.content_type
915       assert_select "gpx", :count => 1 do
916         assert_select "wpt", :count => 1
917       end
918     end
919
920     def test_search_by_user_success
921       user = create(:user)
922
923       create(:note) do |note|
924         create(:note_comment, :note => note, :author => user)
925       end
926
927       get :search, :params => { :user => user.id, :format => "xml" }
928       assert_response :success
929       assert_equal "application/xml", @response.content_type
930       assert_select "osm", :count => 1 do
931         assert_select "note", :count => 1
932       end
933
934       get :search, :params => { :user => user.id, :format => "json" }
935       assert_response :success
936       assert_equal "application/json", @response.content_type
937       js = ActiveSupport::JSON.decode(@response.body)
938       assert_not_nil js
939       assert_equal "FeatureCollection", js["type"]
940       assert_equal 1, js["features"].count
941
942       get :search, :params => { :user => user.id, :format => "rss" }
943       assert_response :success
944       assert_equal "application/rss+xml", @response.content_type
945       assert_select "rss", :count => 1 do
946         assert_select "channel", :count => 1 do
947           assert_select "item", :count => 1
948         end
949       end
950
951       get :search, :params => { :user => user.id, :format => "gpx" }
952       assert_response :success
953       assert_equal "application/gpx+xml", @response.content_type
954       assert_select "gpx", :count => 1 do
955         assert_select "wpt", :count => 1
956       end
957     end
958
959     def test_search_no_match
960       create(:note_with_comments)
961
962       get :search, :params => { :q => "no match", :format => "xml" }
963       assert_response :success
964       assert_equal "application/xml", @response.content_type
965       assert_select "osm", :count => 1 do
966         assert_select "note", :count => 0
967       end
968
969       get :search, :params => { :q => "no match", :format => "json" }
970       assert_response :success
971       assert_equal "application/json", @response.content_type
972       js = ActiveSupport::JSON.decode(@response.body)
973       assert_not_nil js
974       assert_equal "FeatureCollection", js["type"]
975       assert_equal 0, js["features"].count
976
977       get :search, :params => { :q => "no match", :format => "rss" }
978       assert_response :success
979       assert_equal "application/rss+xml", @response.content_type
980       assert_select "rss", :count => 1 do
981         assert_select "channel", :count => 1 do
982           assert_select "item", :count => 0
983         end
984       end
985
986       get :search, :params => { :q => "no match", :format => "gpx" }
987       assert_response :success
988       assert_equal "application/gpx+xml", @response.content_type
989       assert_select "gpx", :count => 1 do
990         assert_select "wpt", :count => 0
991       end
992     end
993
994     def test_search_by_time_no_match
995       create(:note_with_comments)
996
997       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "xml" }
998       assert_response :success
999       assert_equal "application/xml", @response.content_type
1000       assert_select "osm", :count => 1 do
1001         assert_select "note", :count => 0
1002       end
1003
1004       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "json" }
1005       assert_response :success
1006       assert_equal "application/json", @response.content_type
1007       js = ActiveSupport::JSON.decode(@response.body)
1008       assert_not_nil js
1009       assert_equal "FeatureCollection", js["type"]
1010       assert_equal 0, js["features"].count
1011
1012       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "rss" }
1013       assert_response :success
1014       assert_equal "application/rss+xml", @response.content_type
1015       assert_select "rss", :count => 1 do
1016         assert_select "channel", :count => 1 do
1017           assert_select "item", :count => 0
1018         end
1019       end
1020
1021       get :search, :params => { :from => "01.01.2010", :to => "01.10.2010", :format => "gpx" }
1022       assert_response :success
1023       assert_equal "application/gpx+xml", @response.content_type
1024       assert_select "gpx", :count => 1 do
1025         assert_select "wpt", :count => 0
1026       end
1027     end
1028
1029     def test_search_bad_params
1030       get :search, :params => { :q => "no match", :limit => "0", :format => "json" }
1031       assert_response :bad_request
1032
1033       get :search, :params => { :q => "no match", :limit => "10001", :format => "json" }
1034       assert_response :bad_request
1035
1036       get :search, :params => { :display_name => "non-existent" }
1037       assert_response :bad_request
1038
1039       get :search, :params => { :user => "-1" }
1040       assert_response :bad_request
1041
1042       get :search, :params => { :from => "wrong-date", :to => "wrong-date" }
1043       assert_response :bad_request
1044
1045       get :search, :params => { :from => "01.01.2010", :to => "2010.01.2010" }
1046       assert_response :bad_request
1047     end
1048
1049     def test_feed_success
1050       position = (1.1 * GeoRecord::SCALE).to_i
1051       create(:note_with_comments, :latitude => position, :longitude => position)
1052       create(:note_with_comments, :latitude => position, :longitude => position)
1053       position = (1.5 * GeoRecord::SCALE).to_i
1054       create(:note_with_comments, :latitude => position, :longitude => position)
1055       create(:note_with_comments, :latitude => position, :longitude => position)
1056
1057       get :feed, :params => { :format => "rss" }
1058       assert_response :success
1059       assert_equal "application/rss+xml", @response.content_type
1060       assert_select "rss", :count => 1 do
1061         assert_select "channel", :count => 1 do
1062           assert_select "item", :count => 4
1063         end
1064       end
1065
1066       get :feed, :params => { :bbox => "1,1,1.2,1.2", :format => "rss" }
1067       assert_response :success
1068       assert_equal "application/rss+xml", @response.content_type
1069       assert_select "rss", :count => 1 do
1070         assert_select "channel", :count => 1 do
1071           assert_select "item", :count => 2
1072         end
1073       end
1074     end
1075
1076     def test_feed_fail
1077       get :feed, :params => { :bbox => "1,1,1.2", :format => "rss" }
1078       assert_response :bad_request
1079
1080       get :feed, :params => { :bbox => "1,1,1.2,1.2,1.2", :format => "rss" }
1081       assert_response :bad_request
1082
1083       get :feed, :params => { :bbox => "1,1,1.2,1.2", :limit => "0", :format => "rss" }
1084       assert_response :bad_request
1085
1086       get :feed, :params => { :bbox => "1,1,1.2,1.2", :limit => "10001", :format => "rss" }
1087       assert_response :bad_request
1088     end
1089   end
1090 end