Refactor friendships controller and model

test/controllers/changesets_controller_test.rb

@@ -190,8 +190,8 @@ class ChangesetsControllerTest < ActionDispatch::IntegrationTest
   # Checks the display of the friends changesets listing
   def test_index_friends
     private_user = create(:user, :data_public => true)
-    friendship = create(:friendship, :befriender => private_user)
-    changeset = create(:changeset, :user => friendship.befriendee, :num_changes => 1)
+    follow = create(:follow, :follower => private_user)
+    changeset = create(:changeset, :user => follow.following, :num_changes => 1)
     _changeset2 = create(:changeset, :user => create(:user), :num_changes => 1)
 
     get friend_changesets_path

test/controllers/diary_entries_controller_test.rb

@@ -384,8 +384,8 @@ class DiaryEntriesControllerTest < ActionDispatch::IntegrationTest
   def test_index_friends
     user = create(:user)
     other_user = create(:user)
-    friendship = create(:friendship, :befriender => user)
-    diary_entry = create(:diary_entry, :user => friendship.befriendee)
+    follow = create(:follow, :follower => user)
+    diary_entry = create(:diary_entry, :user => follow.following)
     _other_entry = create(:diary_entry, :user => other_user)
 
     # Try a list of diary entries for your friends when not logged in

test/controllers/follows_controller_test.rb

@@ -0,0 +1,182 @@
+require "test_helper"
+
+class FollowsControllerTest < ActionDispatch::IntegrationTest
+  ##
+  # test all routes which lead to this controller
+  def test_routes
+    assert_routing(
+      { :path => "/user/username/follow", :method => :get },
+      { :controller => "follows", :action => "show", :display_name => "username" }
+    )
+    assert_routing(
+      { :path => "/user/username/follow", :method => :post },
+      { :controller => "follows", :action => "create", :display_name => "username" }
+    )
+    assert_routing(
+      { :path => "/user/username/follow", :method => :delete },
+      { :controller => "follows", :action => "destroy", :display_name => "username" }
+    )
+  end
+
+  def test_follow
+    # Get users to work with
+    user = create(:user)
+    follow = create(:user)
+
+    # Check that the users aren't already friends
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+
+    # When not logged in a GET should ask us to login
+    get follow_path(follow)
+    assert_redirected_to login_path(:referer => follow_path(follow))
+
+    # When not logged in a POST should error
+    post follow_path(follow)
+    assert_response :forbidden
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+
+    session_for(user)
+
+    # When logged in a GET should get a confirmation page
+    get follow_path(follow)
+    assert_response :success
+    assert_template :show
+    assert_select "a[href*='test']", 0
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+
+    # When logged in a POST should add the follow
+    assert_difference "ActionMailer::Base.deliveries.size", 1 do
+      perform_enqueued_jobs do
+        post follow_path(follow)
+      end
+    end
+    assert_redirected_to user_path(follow)
+    assert_match(/You are now following/, flash[:notice])
+    assert Follow.find_by(:follower => user, :following => follow)
+    email = ActionMailer::Base.deliveries.first
+    assert_equal 1, email.to.count
+    assert_equal follow.email, email.to.first
+    ActionMailer::Base.deliveries.clear
+
+    # A second POST should report that the follow already exists
+    assert_no_difference "ActionMailer::Base.deliveries.size" do
+      perform_enqueued_jobs do
+        post follow_path(follow)
+      end
+    end
+    assert_redirected_to user_path(follow)
+    assert_match(/You already follow/, flash[:warning])
+    assert Follow.find_by(:follower => user, :following => follow)
+  end
+
+  def test_follow_with_referer
+    # Get users to work with
+    user = create(:user)
+    follow = create(:user)
+    session_for(user)
+
+    # Check that the users aren't already friends
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+
+    # The GET should preserve any referer
+    get follow_path(follow), :params => { :referer => "/test" }
+    assert_response :success
+    assert_template :show
+    assert_select "a[href*='test']"
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+
+    # When logged in a POST should add the follow and refer us
+    assert_difference "ActionMailer::Base.deliveries.size", 1 do
+      perform_enqueued_jobs do
+        post follow_path(follow), :params => { :referer => "/test" }
+      end
+    end
+    assert_redirected_to "/test"
+    assert_match(/You are now following/, flash[:notice])
+    assert Follow.find_by(:follower => user, :following => follow)
+    email = ActionMailer::Base.deliveries.first
+    assert_equal 1, email.to.count
+    assert_equal follow.email, email.to.first
+    ActionMailer::Base.deliveries.clear
+  end
+
+  def test_follow_unknown_user
+    # Should error when a bogus user is specified
+    session_for(create(:user))
+    get follow_path("No Such User")
+    assert_response :not_found
+    assert_template :no_such_user
+  end
+
+  def test_unfollow
+    # Get users to work with
+    user = create(:user)
+    follow = create(:user)
+    create(:follow, :follower => user, :following => follow)
+
+    # Check that the users are friends
+    assert Follow.find_by(:follower => user, :following => follow)
+
+    # When not logged in a GET should ask us to login
+    get follow_path(follow)
+    assert_redirected_to login_path(:referer => follow_path(follow))
+
+    # When not logged in a POST should error
+    delete follow_path, :params => { :display_name => follow.display_name }
+    assert_response :forbidden
+    assert Follow.find_by(:follower => user, :following => follow)
+
+    session_for(user)
+
+    # When logged in a GET should get a confirmation page
+    get follow_path(follow)
+    assert_response :success
+    assert_template :show
+    assert_select "a[href*='test']", 0
+    assert Follow.find_by(:follower => user, :following => follow)
+
+    # When logged in a DELETE should remove the follow
+    delete follow_path(follow)
+    assert_redirected_to user_path(follow)
+    assert_match(/You successfully unfollowed/, flash[:notice])
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+
+    # A second DELETE should report that the follow does not exist
+    delete follow_path(follow)
+    assert_redirected_to user_path(follow)
+    assert_match(/You are not following/, flash[:error])
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+  end
+
+  def test_unfollow_with_referer
+    # Get users to work with
+    user = create(:user)
+    follow = create(:user)
+    create(:follow, :follower => user, :following => follow)
+    session_for(user)
+
+    # Check that the users are friends
+    assert Follow.find_by(:follower => user, :following => follow)
+
+    # The GET should preserve any referer
+    get follow_path(follow), :params => { :referer => "/test" }
+    assert_response :success
+    assert_template :show
+    assert_select "a[href*='test']"
+    assert Follow.find_by(:follower => user, :following => follow)
+
+    # When logged in a POST should remove the follow and refer
+    delete follow_path(follow), :params => { :referer => "/test" }
+    assert_redirected_to "/test"
+    assert_match(/You successfully unfollowed/, flash[:notice])
+    assert_nil Follow.find_by(:follower => user, :following => follow)
+  end
+
+  def test_unfollow_unknown_user
+    # Should error when a bogus user is specified
+    session_for(create(:user))
+    get follow_path("No Such User")
+    assert_response :not_found
+    assert_template :no_such_user
+  end
+end

test/controllers/friendships_controller_test.rb

@@ -1,198 +0,0 @@
-require "test_helper"
-
-class FriendshipsControllerTest < ActionDispatch::IntegrationTest
-  ##
-  # test all routes which lead to this controller
-  def test_routes
-    assert_routing(
-      { :path => "/user/username/follow", :method => :get },
-      { :controller => "friendships", :action => "follow", :display_name => "username" }
-    )
-    assert_routing(
-      { :path => "/user/username/follow", :method => :post },
-      { :controller => "friendships", :action => "follow", :display_name => "username" }
-    )
-    assert_routing(
-      { :path => "/user/username/unfollow", :method => :get },
-      { :controller => "friendships", :action => "unfollow", :display_name => "username" }
-    )
-    assert_routing(
-      { :path => "/user/username/unfollow", :method => :post },
-      { :controller => "friendships", :action => "unfollow", :display_name => "username" }
-    )
-  end
-
-  def test_follow
-    # Get users to work with
-    user = create(:user)
-    friend = create(:user)
-
-    # Check that the users aren't already friends
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # When not logged in a GET should ask us to login
-    get make_friend_path(friend)
-    assert_redirected_to login_path(:referer => make_friend_path(friend))
-
-    # When not logged in a POST should error
-    post make_friend_path(friend)
-    assert_response :forbidden
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    session_for(user)
-
-    # When logged in a GET should get a confirmation page
-    get make_friend_path(friend)
-    assert_response :success
-    assert_template :follow
-    assert_select "form" do
-      assert_select "input[type='hidden'][name='referer']", 0
-      assert_select "input[type='submit']", 1
-    end
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # When logged in a POST should add the friendship
-    assert_difference "ActionMailer::Base.deliveries.size", 1 do
-      perform_enqueued_jobs do
-        post make_friend_path(friend)
-      end
-    end
-    assert_redirected_to user_path(friend)
-    assert_match(/You are now following/, flash[:notice])
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-    email = ActionMailer::Base.deliveries.first
-    assert_equal 1, email.to.count
-    assert_equal friend.email, email.to.first
-    ActionMailer::Base.deliveries.clear
-
-    # A second POST should report that the friendship already exists
-    assert_no_difference "ActionMailer::Base.deliveries.size" do
-      perform_enqueued_jobs do
-        post make_friend_path(friend)
-      end
-    end
-    assert_redirected_to user_path(friend)
-    assert_match(/You already follow/, flash[:warning])
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-  end
-
-  def test_follow_with_referer
-    # Get users to work with
-    user = create(:user)
-    friend = create(:user)
-    session_for(user)
-
-    # Check that the users aren't already friends
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # The GET should preserve any referer
-    get make_friend_path(friend), :params => { :referer => "/test" }
-    assert_response :success
-    assert_template :follow
-    assert_select "form" do
-      assert_select "input[type='hidden'][name='referer'][value='/test']", 1
-      assert_select "input[type='submit']", 1
-    end
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # When logged in a POST should add the friendship and refer us
-    assert_difference "ActionMailer::Base.deliveries.size", 1 do
-      perform_enqueued_jobs do
-        post make_friend_path(friend), :params => { :referer => "/test" }
-      end
-    end
-    assert_redirected_to "/test"
-    assert_match(/You are now following/, flash[:notice])
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-    email = ActionMailer::Base.deliveries.first
-    assert_equal 1, email.to.count
-    assert_equal friend.email, email.to.first
-    ActionMailer::Base.deliveries.clear
-  end
-
-  def test_follow_unknown_user
-    # Should error when a bogus user is specified
-    session_for(create(:user))
-    get make_friend_path("No Such User")
-    assert_response :not_found
-    assert_template :no_such_user
-  end
-
-  def test_unfollow
-    # Get users to work with
-    user = create(:user)
-    friend = create(:user)
-    create(:friendship, :befriender => user, :befriendee => friend)
-
-    # Check that the users are friends
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # When not logged in a GET should ask us to login
-    get remove_friend_path(friend)
-    assert_redirected_to login_path(:referer => remove_friend_path(friend))
-
-    # When not logged in a POST should error
-    post remove_friend_path, :params => { :display_name => friend.display_name }
-    assert_response :forbidden
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    session_for(user)
-
-    # When logged in a GET should get a confirmation page
-    get remove_friend_path(friend)
-    assert_response :success
-    assert_template :unfollow
-    assert_select "form" do
-      assert_select "input[type='hidden'][name='referer']", 0
-      assert_select "input[type='submit']", 1
-    end
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # When logged in a POST should remove the friendship
-    post remove_friend_path(friend)
-    assert_redirected_to user_path(friend)
-    assert_match(/You successfully unfollowed/, flash[:notice])
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # A second POST should report that the friendship does not exist
-    post remove_friend_path(friend)
-    assert_redirected_to user_path(friend)
-    assert_match(/You are not following/, flash[:error])
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-  end
-
-  def test_unfollow_with_referer
-    # Get users to work with
-    user = create(:user)
-    friend = create(:user)
-    create(:friendship, :befriender => user, :befriendee => friend)
-    session_for(user)
-
-    # Check that the users are friends
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # The GET should preserve any referer
-    get remove_friend_path(friend), :params => { :referer => "/test" }
-    assert_response :success
-    assert_template :unfollow
-    assert_select "form" do
-      assert_select "input[type='hidden'][name='referer'][value='/test']", 1
-      assert_select "input[type='submit']", 1
-    end
-    assert Friendship.find_by(:befriender => user, :befriendee => friend)
-
-    # When logged in a POST should remove the friendship and refer
-    post remove_friend_path(friend), :params => { :referer => "/test" }
-    assert_redirected_to "/test"
-    assert_match(/You successfully unfollowed/, flash[:notice])
-    assert_nil Friendship.find_by(:befriender => user, :befriendee => friend)
-  end
-
-  def test_unfollow_unknown_user
-    # Should error when a bogus user is specified
-    session_for(create(:user))
-    get remove_friend_path("No Such User")
-    assert_response :not_found
-    assert_template :no_such_user
-  end
-end

test/factories/follows.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :follow do
+    follower :factory => :user
+    following :factory => :user
+  end
+end

test/factories/friendships.rb

@@ -1,6 +0,0 @@
-FactoryBot.define do
-  factory :friendship do
-    befriender :factory => :user
-    befriendee :factory => :user
-  end
-end

test/models/user_test.rb

@@ -140,7 +140,7 @@ class UserTest < ActiveSupport::TestCase
     alice = create(:user, :active)
     bob = create(:user, :active)
     charlie = create(:user, :active)
-    create(:friendship, :befriender => alice, :befriendee => bob)
+    create(:follow, :follower => alice, :following => bob)
 
     assert alice.friends_with?(bob)
     assert_not alice.friends_with?(charlie)
@@ -174,13 +174,13 @@ class UserTest < ActiveSupport::TestCase
   def test_friends
     norm = create(:user, :active)
     sec = create(:user, :active)
-    create(:friendship, :befriender => norm, :befriendee => sec)
+    create(:follow, :follower => norm, :following => sec)
 
-    assert_equal [sec], norm.friends
-    assert_equal 1, norm.friends.size
+    assert_equal [sec], norm.followings
+    assert_equal 1, norm.followings.size
 
-    assert_empty sec.friends
-    assert_equal 0, sec.friends.size
+    assert_empty sec.followings
+    assert_equal 0, sec.followings.size
   end
 
   def test_user_preferred_editor

test/system/dashboard_test.rb

@@ -12,7 +12,7 @@ class DashboardSystemTest < ApplicationSystemTestCase
   test "show users if have friends" do
     user = create(:user, :home_lon => 1.1, :home_lat => 1.1)
     friend_user = create(:user, :home_lon => 1.2, :home_lat => 1.2)
-    create(:friendship, :befriender => user, :befriendee => friend_user)
+    create(:follow, :follower => user, :following => friend_user)
     create(:changeset, :user => friend_user)
     sign_in_as(user)
 

test/system/follows_test.rb

@@ -1,13 +1,13 @@
 require "application_system_test_case"
 
-class FriendshipsTest < ApplicationSystemTestCase
+class FollowsTest < ApplicationSystemTestCase
   test "show message when max frienships limit is exceeded" do
-    befriendee = create(:user)
+    following = create(:user)
 
     sign_in_as create(:user)
 
     with_settings(:max_friends_per_hour => 0) do
-      visit user_path(befriendee)
+      visit user_path(following)
       assert_link "Follow"
 
       click_on "Follow"