test/controllers/notes_controller_test.rb

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