]> git.openstreetmap.org Git - rails.git/blob - test/controllers/api/notes_controller_test.rb
Set sidebar background using Bootstrap class
[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" }
18       )
19       assert_routing(
20         { :path => "/api/0.6/notes/1", :method => :get },
21         { :controller => "api/notes", :action => "show", :id => "1" }
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" }
42       )
43       assert_routing(
44         { :path => "/api/0.6/notes/1/close", :method => :post },
45         { :controller => "api/notes", :action => "close", :id => "1" }
46       )
47       assert_routing(
48         { :path => "/api/0.6/notes/1/reopen", :method => :post },
49         { :controller => "api/notes", :action => "reopen", :id => "1" }
50       )
51       assert_routing(
52         { :path => "/api/0.6/notes/1", :method => :delete },
53         { :controller => "api/notes", :action => "destroy", :id => "1" }
54       )
55
56       assert_routing(
57         { :path => "/api/0.6/notes", :method => :get },
58         { :controller => "api/notes", :action => "index" }
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" }
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 api_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 api_note_path(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 api_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 api_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 api_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 api_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 api_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 api_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 api_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 api_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 api_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_api_note_path(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 api_note_path(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_api_note_path(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 api_note_path(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_api_note_path(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_api_note_path(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_api_note_path(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_api_note_path(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_api_note_path(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, :closed)
349
350       assert_no_difference "NoteComment.count" do
351         post comment_api_note_path(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_api_note_path(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_api_note_path(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_api_note_path(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 api_note_path(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_api_note_path(12345)
397       assert_response :unauthorized
398
399       auth_header = basic_authorization_header create(:user).email, "test"
400
401       post close_api_note_path(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_api_note_path(hidden_note_with_comment), :headers => auth_header
407       assert_response :gone
408
409       closed_note_with_comment = create(:note_with_comments, :closed)
410
411       post close_api_note_path(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, :closed)
417       user = create(:user)
418
419       post reopen_api_note_path(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_api_note_path(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 3, 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 api_note_path(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 3, 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_api_note_path(hidden_note_with_comment)
453       assert_response :unauthorized
454
455       auth_header = basic_authorization_header create(:user).email, "test"
456
457       post reopen_api_note_path(12345), :headers => auth_header
458       assert_response :not_found
459
460       post reopen_api_note_path(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_api_note_path(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 api_note_path(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", api_note_url(open_note, :format => "xml")
479           assert_select "comment_url", comment_api_note_url(open_note, :format => "xml")
480           assert_select "close_url", close_api_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 api_note_path(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", note_url(open_note)
496             assert_select "guid", api_note_url(open_note)
497             assert_select "pubDate", open_note.created_at.to_fs(:rfc822)
498             assert_select "geo|lat", open_note.lat.to_s
499             assert_select "geo|long", open_note.lon.to_s
500             assert_select "georss|point", "#{open_note.lon} #{open_note.lon}"
501           end
502         end
503       end
504
505       get api_note_path(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 api_note_url(open_note, :format => "json"), js["properties"]["url"]
516       assert_equal comment_api_note_url(open_note, :format => "json"), js["properties"]["comment_url"]
517       assert_equal close_api_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 api_note_path(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", api_note_url(open_note, :format => "gpx")
533             assert_select "comment_url", comment_api_note_url(open_note, :format => "gpx")
534             assert_select "close_url", close_api_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 api_note_path(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 api_note_path(12345)
560       assert_response :not_found
561
562       get api_note_path(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 api_note_path(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 api_note_path(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 api_note_path(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 api_note_path(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 api_note_path(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 api_note_path(12345, :format => "json")
607       assert_response :unauthorized
608
609       auth_header = basic_authorization_header user.email, "test"
610
611       delete api_note_path(12345, :format => "json"), :headers => auth_header
612       assert_response :forbidden
613
614       auth_header = basic_authorization_header moderator_user.email, "test"
615
616       delete api_note_path(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 api_note_path(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 api_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 "description", :text => /1\.2/, :count => 1
636           assert_select "item", :count => 2
637         end
638       end
639
640       get api_notes_path(:bbox => "1,1,1.2,1.2", :format => "json")
641       assert_response :success
642       assert_equal "application/json", @response.media_type
643       js = ActiveSupport::JSON.decode(@response.body)
644       assert_not_nil js
645       assert_equal "FeatureCollection", js["type"]
646       assert_equal 2, js["features"].count
647
648       get api_notes_path(:bbox => "1,1,1.2,1.2", :format => "xml")
649       assert_response :success
650       assert_equal "application/xml", @response.media_type
651       assert_select "osm", :count => 1 do
652         assert_select "note", :count => 2
653       end
654
655       get api_notes_path(:bbox => "1,1,1.2,1.2", :format => "gpx")
656       assert_response :success
657       assert_equal "application/gpx+xml", @response.media_type
658       assert_select "gpx", :count => 1 do
659         assert_select "wpt", :count => 2
660       end
661     end
662
663     def test_index_limit
664       position = (1.1 * GeoRecord::SCALE).to_i
665       create(:note_with_comments, :latitude => position, :longitude => position)
666       create(:note_with_comments, :latitude => position, :longitude => position)
667
668       get api_notes_path(:bbox => "1,1,1.2,1.2", :limit => 1, :format => "rss")
669       assert_response :success
670       assert_equal "application/rss+xml", @response.media_type
671       assert_select "rss", :count => 1 do
672         assert_select "channel", :count => 1 do
673           assert_select "item", :count => 1
674         end
675       end
676
677       get api_notes_path(:bbox => "1,1,1.2,1.2", :limit => 1, :format => "json")
678       assert_response :success
679       assert_equal "application/json", @response.media_type
680       js = ActiveSupport::JSON.decode(@response.body)
681       assert_not_nil js
682       assert_equal "FeatureCollection", js["type"]
683       assert_equal 1, js["features"].count
684
685       get api_notes_path(:bbox => "1,1,1.2,1.2", :limit => 1, :format => "xml")
686       assert_response :success
687       assert_equal "application/xml", @response.media_type
688       assert_select "osm", :count => 1 do
689         assert_select "note", :count => 1
690       end
691
692       get api_notes_path(:bbox => "1,1,1.2,1.2", :limit => 1, :format => "gpx")
693       assert_response :success
694       assert_equal "application/gpx+xml", @response.media_type
695       assert_select "gpx", :count => 1 do
696         assert_select "wpt", :count => 1
697       end
698
699       get api_notes_path(:bbox => "1,1,1.2,1.2", :limit => Settings.max_note_query_limit, :format => "rss")
700       assert_response :success
701     end
702
703     def test_index_empty_area
704       get api_notes_path(:bbox => "5,5,5.1,5.1", :format => "rss")
705       assert_response :success
706       assert_equal "application/rss+xml", @response.media_type
707       assert_select "rss", :count => 1 do
708         assert_select "channel", :count => 1 do
709           assert_select "item", :count => 0
710         end
711       end
712
713       get api_notes_path(:bbox => "5,5,5.1,5.1", :format => "json")
714       assert_response :success
715       assert_equal "application/json", @response.media_type
716       js = ActiveSupport::JSON.decode(@response.body)
717       assert_not_nil js
718       assert_equal "FeatureCollection", js["type"]
719       assert_equal 0, js["features"].count
720
721       get api_notes_path(:bbox => "5,5,5.1,5.1", :format => "xml")
722       assert_response :success
723       assert_equal "application/xml", @response.media_type
724       assert_select "osm", :count => 1 do
725         assert_select "note", :count => 0
726       end
727
728       get api_notes_path(:bbox => "5,5,5.1,5.1", :format => "gpx")
729       assert_response :success
730       assert_equal "application/gpx+xml", @response.media_type
731       assert_select "gpx", :count => 1 do
732         assert_select "wpt", :count => 0
733       end
734     end
735
736     def test_index_large_area
737       get api_notes_path(:bbox => "-2.5,-2.5,2.5,2.5", :format => :json)
738       assert_response :success
739       assert_equal "application/json", @response.media_type
740
741       get api_notes_path(:l => "-2.5", :b => "-2.5", :r => "2.5", :t => "2.5", :format => :json)
742       assert_response :success
743       assert_equal "application/json", @response.media_type
744
745       get api_notes_path(:bbox => "-10,-10,12,12", :format => :json)
746       assert_response :bad_request
747       assert_equal "text/plain", @response.media_type
748
749       get api_notes_path(:l => "-10", :b => "-10", :r => "12", :t => "12", :format => :json)
750       assert_response :bad_request
751       assert_equal "text/plain", @response.media_type
752     end
753
754     def test_index_closed
755       create(:note_with_comments, :closed, :closed_at => Time.now.utc - 5.days)
756       create(:note_with_comments, :closed, :closed_at => Time.now.utc - 100.days)
757       create(:note_with_comments, :status => "hidden")
758       create(:note_with_comments)
759
760       # Open notes + closed in last 7 days
761       get api_notes_path(:bbox => "1,1,1.7,1.7", :closed => "7", :format => "json")
762       assert_response :success
763       assert_equal "application/json", @response.media_type
764       js = ActiveSupport::JSON.decode(@response.body)
765       assert_not_nil js
766       assert_equal "FeatureCollection", js["type"]
767       assert_equal 2, js["features"].count
768
769       # Only open notes
770       get api_notes_path(:bbox => "1,1,1.7,1.7", :closed => "0", :format => "json")
771       assert_response :success
772       assert_equal "application/json", @response.media_type
773       js = ActiveSupport::JSON.decode(@response.body)
774       assert_not_nil js
775       assert_equal "FeatureCollection", js["type"]
776       assert_equal 1, js["features"].count
777
778       # Open notes + all closed notes
779       get api_notes_path(:bbox => "1,1,1.7,1.7", :closed => "-1", :format => "json")
780       assert_response :success
781       assert_equal "application/json", @response.media_type
782       js = ActiveSupport::JSON.decode(@response.body)
783       assert_not_nil js
784       assert_equal "FeatureCollection", js["type"]
785       assert_equal 3, js["features"].count
786     end
787
788     def test_index_bad_params
789       get api_notes_path
790       assert_response :bad_request
791       assert_equal "The parameter bbox is required", @response.body
792
793       get api_notes_path(:bbox => "-2.5,-2.5,2.5")
794       assert_response :bad_request
795
796       get api_notes_path(:bbox => "-2.5,-2.5,2.5,2.5,2.5")
797       assert_response :bad_request
798
799       get api_notes_path(:b => "-2.5", :r => "2.5", :t => "2.5")
800       assert_response :bad_request
801
802       get api_notes_path(:l => "-2.5", :r => "2.5", :t => "2.5")
803       assert_response :bad_request
804
805       get api_notes_path(:l => "-2.5", :b => "-2.5", :t => "2.5")
806       assert_response :bad_request
807
808       get api_notes_path(:l => "-2.5", :b => "-2.5", :r => "2.5")
809       assert_response :bad_request
810
811       get api_notes_path(:bbox => "1,1,1.7,1.7", :limit => "0", :format => "json")
812       assert_response :bad_request
813
814       get api_notes_path(:bbox => "1,1,1.7,1.7", :limit => Settings.max_note_query_limit + 1, :format => "json")
815       assert_response :bad_request
816     end
817
818     def test_search_success
819       create(:note_with_comments)
820
821       get search_api_notes_path(:q => "note comment", :format => "xml")
822       assert_response :success
823       assert_equal "application/xml", @response.media_type
824       assert_select "osm", :count => 1 do
825         assert_select "note", :count => 1
826       end
827
828       get search_api_notes_path(:q => "note comment", :format => "json")
829       assert_response :success
830       assert_equal "application/json", @response.media_type
831       js = ActiveSupport::JSON.decode(@response.body)
832       assert_not_nil js
833       assert_equal "FeatureCollection", js["type"]
834       assert_equal 1, js["features"].count
835
836       get search_api_notes_path(:q => "note comment", :format => "rss")
837       assert_response :success
838       assert_equal "application/rss+xml", @response.media_type
839       assert_select "rss", :count => 1 do
840         assert_select "channel", :count => 1 do
841           assert_select "item", :count => 1
842         end
843       end
844
845       get search_api_notes_path(:q => "note comment", :format => "gpx")
846       assert_response :success
847       assert_equal "application/gpx+xml", @response.media_type
848       assert_select "gpx", :count => 1 do
849         assert_select "wpt", :count => 1
850       end
851
852       get search_api_notes_path(:q => "note comment", :limit => Settings.max_note_query_limit, :format => "xml")
853       assert_response :success
854     end
855
856     def test_search_by_display_name_success
857       user = create(:user)
858
859       create(:note) do |note|
860         create(:note_comment, :note => note, :author => user)
861       end
862
863       get search_api_notes_path(:display_name => user.display_name, :format => "xml")
864       assert_response :success
865       assert_equal "application/xml", @response.media_type
866       assert_select "osm", :count => 1 do
867         assert_select "note", :count => 1
868       end
869
870       get search_api_notes_path(:display_name => user.display_name, :format => "json")
871       assert_response :success
872       assert_equal "application/json", @response.media_type
873       js = ActiveSupport::JSON.decode(@response.body)
874       assert_not_nil js
875       assert_equal "FeatureCollection", js["type"]
876       assert_equal 1, js["features"].count
877
878       get search_api_notes_path(:display_name => user.display_name, :format => "rss")
879       assert_response :success
880       assert_equal "application/rss+xml", @response.media_type
881       assert_select "rss", :count => 1 do
882         assert_select "channel", :count => 1 do
883           assert_select "item", :count => 1
884         end
885       end
886
887       get search_api_notes_path(:display_name => user.display_name, :format => "gpx")
888       assert_response :success
889       assert_equal "application/gpx+xml", @response.media_type
890       assert_select "gpx", :count => 1 do
891         assert_select "wpt", :count => 1
892       end
893     end
894
895     def test_search_by_user_success
896       user = create(:user)
897
898       create(:note) do |note|
899         create(:note_comment, :note => note, :author => user)
900       end
901
902       get search_api_notes_path(:user => user.id, :format => "xml")
903       assert_response :success
904       assert_equal "application/xml", @response.media_type
905       assert_select "osm", :count => 1 do
906         assert_select "note", :count => 1
907       end
908
909       get search_api_notes_path(:user => user.id, :format => "json")
910       assert_response :success
911       assert_equal "application/json", @response.media_type
912       js = ActiveSupport::JSON.decode(@response.body)
913       assert_not_nil js
914       assert_equal "FeatureCollection", js["type"]
915       assert_equal 1, js["features"].count
916
917       get search_api_notes_path(:user => user.id, :format => "rss")
918       assert_response :success
919       assert_equal "application/rss+xml", @response.media_type
920       assert_select "rss", :count => 1 do
921         assert_select "channel", :count => 1 do
922           assert_select "item", :count => 1
923         end
924       end
925
926       get search_api_notes_path(:user => user.id, :format => "gpx")
927       assert_response :success
928       assert_equal "application/gpx+xml", @response.media_type
929       assert_select "gpx", :count => 1 do
930         assert_select "wpt", :count => 1
931       end
932     end
933
934     def test_search_by_bbox_success
935       notes = Array.new(5) do |i|
936         position = ((1.0 + (i * 0.1)) * GeoRecord::SCALE).to_i
937         create(:note_with_comments, :created_at => Time.parse("2020-01-01T00:00:00Z") + i.day, :latitude => position, :longitude => position)
938       end
939
940       get search_api_notes_path(:bbox => "1.0,1.0,1.6,1.6", :sort => "created_at", :order => "oldest", :format => "xml")
941       assert_response :success
942       assert_equal "application/xml", @response.media_type
943       assert_notes_in_order notes
944
945       get search_api_notes_path(:bbox => "1.25,1.25,1.45,1.45", :sort => "created_at", :order => "oldest", :format => "xml")
946       assert_response :success
947       assert_equal "application/xml", @response.media_type
948       assert_notes_in_order [notes[3], notes[4]]
949
950       get search_api_notes_path(:bbox => "2.0,2.0,2.5,2.5", :sort => "created_at", :order => "oldest", :format => "xml")
951       assert_response :success
952       assert_equal "application/xml", @response.media_type
953       assert_notes_in_order []
954     end
955
956     def test_search_no_match
957       create(:note_with_comments)
958
959       get search_api_notes_path(:q => "no match", :format => "xml")
960       assert_response :success
961       assert_equal "application/xml", @response.media_type
962       assert_select "osm", :count => 1 do
963         assert_select "note", :count => 0
964       end
965
966       get search_api_notes_path(:q => "no match", :format => "json")
967       assert_response :success
968       assert_equal "application/json", @response.media_type
969       js = ActiveSupport::JSON.decode(@response.body)
970       assert_not_nil js
971       assert_equal "FeatureCollection", js["type"]
972       assert_equal 0, js["features"].count
973
974       get search_api_notes_path(:q => "no match", :format => "rss")
975       assert_response :success
976       assert_equal "application/rss+xml", @response.media_type
977       assert_select "rss", :count => 1 do
978         assert_select "channel", :count => 1 do
979           assert_select "item", :count => 0
980         end
981       end
982
983       get search_api_notes_path(:q => "no match", :format => "gpx")
984       assert_response :success
985       assert_equal "application/gpx+xml", @response.media_type
986       assert_select "gpx", :count => 1 do
987         assert_select "wpt", :count => 0
988       end
989     end
990
991     def test_search_by_time_no_match
992       create(:note_with_comments)
993
994       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "xml")
995       assert_response :success
996       assert_equal "application/xml", @response.media_type
997       assert_select "osm", :count => 1 do
998         assert_select "note", :count => 0
999       end
1000
1001       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "json")
1002       assert_response :success
1003       assert_equal "application/json", @response.media_type
1004       js = ActiveSupport::JSON.decode(@response.body)
1005       assert_not_nil js
1006       assert_equal "FeatureCollection", js["type"]
1007       assert_equal 0, js["features"].count
1008
1009       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "rss")
1010       assert_response :success
1011       assert_equal "application/rss+xml", @response.media_type
1012       assert_select "rss", :count => 1 do
1013         assert_select "channel", :count => 1 do
1014           assert_select "item", :count => 0
1015         end
1016       end
1017
1018       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "gpx")
1019       assert_response :success
1020       assert_equal "application/gpx+xml", @response.media_type
1021       assert_select "gpx", :count => 1 do
1022         assert_select "wpt", :count => 0
1023       end
1024     end
1025
1026     def test_search_bad_params
1027       get search_api_notes_path(:q => "no match", :limit => "0", :format => "json")
1028       assert_response :bad_request
1029
1030       get search_api_notes_path(:q => "no match", :limit => Settings.max_note_query_limit + 1, :format => "json")
1031       assert_response :bad_request
1032
1033       get search_api_notes_path(:display_name => "non-existent")
1034       assert_response :bad_request
1035
1036       get search_api_notes_path(:user => "-1")
1037       assert_response :bad_request
1038
1039       get search_api_notes_path(:from => "wrong-date", :to => "wrong-date")
1040       assert_response :bad_request
1041
1042       get search_api_notes_path(:from => "01.01.2010", :to => "2010.01.2010")
1043       assert_response :bad_request
1044     end
1045
1046     def test_feed_success
1047       position = (1.1 * GeoRecord::SCALE).to_i
1048       create(:note_with_comments, :latitude => position, :longitude => position)
1049       create(:note_with_comments, :latitude => position, :longitude => position)
1050       position = (1.5 * GeoRecord::SCALE).to_i
1051       create(:note_with_comments, :latitude => position, :longitude => position)
1052       create(:note_with_comments, :latitude => position, :longitude => position)
1053
1054       get feed_api_notes_path(:format => "rss")
1055       assert_response :success
1056       assert_equal "application/rss+xml", @response.media_type
1057       assert_select "rss", :count => 1 do
1058         assert_select "channel", :count => 1 do
1059           assert_select "item", :count => 4
1060         end
1061       end
1062
1063       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :format => "rss")
1064       assert_response :success
1065       assert_equal "application/rss+xml", @response.media_type
1066       assert_select "rss", :count => 1 do
1067         assert_select "channel", :count => 1 do
1068           assert_select "description", :text => /1\.2/, :count => 1
1069           assert_select "item", :count => 2
1070         end
1071       end
1072
1073       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :limit => Settings.max_note_query_limit, :format => "rss")
1074       assert_response :success
1075     end
1076
1077     def test_feed_fail
1078       get feed_api_notes_path(:bbox => "1,1,1.2", :format => "rss")
1079       assert_response :bad_request
1080
1081       get feed_api_notes_path(:bbox => "1,1,1.2,1.2,1.2", :format => "rss")
1082       assert_response :bad_request
1083
1084       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :limit => "0", :format => "rss")
1085       assert_response :bad_request
1086
1087       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :limit => Settings.max_note_query_limit + 1, :format => "rss")
1088       assert_response :bad_request
1089     end
1090
1091     private
1092
1093     def assert_notes_in_order(notes)
1094       assert_select "osm>note", notes.size
1095       notes.each_with_index do |note, index|
1096         assert_select "osm>note:nth-child(#{index + 1})>id", :text => note.id.to_s, :count => 1
1097       end
1098     end
1099   end
1100 end