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