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