test/controllers/notes_controller_test.rb

   1 require "test_helper"
   2
   3 class NotesControllerTest < ActionDispatch::IntegrationTest
   4   def setup
   5     super
   6     # Stub nominatim response for note locations
   7     stub_request(:get, %r{^https://nominatim\.openstreetmap\.org/reverse\?})
   8       .to_return(:status => 404)
   9   end
  10
  11   ##
  12   # test all routes which lead to this controller
  13   def test_routes
  14     assert_routing(
  15       { :path => "/user/username/notes", :method => :get },
  16       { :controller => "notes", :action => "index", :display_name => "username" }
  17     )
  18     assert_routing(
  19       { :path => "/note/1", :method => :get },
  20       { :controller => "notes", :action => "show", :id => "1" }
  21     )
  22     assert_routing(
  23       { :path => "/note/new", :method => :get },
  24       { :controller => "notes", :action => "new" }
  25     )
  26   end
  27
  28   def test_index_success
  29     first_user = create(:user)
  30     second_user = create(:user)
  31     moderator_user = create(:moderator_user)
  32
  33     create(:note) do |note|
  34       create(:note_comment, :note => note, :author => first_user)
  35     end
  36     create(:note) do |note|
  37       create(:note_comment, :note => note, :author => second_user)
  38     end
  39     create(:note, :status => "hidden") do |note|
  40       create(:note_comment, :note => note, :author => second_user)
  41     end
  42
  43     get user_notes_path(first_user)
  44     assert_response :success
  45     assert_select ".content-heading a[href='#{user_path first_user}']", :text => first_user.display_name
  46     assert_select "table.note_list tbody tr", :count => 1
  47
  48     get user_notes_path(second_user)
  49     assert_response :success
  50     assert_select ".content-heading a[href='#{user_path second_user}']", :text => second_user.display_name
  51     assert_select "table.note_list tbody tr", :count => 1
  52
  53     get user_notes_path("non-existent")
  54     assert_response :not_found
  55
  56     session_for(moderator_user)
  57
  58     get user_notes_path(first_user)
  59     assert_response :success
  60     assert_select "table.note_list tbody tr", :count => 1
  61
  62     get user_notes_path(second_user)
  63     assert_response :success
  64     assert_select "table.note_list tbody tr", :count => 2
  65
  66     get user_notes_path("non-existent")
  67     assert_response :not_found
  68   end
  69
  70   def test_index_paged
  71     user = create(:user)
  72
  73     create_list(:note, 50) do |note|
  74       create(:note_comment, :note => note, :author => user)
  75     end
  76
  77     get user_notes_path(user)
  78     assert_response :success
  79     assert_select "table.note_list tbody tr", :count => 10
  80
  81     get user_notes_path(user, :page => 2)
  82     assert_response :success
  83     assert_select "table.note_list tbody tr", :count => 10
  84   end
  85
  86   def test_empty_page
  87     user = create(:user)
  88     get user_notes_path(user)
  89     assert_response :success
  90     assert_select "h4", :html => "No notes"
  91   end
  92
  93   def test_read_note
  94     open_note = create(:note_with_comments)
  95
  96     browse_check :note_path, open_note.id, "notes/show"
  97   end
  98
  99   def test_read_hidden_note
 100     hidden_note_with_comment = create(:note_with_comments, :status => "hidden")
 101
 102     get note_path(hidden_note_with_comment)
 103     assert_response :not_found
 104     assert_template "browse/not_found"
 105     assert_template :layout => "map"
 106
 107     get note_path(hidden_note_with_comment), :xhr => true
 108     assert_response :not_found
 109     assert_template "browse/not_found"
 110     assert_template :layout => "xhr"
 111
 112     session_for(create(:moderator_user))
 113
 114     browse_check :note_path, hidden_note_with_comment.id, "notes/show"
 115   end
 116
 117   def test_read_note_hidden_comments
 118     note_with_hidden_comment = create(:note_with_comments, :comments_count => 2) do |note|
 119       create(:note_comment, :note => note, :visible => false)
 120     end
 121
 122     browse_check :note_path, note_with_hidden_comment.id, "notes/show"
 123     assert_select "div.note-comments ul li", :count => 1
 124
 125     session_for(create(:moderator_user))
 126
 127     browse_check :note_path, note_with_hidden_comment.id, "notes/show"
 128     assert_select "div.note-comments ul li", :count => 2
 129   end
 130
 131   def test_read_note_hidden_user_comment
 132     hidden_user = create(:user, :deleted)
 133     note_with_hidden_user_comment = create(:note_with_comments, :comments_count => 2) do |note|
 134       create(:note_comment, :note => note, :author => hidden_user)
 135     end
 136
 137     browse_check :note_path, note_with_hidden_user_comment.id, "notes/show"
 138     assert_select "div.note-comments ul li", :count => 1
 139
 140     session_for(create(:moderator_user))
 141
 142     browse_check :note_path, note_with_hidden_user_comment.id, "notes/show"
 143     assert_select "div.note-comments ul li", :count => 1
 144   end
 145
 146   def test_read_closed_note
 147     user = create(:user)
 148     closed_note = create(:note_with_comments, :closed, :closed_by => user, :comments_count => 2)
 149
 150     browse_check :note_path, closed_note.id, "notes/show"
 151     assert_select "div.note-comments ul li", :count => 2
 152     assert_select "div.details", /Resolved by #{user.display_name}/
 153
 154     user.soft_destroy!
 155
 156     reset!
 157
 158     browse_check :note_path, closed_note.id, "notes/show"
 159     assert_select "div.note-comments ul li", :count => 1
 160     assert_select "div.details", /Resolved by deleted/
 161   end
 162
 163   def test_new_note
 164     get new_note_path
 165     assert_response :success
 166     assert_template "notes/new"
 167   end
 168
 169   private
 170
 171   # This is a convenience method for most of the above checks
 172   # First we check that when we don't have an id, it will correctly return a 404
 173   # then we check that we get the correct 404 when a non-existant id is passed
 174   # then we check that it will get a successful response, when we do pass an id
 175   def browse_check(path, id, template)
 176     path_method = method(path)
 177
 178     assert_raise ActionController::UrlGenerationError do
 179       get path_method.call
 180     end
 181
 182     assert_raise ActionController::UrlGenerationError do
 183       get path_method.call(:id => -10) # we won't have an id that's negative
 184     end
 185
 186     get path_method.call(:id => 0)
 187     assert_response :not_found
 188     assert_template "browse/not_found"
 189     assert_template :layout => "map"
 190
 191     get path_method.call(:id => 0), :xhr => true
 192     assert_response :not_found
 193     assert_template "browse/not_found"
 194     assert_template :layout => "xhr"
 195
 196     get path_method.call(:id => id)
 197     assert_response :success
 198     assert_template template
 199     assert_template :layout => "map"
 200
 201     get path_method.call(:id => id), :xhr => true
 202     assert_response :success
 203     assert_template template
 204     assert_template :layout => "xhr"
 205   end
 206 end