]> git.openstreetmap.org Git - rails.git/blob - test/controllers/api/notes_controller_test.rb
Use max note query limit setting in tests
[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 => 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(: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 api_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_api_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 api_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_api_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_api_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_api_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_api_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_api_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.utc)
349
350       assert_no_difference "NoteComment.count" do
351         post comment_api_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_api_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_api_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_api_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 api_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_api_note_path(:id => 12345)
397       assert_response :unauthorized
398
399       auth_header = basic_authorization_header create(:user).email, "test"
400
401       post close_api_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_api_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.utc)
410
411       post close_api_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.utc)
417       user = create(:user)
418
419       post reopen_api_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_api_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 api_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_api_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_api_note_path(:id => 12345), :headers => auth_header
458       assert_response :not_found
459
460       post reopen_api_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_api_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 api_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", 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(: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", 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(: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 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(: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", 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(: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 api_note_path(:id => 12345)
560       assert_response :not_found
561
562       get api_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 api_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 api_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 api_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 api_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 api_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 api_note_path(:id => 12345, :format => "json")
607       assert_response :unauthorized
608
609       auth_header = basic_authorization_header user.email, "test"
610
611       delete api_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 api_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 api_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 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, :status => "closed", :closed_at => Time.now.utc - 5.days)
756       create(:note_with_comments, :status => "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(:bbox => "-2.5,-2.5,2.5")
790       assert_response :bad_request
791
792       get api_notes_path(:bbox => "-2.5,-2.5,2.5,2.5,2.5")
793       assert_response :bad_request
794
795       get api_notes_path(:b => "-2.5", :r => "2.5", :t => "2.5")
796       assert_response :bad_request
797
798       get api_notes_path(:l => "-2.5", :r => "2.5", :t => "2.5")
799       assert_response :bad_request
800
801       get api_notes_path(:l => "-2.5", :b => "-2.5", :t => "2.5")
802       assert_response :bad_request
803
804       get api_notes_path(:l => "-2.5", :b => "-2.5", :r => "2.5")
805       assert_response :bad_request
806
807       get api_notes_path(:bbox => "1,1,1.7,1.7", :limit => "0", :format => "json")
808       assert_response :bad_request
809
810       get api_notes_path(:bbox => "1,1,1.7,1.7", :limit => Settings.max_note_query_limit + 1, :format => "json")
811       assert_response :bad_request
812     end
813
814     def test_search_success
815       create(:note_with_comments)
816
817       get search_api_notes_path(:q => "note comment", :format => "xml")
818       assert_response :success
819       assert_equal "application/xml", @response.media_type
820       assert_select "osm", :count => 1 do
821         assert_select "note", :count => 1
822       end
823
824       get search_api_notes_path(:q => "note comment", :format => "json")
825       assert_response :success
826       assert_equal "application/json", @response.media_type
827       js = ActiveSupport::JSON.decode(@response.body)
828       assert_not_nil js
829       assert_equal "FeatureCollection", js["type"]
830       assert_equal 1, js["features"].count
831
832       get search_api_notes_path(:q => "note comment", :format => "rss")
833       assert_response :success
834       assert_equal "application/rss+xml", @response.media_type
835       assert_select "rss", :count => 1 do
836         assert_select "channel", :count => 1 do
837           assert_select "item", :count => 1
838         end
839       end
840
841       get search_api_notes_path(:q => "note comment", :format => "gpx")
842       assert_response :success
843       assert_equal "application/gpx+xml", @response.media_type
844       assert_select "gpx", :count => 1 do
845         assert_select "wpt", :count => 1
846       end
847
848       get search_api_notes_path(:q => "note comment", :limit => Settings.max_note_query_limit, :format => "xml")
849       assert_response :success
850     end
851
852     def test_search_by_display_name_success
853       user = create(:user)
854
855       create(:note) do |note|
856         create(:note_comment, :note => note, :author => user)
857       end
858
859       get search_api_notes_path(:display_name => user.display_name, :format => "xml")
860       assert_response :success
861       assert_equal "application/xml", @response.media_type
862       assert_select "osm", :count => 1 do
863         assert_select "note", :count => 1
864       end
865
866       get search_api_notes_path(:display_name => user.display_name, :format => "json")
867       assert_response :success
868       assert_equal "application/json", @response.media_type
869       js = ActiveSupport::JSON.decode(@response.body)
870       assert_not_nil js
871       assert_equal "FeatureCollection", js["type"]
872       assert_equal 1, js["features"].count
873
874       get search_api_notes_path(:display_name => user.display_name, :format => "rss")
875       assert_response :success
876       assert_equal "application/rss+xml", @response.media_type
877       assert_select "rss", :count => 1 do
878         assert_select "channel", :count => 1 do
879           assert_select "item", :count => 1
880         end
881       end
882
883       get search_api_notes_path(:display_name => user.display_name, :format => "gpx")
884       assert_response :success
885       assert_equal "application/gpx+xml", @response.media_type
886       assert_select "gpx", :count => 1 do
887         assert_select "wpt", :count => 1
888       end
889     end
890
891     def test_search_by_user_success
892       user = create(:user)
893
894       create(:note) do |note|
895         create(:note_comment, :note => note, :author => user)
896       end
897
898       get search_api_notes_path(:user => user.id, :format => "xml")
899       assert_response :success
900       assert_equal "application/xml", @response.media_type
901       assert_select "osm", :count => 1 do
902         assert_select "note", :count => 1
903       end
904
905       get search_api_notes_path(:user => user.id, :format => "json")
906       assert_response :success
907       assert_equal "application/json", @response.media_type
908       js = ActiveSupport::JSON.decode(@response.body)
909       assert_not_nil js
910       assert_equal "FeatureCollection", js["type"]
911       assert_equal 1, js["features"].count
912
913       get search_api_notes_path(:user => user.id, :format => "rss")
914       assert_response :success
915       assert_equal "application/rss+xml", @response.media_type
916       assert_select "rss", :count => 1 do
917         assert_select "channel", :count => 1 do
918           assert_select "item", :count => 1
919         end
920       end
921
922       get search_api_notes_path(:user => user.id, :format => "gpx")
923       assert_response :success
924       assert_equal "application/gpx+xml", @response.media_type
925       assert_select "gpx", :count => 1 do
926         assert_select "wpt", :count => 1
927       end
928     end
929
930     def test_search_no_match
931       create(:note_with_comments)
932
933       get search_api_notes_path(:q => "no match", :format => "xml")
934       assert_response :success
935       assert_equal "application/xml", @response.media_type
936       assert_select "osm", :count => 1 do
937         assert_select "note", :count => 0
938       end
939
940       get search_api_notes_path(:q => "no match", :format => "json")
941       assert_response :success
942       assert_equal "application/json", @response.media_type
943       js = ActiveSupport::JSON.decode(@response.body)
944       assert_not_nil js
945       assert_equal "FeatureCollection", js["type"]
946       assert_equal 0, js["features"].count
947
948       get search_api_notes_path(:q => "no match", :format => "rss")
949       assert_response :success
950       assert_equal "application/rss+xml", @response.media_type
951       assert_select "rss", :count => 1 do
952         assert_select "channel", :count => 1 do
953           assert_select "item", :count => 0
954         end
955       end
956
957       get search_api_notes_path(:q => "no match", :format => "gpx")
958       assert_response :success
959       assert_equal "application/gpx+xml", @response.media_type
960       assert_select "gpx", :count => 1 do
961         assert_select "wpt", :count => 0
962       end
963     end
964
965     def test_search_by_time_no_match
966       create(:note_with_comments)
967
968       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "xml")
969       assert_response :success
970       assert_equal "application/xml", @response.media_type
971       assert_select "osm", :count => 1 do
972         assert_select "note", :count => 0
973       end
974
975       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "json")
976       assert_response :success
977       assert_equal "application/json", @response.media_type
978       js = ActiveSupport::JSON.decode(@response.body)
979       assert_not_nil js
980       assert_equal "FeatureCollection", js["type"]
981       assert_equal 0, js["features"].count
982
983       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "rss")
984       assert_response :success
985       assert_equal "application/rss+xml", @response.media_type
986       assert_select "rss", :count => 1 do
987         assert_select "channel", :count => 1 do
988           assert_select "item", :count => 0
989         end
990       end
991
992       get search_api_notes_path(:from => "01.01.2010", :to => "01.10.2010", :format => "gpx")
993       assert_response :success
994       assert_equal "application/gpx+xml", @response.media_type
995       assert_select "gpx", :count => 1 do
996         assert_select "wpt", :count => 0
997       end
998     end
999
1000     def test_search_bad_params
1001       get search_api_notes_path(:q => "no match", :limit => "0", :format => "json")
1002       assert_response :bad_request
1003
1004       get search_api_notes_path(:q => "no match", :limit => Settings.max_note_query_limit + 1, :format => "json")
1005       assert_response :bad_request
1006
1007       get search_api_notes_path(:display_name => "non-existent")
1008       assert_response :bad_request
1009
1010       get search_api_notes_path(:user => "-1")
1011       assert_response :bad_request
1012
1013       get search_api_notes_path(:from => "wrong-date", :to => "wrong-date")
1014       assert_response :bad_request
1015
1016       get search_api_notes_path(:from => "01.01.2010", :to => "2010.01.2010")
1017       assert_response :bad_request
1018     end
1019
1020     def test_feed_success
1021       position = (1.1 * GeoRecord::SCALE).to_i
1022       create(:note_with_comments, :latitude => position, :longitude => position)
1023       create(:note_with_comments, :latitude => position, :longitude => position)
1024       position = (1.5 * GeoRecord::SCALE).to_i
1025       create(:note_with_comments, :latitude => position, :longitude => position)
1026       create(:note_with_comments, :latitude => position, :longitude => position)
1027
1028       get feed_api_notes_path(:format => "rss")
1029       assert_response :success
1030       assert_equal "application/rss+xml", @response.media_type
1031       assert_select "rss", :count => 1 do
1032         assert_select "channel", :count => 1 do
1033           assert_select "item", :count => 4
1034         end
1035       end
1036
1037       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :format => "rss")
1038       assert_response :success
1039       assert_equal "application/rss+xml", @response.media_type
1040       assert_select "rss", :count => 1 do
1041         assert_select "channel", :count => 1 do
1042           assert_select "description", :text => /1\.2/, :count => 1
1043           assert_select "item", :count => 2
1044         end
1045       end
1046
1047       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :limit => Settings.max_note_query_limit, :format => "rss")
1048       assert_response :success
1049     end
1050
1051     def test_feed_fail
1052       get feed_api_notes_path(:bbox => "1,1,1.2", :format => "rss")
1053       assert_response :bad_request
1054
1055       get feed_api_notes_path(:bbox => "1,1,1.2,1.2,1.2", :format => "rss")
1056       assert_response :bad_request
1057
1058       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :limit => "0", :format => "rss")
1059       assert_response :bad_request
1060
1061       get feed_api_notes_path(:bbox => "1,1,1.2,1.2", :limit => Settings.max_note_query_limit + 1, :format => "rss")
1062       assert_response :bad_request
1063     end
1064   end
1065 end