can [:create, :subscribe, :unsubscribe], DiaryEntry
can :update, DiaryEntry, :user => user
can [:create], DiaryComment
- can [:make_friend, :remove_friend], Friendship
+ can [:show, :create, :destroy], Follow
can [:read, :create, :mark, :unmute, :destroy], Message
can [:close, :reopen], Note
can [:read, :update], :preference
elsif @params[:bbox]
changesets = conditions_bbox(changesets, BoundingBox.from_bbox_params(params))
elsif @params[:friends] && current_user
- changesets = changesets.where(:user => current_user.friends.identifiable)
+ changesets = changesets.where(:user => current_user.followings.identifiable)
elsif @params[:nearby] && current_user
changesets = changesets.where(:user => current_user.nearby)
end
elsif params[:friends]
if current_user
@title = t ".title_followed"
- entries = DiaryEntry.where(:user => current_user.friends)
+ entries = DiaryEntry.where(:user => current_user.followings)
else
require_user
return
--- /dev/null
+class FollowsController < ApplicationController
+ include UserMethods
+
+ layout "site"
+
+ before_action :authorize_web
+ before_action :set_locale
+ before_action :check_database_readable
+
+ authorize_resource
+
+ before_action :check_database_writable
+ before_action :lookup_friend
+
+ def show
+ @already_follows = current_user.friends_with?(@friend)
+ end
+
+ def create
+ follow = Follow.new
+ follow.follower = current_user
+ follow.following = @friend
+ if current_user.friends_with?(@friend)
+ flash[:warning] = t ".already_followed", :name => @friend.display_name
+ elsif current_user.follows.where(:created_at => Time.now.utc - 1.hour..).count >= current_user.max_friends_per_hour
+ flash[:error] = t ".limit_exceeded"
+ elsif follow.save
+ flash[:notice] = t ".success", :name => @friend.display_name
+ UserMailer.friendship_notification(follow).deliver_later
+ else
+ follow.add_error(t(".failed", :name => @friend.display_name))
+ end
+
+ referer = safe_referer(params[:referer]) if params[:referer]
+
+ redirect_to referer || user_path
+ end
+
+ def destroy
+ if current_user.friends_with?(@friend)
+ Follow.where(:follower => current_user, :following => @friend).delete_all
+ flash[:notice] = t ".success", :name => @friend.display_name
+ else
+ flash[:error] = t ".not_followed", :name => @friend.display_name
+ end
+
+ referer = safe_referer(params[:referer]) if params[:referer]
+
+ redirect_to referer || user_path
+ end
+
+ private
+
+ ##
+ # ensure that there is a "friend" instance variable
+ def lookup_friend
+ @friend = User.active.find_by!(:display_name => params[:display_name])
+ rescue ActiveRecord::RecordNotFound
+ render_unknown_user params[:display_name]
+ end
+end
+++ /dev/null
-class FriendshipsController < ApplicationController
- include UserMethods
-
- layout "site"
-
- before_action :authorize_web
- before_action :set_locale
- before_action :check_database_readable
-
- authorize_resource
-
- before_action :check_database_writable, :only => [:make_friend, :remove_friend]
- before_action :lookup_friend, :only => [:make_friend, :remove_friend]
-
- def make_friend
- if request.post?
- friendship = Friendship.new
- friendship.befriender = current_user
- friendship.befriendee = @friend
- if current_user.friends_with?(@friend)
- flash[:warning] = t ".already_followed", :name => @friend.display_name
- elsif current_user.friendships.where(:created_at => Time.now.utc - 1.hour..).count >= current_user.max_friends_per_hour
- flash[:error] = t ".limit_exceeded"
- elsif friendship.save
- flash[:notice] = t ".success", :name => @friend.display_name
- UserMailer.friendship_notification(friendship).deliver_later
- else
- friendship.add_error(t(".failed", :name => @friend.display_name))
- end
-
- referer = safe_referer(params[:referer]) if params[:referer]
-
- redirect_to referer || user_path
- end
- end
-
- def remove_friend
- if request.post?
- if current_user.friends_with?(@friend)
- Friendship.where(:befriender => current_user, :befriendee => @friend).delete_all
- flash[:notice] = t ".success", :name => @friend.display_name
- else
- flash[:error] = t ".not_followed", :name => @friend.display_name
- end
-
- referer = safe_referer(params[:referer]) if params[:referer]
-
- redirect_to referer || user_path
- end
- end
-
- private
-
- ##
- # ensure that there is a "friend" instance variable
- def lookup_friend
- @friend = User.active.find_by!(:display_name => params[:display_name])
- rescue ActiveRecord::RecordNotFound
- render_unknown_user params[:display_name]
- end
-end
end
end
- def friendship_notification(friendship)
- with_recipient_locale friendship.befriendee do
- @friendship = friendship
- @viewurl = user_url(@friendship.befriender)
- @followurl = follow_url(@friendship.befriender)
- @author = @friendship.befriender.display_name
-
- attach_user_avatar(@friendship.befriender)
- mail :to => friendship.befriendee.email,
- :subject => t(".subject", :user => friendship.befriender.display_name)
+ def friendship_notification(follow)
+ with_recipient_locale follow.following do
+ @follow = follow
+ @viewurl = user_url(@follow.follower)
+ @followurl = follow_url(@follow.follower)
+ @author = @follow.follower.display_name
+
+ attach_user_avatar(@follow.follower)
+ mail :to => follow.following.email,
+ :subject => t(".subject", :user => follow.follower.display_name)
end
end
# friends_user_id_fkey (user_id => users.id)
#
-class Friendship < ApplicationRecord
+class Follow < ApplicationRecord
self.table_name = "friends"
- belongs_to :befriender, :class_name => "User", :foreign_key => :user_id
- belongs_to :befriendee, :class_name => "User", :foreign_key => :friend_user_id
+ belongs_to :follower, :class_name => "User", :foreign_key => :user_id, :inverse_of => :follows
+ belongs_to :following, :class_name => "User", :foreign_key => :friend_user_id, :inverse_of => :follows
end
has_many :new_messages, -> { where(:to_user_visible => true, :muted => false, :message_read => false).order(:sent_on => :desc) }, :class_name => "Message", :foreign_key => :to_user_id
has_many :sent_messages, -> { where(:from_user_visible => true).order(:sent_on => :desc).preload(:sender, :recipient) }, :class_name => "Message", :foreign_key => :from_user_id
has_many :muted_messages, -> { where(:to_user_visible => true, :muted => true).order(:sent_on => :desc).preload(:sender, :recipient) }, :class_name => "Message", :foreign_key => :to_user_id
- has_many :friendships, -> { joins(:befriendee).where(:users => { :status => %w[active confirmed] }) }
- has_many :friends, :through => :friendships, :source => :befriendee
+ has_many :follows, -> { joins(:following).where(:users => { :status => %w[active confirmed] }) }
+ has_many :followings, :through => :follows, :source => :following
has_many :preferences, :class_name => "UserPreference"
has_many :changesets, -> { order(:created_at => :desc) }, :inverse_of => :user
has_many :changeset_comments, :foreign_key => :author_id, :inverse_of => :author
end
def friends_with?(new_friend)
- friendships.exists?(:befriendee => new_friend)
+ follows.exists?(:following => new_friend)
end
##
def max_friends_per_hour
account_age_in_seconds = Time.now.utc - created_at
account_age_in_hours = account_age_in_seconds / 3600
- recent_friends = Friendship.where(:befriendee => self).where(:created_at => Time.now.utc - 3600..).count
+ recent_friends = Follow.where(:following => self).where(:created_at => Time.now.utc - 3600..).count
max_friends = account_age_in_hours.ceil + recent_friends - (active_reports * 10)
max_friends.clamp(0, Settings.max_friends_per_hour)
end
<li><%= link_to t("users.show.send message"), new_message_path(contact) %></li>
<li>
<% if current_user.friends_with?(contact) %>
- <%= link_to t("users.show.unfollow"), remove_friend_path(:display_name => contact.display_name, :referer => request.fullpath), :method => :post %>
+ <%= link_to t("users.show.unfollow"), follow_path(:display_name => contact.display_name, :referer => request.fullpath), :method => :delete %>
<% else %>
- <%= link_to t("users.follow"), make_friend_path(:display_name => contact.display_name, :referer => request.fullpath), :method => :post %>
+ <%= link_to t("users.follow"), follow_path(:display_name => contact.display_name, :referer => request.fullpath), :method => :post %>
<% end %>
</li>
</ul>
<%= tag.div "", :id => "map", :class => "content_map border border-secondary-subtle rounded z-0", :data => { :user => user_data } %>
<% end %>
- <% friends = @user.friends %>
+ <% friends = @user.followings %>
<% nearby = @user.nearby - friends %>
</div>
--- /dev/null
+<% content_for :heading do %>
+ <h1><%= t(@already_follows ? ".unfollow.heading" : ".follow.heading", :user => @friend.display_name) %></h1>
+<% end %>
+
+<%= link_to t(@already_follows ? ".unfollow.button" : ".follow.button"),
+ follow_path(:display_name => @friend.display_name, :referer => params[:referer]),
+ :method => (@already_follows ? :delete : :post),
+ :class => "btn btn-sm btn-primary" %>
+++ /dev/null
-<% content_for :heading do %>
- <h1><%= t ".heading", :user => @friend.display_name %></h1>
-<% end %>
-
-<%= bootstrap_form_tag do |f| %>
- <% if params[:referer] -%>
- <%= f.hidden_field :referer, :value => params[:referer] %>
- <% end -%>
- <%= f.primary t(".button") %>
-<% end %>
+++ /dev/null
-<% content_for :heading do %>
- <h1><%= t ".heading", :user => @friend.display_name %></h1>
-<% end %>
-
-<%= bootstrap_form_tag do |f| %>
- <% if params[:referer] -%>
- <%= f.hidden_field :referer, :value => params[:referer] %>
- <% end -%>
- <%= f.primary t(".button") %>
-<% end %>
-<p><%= t ".hi", :to_user => @friendship.befriendee.display_name %></p>
+<p><%= t ".hi", :to_user => @follow.following.display_name %></p>
-<p><%= t ".followed_you", :user => @friendship.befriender.display_name %></p>
+<p><%= t ".followed_you", :user => @follow.follower.display_name %></p>
<%= message_body do %>
<p><%= t ".see_their_profile_html", :userurl => link_to(@viewurl, @viewurl) %></p>
- <% unless @friendship.befriendee.friends_with?(@friendship.befriender) -%>
+ <% unless @follow.following.friends_with?(@follow.follower) -%>
<p><%= t ".follow_them_html", :followurl => link_to(@followurl, @followurl) %></p>
<% end -%>
<% end %>
-<%= t ".hi", :to_user => @friendship.befriendee.display_name %>
+<%= t ".hi", :to_user => @follow.following.display_name %>
-<%= t '.followed_you', :user => @friendship.befriender.display_name %>
+<%= t '.followed_you', :user => @follow.follower.display_name %>
<%= t '.see_their_profile', :userurl => @viewurl %>
-<% unless @friendship.befriendee.friends_with?(@friendship.befriender) -%>
+<% unless @follow.following.friends_with?(@follow.follower) -%>
<%= t '.follow_them', :followurl => @followurl %>
<% end -%>
<% if current_user %>
<li>
<% if current_user.friends_with?(@user) %>
- <%= link_to t(".unfollow"), remove_friend_path(:display_name => @user.display_name), :method => :post %>
+ <%= link_to t(".unfollow"), follow_path(:display_name => @user.display_name), :method => :delete %>
<% else %>
- <%= link_to t(".follow"), make_friend_path(:display_name => @user.display_name), :method => :post %>
+ <%= link_to t(".follow"), follow_path(:display_name => @user.display_name), :method => :post %>
<% end %>
</li>
<% end %>
not_found:
title: File not found
description: Couldn't find a file/directory/API operation by that name on the OpenStreetMap server (HTTP 404)
- friendships:
- make_friend:
- heading: "Do you want to follow %{user}?"
- button: "Follow User"
+ follows:
+ show:
+ follow:
+ heading: "Do you want to follow %{user}?"
+ button: "Follow User"
+ unfollow:
+ heading: "Do you want to unfollow %{user}?"
+ button: "Unfollow User"
+ create:
success: "You are now following %{name}!"
failed: "Sorry, your request to follow %{name} has failed."
already_followed: "You already follow %{name}."
limit_exceeded: "You have followed a lot of users recently. Please wait a while before trying to follow any more."
- remove_friend:
- heading: "Do you want to unfollow %{user}?"
- button: "Unfollow"
+ destroy:
success: "You successfully unfollowed %{name}."
not_followed: "You are not following %{name}."
geocoder:
resource :profile, :only => [:edit, :update]
# friendships
- match "/user/:display_name/make_friend" => "friendships#make_friend", :via => [:get, :post], :as => "make_friend"
- match "/user/:display_name/remove_friend" => "friendships#remove_friend", :via => [:get, :post], :as => "remove_friend"
+ scope "/user/:display_name" do
+ resource :follow, :only => [:create, :destroy, :show], :path => "follow"
+
+ get "make_friend", :to => redirect("/user/%{display_name}/follow")
+ get "remove_friend", :to => redirect("/user/%{display_name}/follow")
+ end
# user lists
namespace :users do
# 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
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
--- /dev/null
+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
+++ /dev/null
-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
--- /dev/null
+FactoryBot.define do
+ factory :follow do
+ follower :factory => :user
+ following :factory => :user
+ end
+end
+++ /dev/null
-FactoryBot.define do
- factory :friendship do
- befriender :factory => :user
- befriendee :factory => :user
- end
-end
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)
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 "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)
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"
projects / rails.git / commitdiff