]> git.openstreetmap.org Git - rails.git/commitdiff
Merge remote-tracking branch 'upstream/pull/1987'
authorTom Hughes <tom@compton.nu>
Mon, 10 Sep 2018 18:09:31 +0000 (19:09 +0100)
committerTom Hughes <tom@compton.nu>
Mon, 10 Sep 2018 18:09:31 +0000 (19:09 +0100)
1  2 
test/controllers/diary_entry_controller_test.rb
test/controllers/traces_controller_test.rb
test/controllers/user_controller_test.rb

index b102716d1fc1b7306a2ecbf7b3d152d01bfbc467,633e55e347add70171dd07d38ad0309c586f9658..edff9062560cb34d596a02b6e44957404c264f94
@@@ -16,23 -16,23 +16,23 @@@ class DiaryEntryControllerTest < Action
    def test_routes
      assert_routing(
        { :path => "/diary", :method => :get },
 -      { :controller => "diary_entry", :action => "list" }
 +      { :controller => "diary_entry", :action => "index" }
      )
      assert_routing(
        { :path => "/diary/language", :method => :get },
 -      { :controller => "diary_entry", :action => "list", :language => "language" }
 +      { :controller => "diary_entry", :action => "index", :language => "language" }
      )
      assert_routing(
        { :path => "/user/username/diary", :method => :get },
 -      { :controller => "diary_entry", :action => "list", :display_name => "username" }
 +      { :controller => "diary_entry", :action => "index", :display_name => "username" }
      )
      assert_routing(
        { :path => "/diary/friends", :method => :get },
 -      { :controller => "diary_entry", :action => "list", :friends => true }
 +      { :controller => "diary_entry", :action => "index", :friends => true }
      )
      assert_routing(
        { :path => "/diary/nearby", :method => :get },
 -      { :controller => "diary_entry", :action => "list", :nearby => true }
 +      { :controller => "diary_entry", :action => "index", :nearby => true }
      )
  
      assert_routing(
             :session => { :user => user.id }
      end
      assert_response :redirect
 -    assert_redirected_to :action => :list, :display_name => user.display_name
 +    assert_redirected_to :action => :index, :display_name => user.display_name
      entry = DiaryEntry.order(:id).last
      assert_equal user.id, entry.user_id
      assert_equal "New Title", entry.title
             :session => { :user => user.id }
      end
      assert_response :redirect
 -    assert_redirected_to :action => :list, :display_name => user.display_name
 +    assert_redirected_to :action => :index, :display_name => user.display_name
      entry = DiaryEntry.order(:id).last
      assert_equal user.id, entry.user_id
      assert_equal "New Title", entry.title
             :session => { :user => user.id }
      end
      assert_response :redirect
 -    assert_redirected_to :action => :list, :display_name => user.display_name
 +    assert_redirected_to :action => :index, :display_name => user.display_name
      entry = DiaryEntry.order(:id).last
      assert_equal user.id, entry.user_id
      assert_equal spammy_title, entry.title
      assert_equal "suspended", User.find(user.id).status
  
      # Follow the redirect
 -    get :list,
 +    get :index,
          :params => { :display_name => user.display_name },
          :session => { :user => user }
      assert_response :redirect
      email = ActionMailer::Base.deliveries.first
      assert_equal [user.email], email.to
      assert_equal "[OpenStreetMap] #{other_user.display_name} commented on a diary entry", email.subject
-     assert_match /New comment/, email.text_part.decoded
-     assert_match /New comment/, email.html_part.decoded
+     assert_match(/New comment/, email.text_part.decoded)
+     assert_match(/New comment/, email.html_part.decoded)
      ActionMailer::Base.deliveries.clear
      comment = DiaryComment.order(:id).last
      assert_equal entry.id, comment.diary_entry_id
      assert_equal "suspended", User.find(other_user.id).status
  
      # Follow the redirect
 -    get :list,
 +    get :index,
          :params => { :display_name => user.display_name },
          :session => { :user => other_user }
      assert_response :redirect
      assert_select ".diary-comment", :count => 0
    end
  
 -  def test_list_all
 +  def test_index_all
      diary_entry = create(:diary_entry)
      geo_entry = create(:diary_entry, :latitude => 51.50763, :longitude => -0.10781)
      public_entry = create(:diary_entry, :user => create(:user))
  
      # Try a list of all diary entries
 -    get :list
 -    check_diary_list diary_entry, geo_entry, public_entry
 +    get :index
 +    check_diary_index diary_entry, geo_entry, public_entry
    end
  
 -  def test_list_user
 +  def test_index_user
      user = create(:user)
      other_user = create(:user)
  
      _other_entry = create(:diary_entry, :user => other_user)
  
      # Try a list of diary entries for a valid user
 -    get :list, :params => { :display_name => user.display_name }
 -    check_diary_list diary_entry, geo_entry
 +    get :index, :params => { :display_name => user.display_name }
 +    check_diary_index diary_entry, geo_entry
  
      # Try a list of diary entries for an invalid user
 -    get :list, :params => { :display_name => "No Such User" }
 +    get :index, :params => { :display_name => "No Such User" }
      assert_response :not_found
      assert_template "user/no_such_user"
    end
  
 -  def test_list_friends
 +  def test_index_friends
      user = create(:user)
      other_user = create(:user)
      friend = create(:friend, :befriender => user)
      _other_entry = create(:diary_entry, :user => other_user)
  
      # Try a list of diary entries for your friends when not logged in
 -    get :list, :params => { :friends => true }
 +    get :index, :params => { :friends => true }
      assert_response :redirect
      assert_redirected_to :controller => :user, :action => :login, :referer => "/diary/friends"
  
      # Try a list of diary entries for your friends when logged in
 -    get :list, :params => { :friends => true }, :session => { :user => user }
 -    check_diary_list diary_entry
 -    get :list, :params => { :friends => true }, :session => { :user => other_user }
 -    check_diary_list
 +    get :index, :params => { :friends => true }, :session => { :user => user }
 +    check_diary_index diary_entry
 +    get :index, :params => { :friends => true }, :session => { :user => other_user }
 +    check_diary_index
    end
  
 -  def test_list_nearby
 +  def test_index_nearby
      user = create(:user, :home_lat => 12, :home_lon => 12)
      nearby_user = create(:user, :home_lat => 11.9, :home_lon => 12.1)
  
      diary_entry = create(:diary_entry, :user => user)
  
      # Try a list of diary entries for nearby users when not logged in
 -    get :list, :params => { :nearby => true }
 +    get :index, :params => { :nearby => true }
      assert_response :redirect
      assert_redirected_to :controller => :user, :action => :login, :referer => "/diary/nearby"
  
      # Try a list of diary entries for nearby users when logged in
 -    get :list, :params => { :nearby => true }, :session => { :user => nearby_user }
 -    check_diary_list diary_entry
 -    get :list, :params => { :nearby => true }, :session => { :user => user }
 -    check_diary_list
 +    get :index, :params => { :nearby => true }, :session => { :user => nearby_user }
 +    check_diary_index diary_entry
 +    get :index, :params => { :nearby => true }, :session => { :user => user }
 +    check_diary_index
    end
  
 -  def test_list_language
 +  def test_index_language
      create(:language, :code => "de")
      create(:language, :code => "sl")
      diary_entry_en = create(:diary_entry, :language_code => "en")
      diary_entry_de = create(:diary_entry, :language_code => "de")
  
      # Try a list of diary entries in english
 -    get :list, :params => { :language => "en" }
 -    check_diary_list diary_entry_en, diary_entry_en2
 +    get :index, :params => { :language => "en" }
 +    check_diary_index diary_entry_en, diary_entry_en2
  
      # Try a list of diary entries in german
 -    get :list, :params => { :language => "de" }
 -    check_diary_list diary_entry_de
 +    get :index, :params => { :language => "de" }
 +    check_diary_index diary_entry_de
  
      # Try a list of diary entries in slovenian
 -    get :list, :params => { :language => "sl" }
 -    check_diary_list
 +    get :index, :params => { :language => "sl" }
 +    check_diary_index
    end
  
 -  def test_list_paged
 +  def test_index_paged
      # Create several pages worth of diary entries
      create_list(:diary_entry, 50)
  
 -    # Try and get the list
 -    get :list
 +    # Try and get the index
 +    get :index
      assert_response :success
      assert_select "div.diary_post", :count => 20
  
      # Try and get the second page
 -    get :list, :params => { :page => 2 }
 +    get :index, :params => { :page => 2 }
      assert_response :success
      assert_select "div.diary_post", :count => 20
    end
           :params => { :display_name => user.display_name, :id => diary_entry.id },
           :session => { :user => create(:administrator_user) }
      assert_response :redirect
 -    assert_redirected_to :action => :list, :display_name => user.display_name
 +    assert_redirected_to :action => :index, :display_name => user.display_name
      assert_equal false, DiaryEntry.find(diary_entry.id).visible
    end
  
  
    private
  
 -  def check_diary_list(*entries)
 +  def check_diary_index(*entries)
      assert_response :success
 -    assert_template "list"
 +    assert_template "index"
      assert_no_missing_translations
      assert_select "div.diary_post", entries.count
  
index 7cfc468b2d9906e4fa47ba9b13bbe72a118b4428,32874d7d5722a3fe69370d365f632907e97ba7bc..add7483a329b7f20bccc449140a36ee94b65e925
@@@ -593,7 -593,7 +593,7 @@@ class TracesControllerTest < ActionCont
      post :create, :params => { :trace => { :gpx_file => file, :description => "New Trace", :tagstring => "new,trace", :visibility => "trackable" } }, :session => { :user => user }
      assert_response :redirect
      assert_redirected_to :action => :index, :display_name => user.display_name
-     assert_match /file has been uploaded/, flash[:notice]
+     assert_match(/file has been uploaded/, flash[:notice])
      trace = Trace.order(:id => :desc).first
      assert_equal "a.gpx", trace.name
      assert_equal "New Trace", trace.description
          assert_select "item", :count => traces.length do |items|
            traces.zip(items).each do |trace, item|
              assert_select item, "title", trace.name
 -            assert_select item, "link", "http://test.host/user/#{trace.user.display_name.gsub(' ', '%20')}/traces/#{trace.id}"
 -            assert_select item, "guid", "http://test.host/user/#{trace.user.display_name.gsub(' ', '%20')}/traces/#{trace.id}"
 +            assert_select item, "link", "http://test.host/user/#{ERB::Util.u(trace.user.display_name)}/traces/#{trace.id}"
 +            assert_select item, "guid", "http://test.host/user/#{ERB::Util.u(trace.user.display_name)}/traces/#{trace.id}"
              assert_select item, "description"
              # assert_select item, "dc:creator", trace.user.display_name
              assert_select item, "pubDate", trace.timestamp.rfc822
index f2aaffb9b1d3da9e0fcd32f31ad19a37b56ec608,48e8b4119b8a7c6427a556d952c153b56bdcd907..42bc1ac3f7492f1efafd7ed02f68fe2b32abddb6
@@@ -170,19 -170,19 +170,19 @@@ class UserControllerTest < ActionContro
  
      assert_routing(
        { :path => "/users", :method => :get },
 -      { :controller => "user", :action => "list" }
 +      { :controller => "user", :action => "index" }
      )
      assert_routing(
        { :path => "/users", :method => :post },
 -      { :controller => "user", :action => "list" }
 +      { :controller => "user", :action => "index" }
      )
      assert_routing(
        { :path => "/users/status", :method => :get },
 -      { :controller => "user", :action => "list", :status => "status" }
 +      { :controller => "user", :action => "index", :status => "status" }
      )
      assert_routing(
        { :path => "/users/status", :method => :post },
 -      { :controller => "user", :action => "list", :status => "status" }
 +      { :controller => "user", :action => "index", :status => "status" }
      )
    end
  
      register_email = ActionMailer::Base.deliveries.first
  
      assert_equal register_email.to[0], user.email
-     assert_match /#{@url}/, register_email.body.to_s
+     assert_match(/#{@url}/, register_email.body.to_s)
  
      # Check the page
      assert_redirected_to :action => "confirm", :display_name => user.display_name
      @request.cookies["_osm_session"] = user.display_name
      post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
      assert_redirected_to login_path
-     assert_match /Confirmed your account/, flash[:notice]
+     assert_match(/Confirmed your account/, flash[:notice])
    end
  
    def test_confirm_success_good_token_no_referer
      @request.cookies["_osm_session"] = user.display_name
      post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
      assert_redirected_to login_path
-     assert_match /Confirmed your account/, flash[:notice]
+     assert_match(/Confirmed your account/, flash[:notice])
    end
  
    def test_confirm_success_no_token_with_referer
      @request.cookies["_osm_session"] = user.display_name
      post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
      assert_redirected_to login_path(:referer => diary_new_path)
-     assert_match /Confirmed your account/, flash[:notice]
+     assert_match(/Confirmed your account/, flash[:notice])
    end
  
    def test_confirm_success_good_token_with_referer
      @request.cookies["_osm_session"] = user.display_name
      post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }, :session => { :token => token }
      assert_redirected_to login_path(:referer => diary_new_path)
-     assert_match /Confirmed your account/, flash[:notice]
+     assert_match(/Confirmed your account/, flash[:notice])
    end
  
    def test_confirm_expired_token
      @request.cookies["_osm_session"] = user.display_name
      post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
      assert_redirected_to :action => "confirm"
-     assert_match /confirmation code has expired/, flash[:error]
+     assert_match(/confirmation code has expired/, flash[:error])
    end
  
    def test_confirm_already_confirmed
      @request.cookies["_osm_session"] = user.display_name
      post :confirm, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
      assert_redirected_to :action => "login"
-     assert_match /already been confirmed/, flash[:error]
+     assert_match(/already been confirmed/, flash[:error])
    end
  
    def test_confirm_resend_success
  
      assert_response :redirect
      assert_redirected_to login_path
-     assert_match /sent a new confirmation/, flash[:notice]
+     assert_match(/sent a new confirmation/, flash[:notice])
  
      email = ActionMailer::Base.deliveries.last
  
      post :confirm_email, :params => { :confirm_string => confirm_string }
      assert_response :redirect
      assert_redirected_to :action => :account, :display_name => user.display_name
-     assert_match /Confirmed your change of email address/, flash[:notice]
+     assert_match(/Confirmed your change of email address/, flash[:notice])
    end
  
    def test_confirm_email_already_confirmed
      post :confirm_email, :params => { :confirm_string => confirm_string }
      assert_response :redirect
      assert_redirected_to :action => :account, :display_name => user.display_name
-     assert_match /already been confirmed/, flash[:error]
+     assert_match(/already been confirmed/, flash[:error])
    end
  
    def test_confirm_email_bad_token
      post :confirm_email, :params => { :confirm_string => "XXXXX" }
      assert_response :success
      assert_template :confirm_email
-     assert_match /confirmation code has expired or does not exist/, flash[:error]
+     assert_match(/confirmation code has expired or does not exist/, flash[:error])
    end
  
    ##
      post :confirm_email, :params => { :confirm_string => confirm_string }
      assert_response :redirect
      assert_redirected_to :action => :account, :display_name => user.display_name
-     assert_match /Confirmed your change of email address/, flash[:notice]
+     assert_match(/Confirmed your change of email address/, flash[:notice])
      # gravatar use should now be enabled
      assert User.find(user.id).image_use_gravatar
    end
      post :confirm_email, :params => { :confirm_string => confirm_string }
      assert_response :redirect
      assert_redirected_to :action => :account, :display_name => user.display_name
-     assert_match /Confirmed your change of email address/, flash[:notice]
+     assert_match(/Confirmed your change of email address/, flash[:notice])
      # gravatar use should now be disabled
      assert_not User.find(user.id).image_use_gravatar
    end
      end
      assert_response :redirect
      assert_redirected_to :action => :login
-     assert_match /^Sorry you lost it/, flash[:notice]
+     assert_match(/^Sorry you lost it/, flash[:notice])
      email = ActionMailer::Base.deliveries.first
      assert_equal 1, email.to.count
      assert_equal user.email, email.to.first
      end
      assert_response :redirect
      assert_redirected_to :action => :login
-     assert_match /^Sorry you lost it/, flash[:notice]
+     assert_match(/^Sorry you lost it/, flash[:notice])
      email = ActionMailer::Base.deliveries.first
      assert_equal 1, email.to.count
      assert_equal uppercase_user.email, email.to.first
      end
      assert_response :redirect
      assert_redirected_to :action => :login
-     assert_match /^Sorry you lost it/, flash[:notice]
+     assert_match(/^Sorry you lost it/, flash[:notice])
      email = ActionMailer::Base.deliveries.first
      assert_equal 1, email.to.count
      assert_equal third_user.email, email.to.first
      end
      assert_response :redirect
      assert_redirected_to :action => :login
-     assert_match /^Sorry you lost it/, flash[:notice]
+     assert_match(/^Sorry you lost it/, flash[:notice])
      email = ActionMailer::Base.deliveries.first
      assert_equal 1, email.to.count
      assert_equal third_user.email, email.to.first
      assert_difference "ActionMailer::Base.deliveries.size", 1 do
        post :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
      end
 -    assert_redirected_to user_path(:display_name => friend.display_name)
 +    assert_redirected_to user_path(friend)
-     assert_match /is now your friend/, flash[:notice]
+     assert_match(/is now your friend/, flash[:notice])
      assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
      email = ActionMailer::Base.deliveries.first
      assert_equal 1, email.to.count
      assert_no_difference "ActionMailer::Base.deliveries.size" do
        post :make_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
      end
 -    assert_redirected_to user_path(:display_name => friend.display_name)
 +    assert_redirected_to user_path(friend)
-     assert_match /You are already friends with/, flash[:warning]
+     assert_match(/You are already friends with/, flash[:warning])
      assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
    end
  
        post :make_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
      end
      assert_redirected_to "/test"
-     assert_match /is now your friend/, flash[:notice]
+     assert_match(/is now your friend/, flash[:notice])
      assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
      email = ActionMailer::Base.deliveries.first
      assert_equal 1, email.to.count
  
      # When logged in a POST should remove the friendship
      post :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
 -    assert_redirected_to user_path(:display_name => friend.display_name)
 +    assert_redirected_to user_path(friend)
-     assert_match /was removed from your friends/, flash[:notice]
+     assert_match(/was removed from your friends/, flash[:notice])
      assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
  
      # A second POST should report that the friendship does not exist
      post :remove_friend, :params => { :display_name => friend.display_name }, :session => { :user => user }
 -    assert_redirected_to user_path(:display_name => friend.display_name)
 +    assert_redirected_to user_path(friend)
-     assert_match /is not one of your friends/, flash[:error]
+     assert_match(/is not one of your friends/, flash[:error])
      assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
    end
  
      # When logged in a POST should remove the friendship and refer
      post :remove_friend, :params => { :display_name => friend.display_name, :referer => "/test" }, :session => { :user => user }
      assert_redirected_to "/test"
-     assert_match /was removed from your friends/, flash[:notice]
+     assert_match(/was removed from your friends/, flash[:notice])
      assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
    end
  
      assert_equal "deleted", user.status
    end
  
 -  def test_list_get
 +  def test_index_get
      user = create(:user)
      moderator_user = create(:moderator_user)
      administrator_user = create(:administrator_user)
      assert_equal 7, User.count
  
      # Shouldn't work when not logged in
 -    get :list
 +    get :index
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      session[:user] = user.id
  
      # Shouldn't work when logged in as a normal user
 -    get :list
 +    get :index
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      session[:user] = moderator_user.id
  
      # Shouldn't work when logged in as a moderator
 -    get :list
 +    get :index
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
  
      # Note there is a header row, so all row counts are users + 1
      # Should work when logged in as an administrator
 -    get :list
 +    get :index
      assert_response :success
 -    assert_template :list
 +    assert_template :index
      assert_select "table#user_list tr", :count => 7 + 1
  
      # Should be able to limit by status
 -    get :list, :params => { :status => "suspended" }
 +    get :index, :params => { :status => "suspended" }
      assert_response :success
 -    assert_template :list
 +    assert_template :index
      assert_select "table#user_list tr", :count => 1 + 1
  
      # Should be able to limit by IP address
 -    get :list, :params => { :ip => "1.2.3.4" }
 +    get :index, :params => { :ip => "1.2.3.4" }
      assert_response :success
 -    assert_template :list
 +    assert_template :index
      assert_select "table#user_list tr", :count => 1 + 1
    end
  
 -  def test_list_get_paginated
 +  def test_index_get_paginated
      1.upto(100).each do |n|
        User.create(:display_name => "extra_#{n}",
                    :email => "extra#{n}@example.com",
      # 100 examples, an administrator, and a granter for the admin.
      assert_equal 102, User.count
  
 -    get :list
 +    get :index
      assert_response :success
 -    assert_template :list
 +    assert_template :index
      assert_select "table#user_list tr", :count => 51
  
 -    get :list, :params => { :page => 2 }
 +    get :index, :params => { :page => 2 }
      assert_response :success
 -    assert_template :list
 +    assert_template :index
      assert_select "table#user_list tr", :count => 51
  
 -    get :list, :params => { :page => 3 }
 +    get :index, :params => { :page => 3 }
      assert_response :success
 -    assert_template :list
 +    assert_template :index
      assert_select "table#user_list tr", :count => 3
    end
  
 -  def test_list_post_confirm
 +  def test_index_post_confirm
      inactive_user = create(:user, :pending)
      suspended_user = create(:user, :suspended)
  
      # Shouldn't work when not logged in
      assert_no_difference "User.active.count" do
 -      post :list, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 +      post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
      end
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      # Shouldn't work when logged in as a normal user
      assert_no_difference "User.active.count" do
 -      post :list, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 +      post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
      end
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      # Shouldn't work when logged in as a moderator
      assert_no_difference "User.active.count" do
 -      post :list, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 +      post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
      end
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      # Should work when logged in as an administrator
      assert_difference "User.active.count", 2 do
 -      post :list, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 +      post :index, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
      end
      assert_response :redirect
 -    assert_redirected_to :action => :list
 +    assert_redirected_to :action => :index
      assert_equal "confirmed", inactive_user.reload.status
      assert_equal "confirmed", suspended_user.reload.status
    end
  
 -  def test_list_post_hide
 +  def test_index_post_hide
      normal_user = create(:user)
      confirmed_user = create(:user, :confirmed)
  
      # Shouldn't work when not logged in
      assert_no_difference "User.active.count" do
 -      post :list, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 +      post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
      end
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      # Shouldn't work when logged in as a normal user
      assert_no_difference "User.active.count" do
 -      post :list, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 +      post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
      end
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      # Shouldn't work when logged in as a moderator
      assert_no_difference "User.active.count" do
 -      post :list, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 +      post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
      end
      assert_response :redirect
      assert_redirected_to :action => :login, :referer => users_path
  
      # Should work when logged in as an administrator
      assert_difference "User.active.count", -2 do
 -      post :list, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 +      post :index, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
      end
      assert_response :redirect
 -    assert_redirected_to :action => :list
 +    assert_redirected_to :action => :index
      assert_equal "deleted", normal_user.reload.status
      assert_equal "deleted", confirmed_user.reload.status
    end