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