]> git.openstreetmap.org Git - rails.git/blobdiff - test/controllers/user_blocks_controller_test.rb
Refactor some controller tests to use factories.
[rails.git] / test / controllers / user_blocks_controller_test.rb
index b7dcf755bdef215e2709803035e77153b564a398..a88570c6b9cbe4684d6b2d397b3becaaf75e71bc 100644 (file)
@@ -118,23 +118,25 @@ class UserBlocksControllerTest < ActionController::TestCase
   ##
   # test the new action
   def test_new
   ##
   # test the new action
   def test_new
+    target_user = create(:user)
+
     # Check that the block creation page requires us to login
     # Check that the block creation page requires us to login
-    get :new, :display_name => users(:normal_user).display_name
-    assert_redirected_to login_path(:referer => new_user_block_path(:display_name => users(:normal_user).display_name))
+    get :new, :display_name => target_user.display_name
+    assert_redirected_to login_path(:referer => new_user_block_path(:display_name => target_user.display_name))
 
     # Login as a normal user
 
     # Login as a normal user
-    session[:user] = users(:public_user).id
+    session[:user] = create(:user).id
 
     # Check that normal users can't load the block creation page
 
     # Check that normal users can't load the block creation page
-    get :new, :display_name => users(:normal_user).display_name
+    get :new, :display_name => target_user.display_name
     assert_redirected_to user_blocks_path
     assert_equal "You need to be a moderator to perform that action.", flash[:error]
 
     # Login as a moderator
     assert_redirected_to user_blocks_path
     assert_equal "You need to be a moderator to perform that action.", flash[:error]
 
     # Login as a moderator
-    session[:user] = users(:moderator_user).id
+    session[:user] = create(:moderator_user).id
 
     # Check that the block creation page loads for moderators
 
     # Check that the block creation page loads for moderators
-    get :new, :display_name => users(:normal_user).display_name
+    get :new, :display_name => target_user.display_name
     assert_response :success
     assert_select "form#new_user_block", :count => 1 do
       assert_select "textarea#user_block_reason", :count => 1
     assert_response :success
     assert_select "form#new_user_block", :count => 1 do
       assert_select "textarea#user_block_reason", :count => 1
@@ -167,7 +169,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_redirected_to login_path(:referer => edit_user_block_path(:id => active_block.id))
 
     # Login as a normal user
     assert_redirected_to login_path(:referer => edit_user_block_path(:id => active_block.id))
 
     # Login as a normal user
-    session[:user] = users(:public_user).id
+    session[:user] = create(:user).id
 
     # Check that normal users can't load the block edit page
     get :edit, :id => active_block.id
 
     # Check that normal users can't load the block edit page
     get :edit, :id => active_block.id
@@ -175,7 +177,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_equal "You need to be a moderator to perform that action.", flash[:error]
 
     # Login as a moderator
     assert_equal "You need to be a moderator to perform that action.", flash[:error]
 
     # Login as a moderator
-    session[:user] = users(:moderator_user).id
+    session[:user] = create(:moderator_user).id
 
     # Check that the block edit page loads for moderators
     get :edit, :id => active_block.id
 
     # Check that the block edit page loads for moderators
     get :edit, :id => active_block.id
@@ -202,39 +204,42 @@ class UserBlocksControllerTest < ActionController::TestCase
   ##
   # test the create action
   def test_create
   ##
   # test the create action
   def test_create
+    target_user = create(:user)
+    moderator_user = create(:moderator_user)
+
     # Not logged in yet, so creating a block should fail
     post :create
     assert_response :forbidden
 
     # Login as a normal user
     # Not logged in yet, so creating a block should fail
     post :create
     assert_response :forbidden
 
     # Login as a normal user
-    session[:user] = users(:public_user).id
+    session[:user] = create(:user).id
 
     # Check that normal users can't create blocks
     post :create
     assert_response :forbidden
 
     # Login as a moderator
 
     # Check that normal users can't create blocks
     post :create
     assert_response :forbidden
 
     # Login as a moderator
-    session[:user] = users(:moderator_user).id
+    session[:user] = moderator_user.id
 
     # A bogus block period should result in an error
     assert_no_difference "UserBlock.count" do
       post :create,
 
     # A bogus block period should result in an error
     assert_no_difference "UserBlock.count" do
       post :create,
-           :display_name => users(:unblocked_user).display_name,
+           :display_name => target_user.display_name,
            :user_block_period => "99"
     end
            :user_block_period => "99"
     end
-    assert_redirected_to new_user_block_path(:display_name => users(:unblocked_user).display_name)
+    assert_redirected_to new_user_block_path(:display_name => target_user.display_name)
     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
 
     # Check that creating a block works
     assert_difference "UserBlock.count", 1 do
       post :create,
     assert_equal "The blocking period must be one of the values selectable in the drop-down list.", flash[:error]
 
     # Check that creating a block works
     assert_difference "UserBlock.count", 1 do
       post :create,
-           :display_name => users(:unblocked_user).display_name,
+           :display_name => target_user.display_name,
            :user_block_period => "12",
            :user_block => { :needs_view => false, :reason => "Vandalism" }
     end
     id = UserBlock.order(:id).ids.last
     assert_redirected_to user_block_path(:id => id)
            :user_block_period => "12",
            :user_block => { :needs_view => false, :reason => "Vandalism" }
     end
     id = UserBlock.order(:id).ids.last
     assert_redirected_to user_block_path(:id => id)
-    assert_equal "Created a block on user #{users(:unblocked_user).display_name}.", flash[:notice]
+    assert_equal "Created a block on user #{target_user.display_name}.", flash[:notice]
     b = UserBlock.find(id)
     assert_in_delta Time.now, b.created_at, 1
     assert_in_delta Time.now, b.updated_at, 1
     b = UserBlock.find(id)
     assert_in_delta Time.now, b.created_at, 1
     assert_in_delta Time.now, b.updated_at, 1
@@ -242,7 +247,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_equal false, b.needs_view
     assert_equal "Vandalism", b.reason
     assert_equal "markdown", b.reason_format
     assert_equal false, b.needs_view
     assert_equal "Vandalism", b.reason
     assert_equal "markdown", b.reason_format
-    assert_equal users(:moderator_user).id, b.creator_id
+    assert_equal moderator_user.id, b.creator_id
 
     # We should get an error if no user is specified
     post :create
 
     # We should get an error if no user is specified
     post :create
@@ -260,21 +265,23 @@ class UserBlocksControllerTest < ActionController::TestCase
   ##
   # test the update action
   def test_update
   ##
   # test the update action
   def test_update
-    active_block = create(:user_block, :creator => users(:moderator_user))
+    moderator_user = create(:moderator_user)
+    second_moderator_user = create(:moderator_user)
+    active_block = create(:user_block, :creator => moderator_user)
 
     # Not logged in yet, so updating a block should fail
     put :update, :id => active_block.id
     assert_response :forbidden
 
     # Login as a normal user
 
     # Not logged in yet, so updating a block should fail
     put :update, :id => active_block.id
     assert_response :forbidden
 
     # Login as a normal user
-    session[:user] = users(:public_user).id
+    session[:user] = create(:user).id
 
     # Check that normal users can't update blocks
     put :update, :id => active_block.id
     assert_response :forbidden
 
     # Login as the wrong moderator
 
     # Check that normal users can't update blocks
     put :update, :id => active_block.id
     assert_response :forbidden
 
     # Login as the wrong moderator
-    session[:user] = users(:second_moderator_user).id
+    session[:user] = second_moderator_user.id
 
     # Check that only the person who created a block can update it
     assert_no_difference "UserBlock.count" do
 
     # Check that only the person who created a block can update it
     assert_no_difference "UserBlock.count" do
@@ -287,7 +294,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_equal "Only the moderator who created this block can edit it.", flash[:error]
 
     # Login as the correct moderator
     assert_equal "Only the moderator who created this block can edit it.", flash[:error]
 
     # Login as the correct moderator
-    session[:user] = users(:moderator_user).id
+    session[:user] = moderator_user.id
 
     # A bogus block period should result in an error
     assert_no_difference "UserBlock.count" do
 
     # A bogus block period should result in an error
     assert_no_difference "UserBlock.count" do
@@ -334,7 +341,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_redirected_to login_path(:referer => revoke_user_block_path(:id => active_block.id))
 
     # Login as a normal user
     assert_redirected_to login_path(:referer => revoke_user_block_path(:id => active_block.id))
 
     # Login as a normal user
-    session[:user] = users(:public_user).id
+    session[:user] = create(:user).id
 
     # Check that normal users can't load the block revoke page
     get :revoke, :id => active_block.id
 
     # Check that normal users can't load the block revoke page
     get :revoke, :id => active_block.id
@@ -342,7 +349,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_equal "You need to be a moderator to perform that action.", flash[:error]
 
     # Login as a moderator
     assert_equal "You need to be a moderator to perform that action.", flash[:error]
 
     # Login as a moderator
-    session[:user] = users(:moderator_user).id
+    session[:user] = create(:moderator_user).id
 
     # Check that the block revoke page loads for moderators
     get :revoke, :id => active_block.id
 
     # Check that the block revoke page loads for moderators
     get :revoke, :id => active_block.id
@@ -374,9 +381,12 @@ class UserBlocksControllerTest < ActionController::TestCase
   ##
   # test the blocks_on action
   def test_blocks_on
   ##
   # test the blocks_on action
   def test_blocks_on
-    active_block = create(:user_block, :user => users(:blocked_user))
-    revoked_block = create(:user_block, :revoked, :user => users(:blocked_user))
-    expired_block = create(:user_block, :expired, :user => users(:unblocked_user))
+    blocked_user = create(:user)
+    unblocked_user = create(:user)
+    normal_user = create(:user)
+    active_block = create(:user_block, :user => blocked_user)
+    revoked_block = create(:user_block, :revoked, :user => blocked_user)
+    expired_block = create(:user_block, :expired, :user => unblocked_user)
 
     # Asking for a list of blocks with no user name should fail
     assert_raise ActionController::UrlGenerationError do
 
     # Asking for a list of blocks with no user name should fail
     assert_raise ActionController::UrlGenerationError do
@@ -390,13 +400,13 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_select "h1", "The user non_existent_user does not exist"
 
     # Check the list of blocks for a user that has never been blocked
     assert_select "h1", "The user non_existent_user does not exist"
 
     # Check the list of blocks for a user that has never been blocked
-    get :blocks_on, :display_name => users(:normal_user).display_name
+    get :blocks_on, :display_name => normal_user.display_name
     assert_response :success
     assert_select "table#block_list", false
     assert_response :success
     assert_select "table#block_list", false
-    assert_select "p", "#{users(:normal_user).display_name} has not been blocked yet."
+    assert_select "p", "#{normal_user.display_name} has not been blocked yet."
 
     # Check the list of blocks for a user that is currently blocked
 
     # Check the list of blocks for a user that is currently blocked
-    get :blocks_on, :display_name => users(:blocked_user).display_name
+    get :blocks_on, :display_name => blocked_user.display_name
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 3
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 3
@@ -405,7 +415,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     end
 
     # Check the list of blocks for a user that has previously been blocked
     end
 
     # Check the list of blocks for a user that has previously been blocked
-    get :blocks_on, :display_name => users(:unblocked_user).display_name
+    get :blocks_on, :display_name => unblocked_user.display_name
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 2
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 2
@@ -416,9 +426,12 @@ class UserBlocksControllerTest < ActionController::TestCase
   ##
   # test the blocks_by action
   def test_blocks_by
   ##
   # test the blocks_by action
   def test_blocks_by
-    active_block = create(:user_block, :creator => users(:moderator_user))
-    expired_block = create(:user_block, :expired, :creator => users(:second_moderator_user))
-    revoked_block = create(:user_block, :revoked, :creator => users(:second_moderator_user))
+    moderator_user = create(:moderator_user)
+    second_moderator_user = create(:moderator_user)
+    normal_user = create(:user)
+    active_block = create(:user_block, :creator => moderator_user)
+    expired_block = create(:user_block, :expired, :creator => second_moderator_user)
+    revoked_block = create(:user_block, :revoked, :creator => second_moderator_user)
 
     # Asking for a list of blocks with no user name should fail
     assert_raise ActionController::UrlGenerationError do
 
     # Asking for a list of blocks with no user name should fail
     assert_raise ActionController::UrlGenerationError do
@@ -432,7 +445,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     assert_select "h1", "The user non_existent_user does not exist"
 
     # Check the list of blocks given by one moderator
     assert_select "h1", "The user non_existent_user does not exist"
 
     # Check the list of blocks given by one moderator
-    get :blocks_by, :display_name => users(:moderator_user).display_name
+    get :blocks_by, :display_name => moderator_user.display_name
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 2
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 2
@@ -440,7 +453,7 @@ class UserBlocksControllerTest < ActionController::TestCase
     end
 
     # Check the list of blocks given by a different moderator
     end
 
     # Check the list of blocks given by a different moderator
-    get :blocks_by, :display_name => users(:second_moderator_user).display_name
+    get :blocks_by, :display_name => second_moderator_user.display_name
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 3
     assert_response :success
     assert_select "table#block_list", :count => 1 do
       assert_select "tr", 3
@@ -449,9 +462,9 @@ class UserBlocksControllerTest < ActionController::TestCase
     end
 
     # Check the list of blocks (not) given by a normal user
     end
 
     # Check the list of blocks (not) given by a normal user
-    get :blocks_by, :display_name => users(:normal_user).display_name
+    get :blocks_by, :display_name => normal_user.display_name
     assert_response :success
     assert_select "table#block_list", false
     assert_response :success
     assert_select "table#block_list", false
-    assert_select "p", "#{users(:normal_user).display_name} has not made any blocks yet."
+    assert_select "p", "#{normal_user.display_name} has not made any blocks yet."
   end
 end
   end
 end