FollowingRelationship storage & performance optimizations See merge request pleroma/pleroma!2332tags/v2.0.3^2
@@ -4,10 +4,16 @@ | |||
import EctoEnum | |||
defenum(UserRelationshipTypeEnum, | |||
defenum(Pleroma.UserRelationship.Type, | |||
block: 1, | |||
mute: 2, | |||
reblog_mute: 3, | |||
notification_mute: 4, | |||
inverse_subscription: 5 | |||
) | |||
defenum(Pleroma.FollowingRelationship.State, | |||
follow_pending: 1, | |||
follow_accept: 2, | |||
follow_reject: 3 | |||
) |
@@ -8,12 +8,13 @@ defmodule Pleroma.FollowingRelationship do | |||
import Ecto.Changeset | |||
import Ecto.Query | |||
alias Ecto.Changeset | |||
alias FlakeId.Ecto.CompatType | |||
alias Pleroma.Repo | |||
alias Pleroma.User | |||
schema "following_relationships" do | |||
field(:state, :string, default: "accept") | |||
field(:state, Pleroma.FollowingRelationship.State, default: :follow_pending) | |||
belongs_to(:follower, User, type: CompatType) | |||
belongs_to(:following, User, type: CompatType) | |||
@@ -27,6 +28,18 @@ defmodule Pleroma.FollowingRelationship do | |||
|> put_assoc(:follower, attrs.follower) | |||
|> put_assoc(:following, attrs.following) | |||
|> validate_required([:state, :follower, :following]) | |||
|> unique_constraint(:follower_id, | |||
name: :following_relationships_follower_id_following_id_index | |||
) | |||
|> validate_not_self_relationship() | |||
end | |||
def state_to_enum(state) when state in ["pending", "accept", "reject"] do | |||
String.to_existing_atom("follow_#{state}") | |||
end | |||
def state_to_enum(state) do | |||
raise "State is not convertible to Pleroma.FollowingRelationship.State: #{state}" | |||
end | |||
def get(%User{} = follower, %User{} = following) do | |||
@@ -35,7 +48,7 @@ defmodule Pleroma.FollowingRelationship do | |||
|> Repo.one() | |||
end | |||
def update(follower, following, "reject"), do: unfollow(follower, following) | |||
def update(follower, following, :follow_reject), do: unfollow(follower, following) | |||
def update(%User{} = follower, %User{} = following, state) do | |||
case get(follower, following) do | |||
@@ -50,7 +63,7 @@ defmodule Pleroma.FollowingRelationship do | |||
end | |||
end | |||
def follow(%User{} = follower, %User{} = following, state \\ "accept") do | |||
def follow(%User{} = follower, %User{} = following, state \\ :follow_accept) do | |||
%__MODULE__{} | |||
|> changeset(%{follower: follower, following: following, state: state}) | |||
|> Repo.insert(on_conflict: :nothing) | |||
@@ -80,7 +93,7 @@ defmodule Pleroma.FollowingRelationship do | |||
def get_follow_requests(%User{id: id}) do | |||
__MODULE__ | |||
|> join(:inner, [r], f in assoc(r, :follower)) | |||
|> where([r], r.state == "pending") | |||
|> where([r], r.state == ^:follow_pending) | |||
|> where([r], r.following_id == ^id) | |||
|> select([r, f], f) | |||
|> Repo.all() | |||
@@ -88,7 +101,7 @@ defmodule Pleroma.FollowingRelationship do | |||
def following?(%User{id: follower_id}, %User{id: followed_id}) do | |||
__MODULE__ | |||
|> where(follower_id: ^follower_id, following_id: ^followed_id, state: "accept") | |||
|> where(follower_id: ^follower_id, following_id: ^followed_id, state: ^:follow_accept) | |||
|> Repo.exists?() | |||
end | |||
@@ -97,7 +110,7 @@ defmodule Pleroma.FollowingRelationship do | |||
__MODULE__ | |||
|> join(:inner, [r], u in User, on: r.following_id == u.id) | |||
|> where([r], r.follower_id == ^user.id) | |||
|> where([r], r.state == "accept") | |||
|> where([r], r.state == ^:follow_accept) | |||
|> select([r, u], u.follower_address) | |||
|> Repo.all() | |||
@@ -129,4 +142,58 @@ defmodule Pleroma.FollowingRelationship do | |||
move_following(origin, target) | |||
end | |||
end | |||
def all_between_user_sets( | |||
source_users, | |||
target_users | |||
) | |||
when is_list(source_users) and is_list(target_users) do | |||
source_user_ids = User.binary_id(source_users) | |||
target_user_ids = User.binary_id(target_users) | |||
__MODULE__ | |||
|> where( | |||
fragment( | |||
"(follower_id = ANY(?) AND following_id = ANY(?)) OR \ | |||
(follower_id = ANY(?) AND following_id = ANY(?))", | |||
^source_user_ids, | |||
^target_user_ids, | |||
^target_user_ids, | |||
^source_user_ids | |||
) | |||
) | |||
|> Repo.all() | |||
end | |||
def find(following_relationships, follower, following) do | |||
Enum.find(following_relationships, fn | |||
fr -> fr.follower_id == follower.id and fr.following_id == following.id | |||
end) | |||
end | |||
defp validate_not_self_relationship(%Changeset{} = changeset) do | |||
changeset | |||
|> validate_follower_id_following_id_inequality() | |||
|> validate_following_id_follower_id_inequality() | |||
end | |||
defp validate_follower_id_following_id_inequality(%Changeset{} = changeset) do | |||
validate_change(changeset, :follower_id, fn _, follower_id -> | |||
if follower_id == get_field(changeset, :following_id) do | |||
[source_id: "can't be equal to following_id"] | |||
else | |||
[] | |||
end | |||
end) | |||
end | |||
defp validate_following_id_follower_id_inequality(%Changeset{} = changeset) do | |||
validate_change(changeset, :following_id, fn _, following_id -> | |||
if following_id == get_field(changeset, :follower_id) do | |||
[target_id: "can't be equal to follower_id"] | |||
else | |||
[] | |||
end | |||
end) | |||
end | |||
end |
@@ -227,6 +227,24 @@ defmodule Pleroma.User do | |||
end | |||
end | |||
@doc """ | |||
Dumps Flake Id to SQL-compatible format (16-byte UUID). | |||
E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>> | |||
""" | |||
def binary_id(source_id) when is_binary(source_id) do | |||
with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do | |||
dumped_id | |||
else | |||
_ -> source_id | |||
end | |||
end | |||
def binary_id(source_ids) when is_list(source_ids) do | |||
Enum.map(source_ids, &binary_id/1) | |||
end | |||
def binary_id(%User{} = user), do: binary_id(user.id) | |||
@doc "Returns status account" | |||
@spec account_status(User.t()) :: account_status() | |||
def account_status(%User{deactivated: true}), do: :deactivated | |||
@@ -689,7 +707,7 @@ defmodule Pleroma.User do | |||
@spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} | {:error, String.t()} | |||
def maybe_direct_follow(%User{} = follower, %User{local: true, locked: true} = followed) do | |||
follow(follower, followed, "pending") | |||
follow(follower, followed, :follow_pending) | |||
end | |||
def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do | |||
@@ -709,14 +727,14 @@ defmodule Pleroma.User do | |||
def follow_all(follower, followeds) do | |||
followeds | |||
|> Enum.reject(fn followed -> blocks?(follower, followed) || blocks?(followed, follower) end) | |||
|> Enum.each(&follow(follower, &1, "accept")) | |||
|> Enum.each(&follow(follower, &1, :follow_accept)) | |||
set_cache(follower) | |||
end | |||
defdelegate following(user), to: FollowingRelationship | |||
def follow(%User{} = follower, %User{} = followed, state \\ "accept") do | |||
def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do | |||
deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked]) | |||
cond do | |||
@@ -743,7 +761,7 @@ defmodule Pleroma.User do | |||
def unfollow(%User{} = follower, %User{} = followed) do | |||
case get_follow_state(follower, followed) do | |||
state when state in ["accept", "pending"] -> | |||
state when state in [:follow_pending, :follow_accept] -> | |||
FollowingRelationship.unfollow(follower, followed) | |||
{:ok, followed} = update_follower_count(followed) | |||
@@ -761,14 +779,18 @@ defmodule Pleroma.User do | |||
defdelegate following?(follower, followed), to: FollowingRelationship | |||
@doc "Returns follow state as Pleroma.FollowingRelationship.State value" | |||
def get_follow_state(%User{} = follower, %User{} = following) do | |||
following_relationship = FollowingRelationship.get(follower, following) | |||
case {following_relationship, following.local} do | |||
{nil, false} -> | |||
case Utils.fetch_latest_follow(follower, following) do | |||
%{data: %{"state" => state}} when state in ["pending", "accept"] -> state | |||
_ -> nil | |||
%Activity{data: %{"state" => state}} when state in ["pending", "accept"] -> | |||
FollowingRelationship.state_to_enum(state) | |||
_ -> | |||
nil | |||
end | |||
{%{state: state}, _} -> | |||
@@ -1267,7 +1289,7 @@ defmodule Pleroma.User do | |||
def blocks?(%User{} = user, %User{} = target) do | |||
blocks_user?(user, target) || | |||
(!User.following?(user, target) && blocks_domain?(user, target)) | |||
(blocks_domain?(user, target) and not User.following?(user, target)) | |||
end | |||
def blocks_user?(%User{} = user, %User{} = target) do | |||
@@ -148,7 +148,7 @@ defmodule Pleroma.User.Query do | |||
as: :relationships, | |||
on: r.following_id == ^id and r.follower_id == u.id | |||
) | |||
|> where([relationships: r], r.state == "accept") | |||
|> where([relationships: r], r.state == ^:follow_accept) | |||
end | |||
defp compose_query({:friends, %User{id: id}}, query) do | |||
@@ -158,7 +158,7 @@ defmodule Pleroma.User.Query do | |||
as: :relationships, | |||
on: r.following_id == u.id and r.follower_id == ^id | |||
) | |||
|> where([relationships: r], r.state == "accept") | |||
|> where([relationships: r], r.state == ^:follow_accept) | |||
end | |||
defp compose_query({:recipients_from_activity, to}, query) do | |||
@@ -173,7 +173,7 @@ defmodule Pleroma.User.Query do | |||
) | |||
|> where( | |||
[u, following: f, relationships: r], | |||
u.ap_id in ^to or (f.follower_address in ^to and r.state == "accept") | |||
u.ap_id in ^to or (f.follower_address in ^to and r.state == ^:follow_accept) | |||
) | |||
|> distinct(true) | |||
end | |||
@@ -8,6 +8,8 @@ defmodule Pleroma.UserRelationship do | |||
import Ecto.Changeset | |||
import Ecto.Query | |||
alias Ecto.Changeset | |||
alias Pleroma.FollowingRelationship | |||
alias Pleroma.Repo | |||
alias Pleroma.User | |||
alias Pleroma.UserRelationship | |||
@@ -15,12 +17,12 @@ defmodule Pleroma.UserRelationship do | |||
schema "user_relationships" do | |||
belongs_to(:source, User, type: FlakeId.Ecto.CompatType) | |||
belongs_to(:target, User, type: FlakeId.Ecto.CompatType) | |||
field(:relationship_type, UserRelationshipTypeEnum) | |||
field(:relationship_type, Pleroma.UserRelationship.Type) | |||
timestamps(updated_at: false) | |||
end | |||
for relationship_type <- Keyword.keys(UserRelationshipTypeEnum.__enum_map__()) do | |||
for relationship_type <- Keyword.keys(Pleroma.UserRelationship.Type.__enum_map__()) do | |||
# `def create_block/2`, `def create_mute/2`, `def create_reblog_mute/2`, | |||
# `def create_notification_mute/2`, `def create_inverse_subscription/2` | |||
def unquote(:"create_#{relationship_type}")(source, target), | |||
@@ -37,6 +39,10 @@ defmodule Pleroma.UserRelationship do | |||
do: exists?(unquote(relationship_type), source, target) | |||
end | |||
def user_relationship_types, do: Keyword.keys(user_relationship_mappings()) | |||
def user_relationship_mappings, do: Pleroma.UserRelationship.Type.__enum_map__() | |||
def changeset(%UserRelationship{} = user_relationship, params \\ %{}) do | |||
user_relationship | |||
|> cast(params, [:relationship_type, :source_id, :target_id]) | |||
@@ -75,18 +81,93 @@ defmodule Pleroma.UserRelationship do | |||
end | |||
end | |||
defp validate_not_self_relationship(%Ecto.Changeset{} = changeset) do | |||
def dictionary( | |||
source_users, | |||
target_users, | |||
source_to_target_rel_types \\ nil, | |||
target_to_source_rel_types \\ nil | |||
) | |||
when is_list(source_users) and is_list(target_users) do | |||
source_user_ids = User.binary_id(source_users) | |||
target_user_ids = User.binary_id(target_users) | |||
get_rel_type_codes = fn rel_type -> user_relationship_mappings()[rel_type] end | |||
source_to_target_rel_types = | |||
Enum.map(source_to_target_rel_types || user_relationship_types(), &get_rel_type_codes.(&1)) | |||
target_to_source_rel_types = | |||
Enum.map(target_to_source_rel_types || user_relationship_types(), &get_rel_type_codes.(&1)) | |||
__MODULE__ | |||
|> where( | |||
fragment( | |||
"(source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?)) OR \ | |||
(source_id = ANY(?) AND target_id = ANY(?) AND relationship_type = ANY(?))", | |||
^source_user_ids, | |||
^target_user_ids, | |||
^source_to_target_rel_types, | |||
^target_user_ids, | |||
^source_user_ids, | |||
^target_to_source_rel_types | |||
) | |||
) | |||
|> select([ur], [ur.relationship_type, ur.source_id, ur.target_id]) | |||
|> Repo.all() | |||
end | |||
def exists?(dictionary, rel_type, source, target, func) do | |||
cond do | |||
is_nil(source) or is_nil(target) -> | |||
false | |||
dictionary -> | |||
[rel_type, source.id, target.id] in dictionary | |||
true -> | |||
func.(source, target) | |||
end | |||
end | |||
@doc ":relationships option for StatusView / AccountView / NotificationView" | |||
def view_relationships_option(nil = _reading_user, _actors) do | |||
%{user_relationships: [], following_relationships: []} | |||
end | |||
def view_relationships_option(%User{} = reading_user, actors) do | |||
user_relationships = | |||
UserRelationship.dictionary( | |||
[reading_user], | |||
actors, | |||
[:block, :mute, :notification_mute, :reblog_mute], | |||
[:block, :inverse_subscription] | |||
) | |||
following_relationships = FollowingRelationship.all_between_user_sets([reading_user], actors) | |||
%{user_relationships: user_relationships, following_relationships: following_relationships} | |||
end | |||
defp validate_not_self_relationship(%Changeset{} = changeset) do | |||
changeset | |||
|> validate_change(:target_id, fn _, target_id -> | |||
if target_id == get_field(changeset, :source_id) do | |||
[target_id: "can't be equal to source_id"] | |||
|> validate_source_id_target_id_inequality() | |||
|> validate_target_id_source_id_inequality() | |||
end | |||
defp validate_source_id_target_id_inequality(%Changeset{} = changeset) do | |||
validate_change(changeset, :source_id, fn _, source_id -> | |||
if source_id == get_field(changeset, :target_id) do | |||
[source_id: "can't be equal to target_id"] | |||
else | |||
[] | |||
end | |||
end) | |||
|> validate_change(:source_id, fn _, source_id -> | |||
if source_id == get_field(changeset, :target_id) do | |||
[source_id: "can't be equal to target_id"] | |||
end | |||
defp validate_target_id_source_id_inequality(%Changeset{} = changeset) do | |||
validate_change(changeset, :target_id, fn _, target_id -> | |||
if target_id == get_field(changeset, :source_id) do | |||
[target_id: "can't be equal to source_id"] | |||
else | |||
[] | |||
end | |||
@@ -491,7 +491,8 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
{_, {:ok, follower}} <- {:follow, User.follow(follower, followed)}, | |||
{_, {:ok, _}} <- | |||
{:follow_state_update, Utils.update_follow_state_for_all(activity, "accept")}, | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do | |||
{:ok, _relationship} <- | |||
FollowingRelationship.update(follower, followed, :follow_accept) do | |||
ActivityPub.accept(%{ | |||
to: [follower.ap_id], | |||
actor: followed, | |||
@@ -501,7 +502,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
else | |||
{:user_blocked, true} -> | |||
{:ok, _} = Utils.update_follow_state_for_all(activity, "reject") | |||
{:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject") | |||
{:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject) | |||
ActivityPub.reject(%{ | |||
to: [follower.ap_id], | |||
@@ -512,7 +513,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
{:follow, {:error, _}} -> | |||
{:ok, _} = Utils.update_follow_state_for_all(activity, "reject") | |||
{:ok, _relationship} = FollowingRelationship.update(follower, followed, "reject") | |||
{:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_reject) | |||
ActivityPub.reject(%{ | |||
to: [follower.ap_id], | |||
@@ -522,7 +523,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
}) | |||
{:user_locked, true} -> | |||
{:ok, _relationship} = FollowingRelationship.update(follower, followed, "pending") | |||
{:ok, _relationship} = FollowingRelationship.update(follower, followed, :follow_pending) | |||
:noop | |||
end | |||
@@ -542,7 +543,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
{:ok, follow_activity} <- get_follow_activity(follow_object, followed), | |||
{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"), | |||
%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]), | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept") do | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept) do | |||
ActivityPub.accept(%{ | |||
to: follow_activity.data["to"], | |||
type: "Accept", | |||
@@ -565,7 +566,7 @@ defmodule Pleroma.Web.ActivityPub.Transmogrifier do | |||
{:ok, follow_activity} <- get_follow_activity(follow_object, followed), | |||
{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"), | |||
%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]), | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"), | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject), | |||
{:ok, activity} <- | |||
ActivityPub.reject(%{ | |||
to: follow_activity.data["to"], | |||
@@ -42,7 +42,7 @@ defmodule Pleroma.Web.CommonAPI do | |||
with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed), | |||
{:ok, follower} <- User.follow(follower, followed), | |||
{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "accept"), | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "accept"), | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_accept), | |||
{:ok, _activity} <- | |||
ActivityPub.accept(%{ | |||
to: [follower.ap_id], | |||
@@ -57,7 +57,7 @@ defmodule Pleroma.Web.CommonAPI do | |||
def reject_follow_request(follower, followed) do | |||
with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed), | |||
{:ok, follow_activity} <- Utils.update_follow_state_for_all(follow_activity, "reject"), | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, "reject"), | |||
{:ok, _relationship} <- FollowingRelationship.update(follower, followed, :follow_reject), | |||
{:ok, _activity} <- | |||
ActivityPub.reject(%{ | |||
to: [follower.ap_id], | |||
@@ -0,0 +1,29 @@ | |||
defmodule Pleroma.Repo.Migrations.ChangeFollowingRelationshipsStateToInteger do | |||
use Ecto.Migration | |||
@alter_following_relationship_state "ALTER TABLE following_relationships ALTER COLUMN state" | |||
def up do | |||
execute(""" | |||
#{@alter_following_relationship_state} TYPE integer USING | |||
CASE | |||
WHEN state = 'pending' THEN 1 | |||
WHEN state = 'accept' THEN 2 | |||
WHEN state = 'reject' THEN 3 | |||
ELSE 0 | |||
END; | |||
""") | |||
end | |||
def down do | |||
execute(""" | |||
#{@alter_following_relationship_state} TYPE varchar(255) USING | |||
CASE | |||
WHEN state = 1 THEN 'pending' | |||
WHEN state = 2 THEN 'accept' | |||
WHEN state = 3 THEN 'reject' | |||
ELSE '' | |||
END; | |||
""") | |||
end | |||
end |
@@ -0,0 +1,11 @@ | |||
defmodule Pleroma.Repo.Migrations.AddFollowingRelationshipsFollowingIdIndex do | |||
use Ecto.Migration | |||
# [:follower_index] index is useless because of [:follower_id, :following_id] index | |||
# [:following_id] index makes sense because of user's followers-targeted queries | |||
def change do | |||
drop_if_exists(index(:following_relationships, [:follower_id])) | |||
create_if_not_exists(index(:following_relationships, [:following_id])) | |||
end | |||
end |
@@ -15,28 +15,28 @@ defmodule Pleroma.FollowingRelationshipTest do | |||
test "returns following addresses without internal.fetch" do | |||
user = insert(:user) | |||
fetch_actor = InternalFetchActor.get_actor() | |||
FollowingRelationship.follow(fetch_actor, user, "accept") | |||
FollowingRelationship.follow(fetch_actor, user, :follow_accept) | |||
assert FollowingRelationship.following(fetch_actor) == [user.follower_address] | |||
end | |||
test "returns following addresses without relay" do | |||
user = insert(:user) | |||
relay_actor = Relay.get_actor() | |||
FollowingRelationship.follow(relay_actor, user, "accept") | |||
FollowingRelationship.follow(relay_actor, user, :follow_accept) | |||
assert FollowingRelationship.following(relay_actor) == [user.follower_address] | |||
end | |||
test "returns following addresses without remote user" do | |||
user = insert(:user) | |||
actor = insert(:user, local: false) | |||
FollowingRelationship.follow(actor, user, "accept") | |||
FollowingRelationship.follow(actor, user, :follow_accept) | |||
assert FollowingRelationship.following(actor) == [user.follower_address] | |||
end | |||
test "returns following addresses with local user" do | |||
user = insert(:user) | |||
actor = insert(:user, local: true) | |||
FollowingRelationship.follow(actor, user, "accept") | |||
FollowingRelationship.follow(actor, user, :follow_accept) | |||
assert FollowingRelationship.following(actor) == [ | |||
actor.follower_address, | |||
@@ -140,7 +140,7 @@ defmodule Mix.Tasks.Pleroma.UserTest do | |||
test "user is unsubscribed" do | |||
followed = insert(:user) | |||
user = insert(:user) | |||
User.follow(user, followed, "accept") | |||
User.follow(user, followed, :follow_accept) | |||
Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname]) | |||
@@ -194,7 +194,8 @@ defmodule Pleroma.UserTest do | |||
CommonAPI.follow(pending_follower, locked) | |||
CommonAPI.follow(pending_follower, locked) | |||
CommonAPI.follow(accepted_follower, locked) | |||
Pleroma.FollowingRelationship.update(accepted_follower, locked, "accept") | |||
Pleroma.FollowingRelationship.update(accepted_follower, locked, :follow_accept) | |||
assert [^pending_follower] = User.get_follow_requests(locked) | |||
end | |||
@@ -319,7 +320,7 @@ defmodule Pleroma.UserTest do | |||
following_address: "http://localhost:4001/users/fuser2/following" | |||
}) | |||
{:ok, user} = User.follow(user, followed, "accept") | |||
{:ok, user} = User.follow(user, followed, :follow_accept) | |||
{:ok, user, _activity} = User.unfollow(user, followed) | |||
@@ -332,7 +333,7 @@ defmodule Pleroma.UserTest do | |||
followed = insert(:user) | |||
user = insert(:user) | |||
{:ok, user} = User.follow(user, followed, "accept") | |||
{:ok, user} = User.follow(user, followed, :follow_accept) | |||
assert User.following(user) == [user.follower_address, followed.follower_address] | |||
@@ -353,7 +354,7 @@ defmodule Pleroma.UserTest do | |||
test "test if a user is following another user" do | |||
followed = insert(:user) | |||
user = insert(:user) | |||
User.follow(user, followed, "accept") | |||
User.follow(user, followed, :follow_accept) | |||
assert User.following?(user, followed) | |||
refute User.following?(followed, user) | |||
@@ -1629,7 +1629,7 @@ defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do | |||
}) | |||
user_two = insert(:user) | |||
Pleroma.FollowingRelationship.follow(user_two, user, "accept") | |||
Pleroma.FollowingRelationship.follow(user_two, user, :follow_accept) | |||
{:ok, activity} = CommonAPI.post(user, %{"status" => "test"}) | |||
{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"}) | |||
@@ -574,7 +574,7 @@ defmodule Pleroma.Web.CommonAPITest do | |||
assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} = | |||
CommonAPI.follow(follower, followed) | |||
assert User.get_follow_state(follower, followed) == "pending" | |||
assert User.get_follow_state(follower, followed) == :follow_pending | |||
assert {:ok, follower} = CommonAPI.unfollow(follower, followed) | |||
assert User.get_follow_state(follower, followed) == nil | |||
@@ -596,7 +596,7 @@ defmodule Pleroma.Web.CommonAPITest do | |||
assert {:ok, follower, followed, %{id: activity_id, data: %{"state" => "pending"}}} = | |||
CommonAPI.follow(follower, followed) | |||
assert User.get_follow_state(follower, followed) == "pending" | |||
assert User.get_follow_state(follower, followed) == :follow_pending | |||
assert {:ok, follower} = CommonAPI.unfollow(follower, followed) | |||
assert User.get_follow_state(follower, followed) == nil | |||
@@ -21,7 +21,7 @@ defmodule Pleroma.Web.MastodonAPI.FollowRequestControllerTest do | |||
other_user = insert(:user) | |||
{:ok, _activity} = ActivityPub.follow(other_user, user) | |||
{:ok, other_user} = User.follow(other_user, user, "pending") | |||
{:ok, other_user} = User.follow(other_user, user, :follow_pending) | |||
assert User.following?(other_user, user) == false | |||
@@ -35,7 +35,7 @@ defmodule Pleroma.Web.MastodonAPI.FollowRequestControllerTest do | |||
other_user = insert(:user) | |||
{:ok, _activity} = ActivityPub.follow(other_user, user) | |||
{:ok, other_user} = User.follow(other_user, user, "pending") | |||
{:ok, other_user} = User.follow(other_user, user, :follow_pending) | |||
user = User.get_cached_by_id(user.id) | |||
other_user = User.get_cached_by_id(other_user.id) | |||
@@ -198,7 +198,7 @@ defmodule Pleroma.Web.StreamerTest do | |||
Pleroma.Config.put([:instance, :skip_thread_containment], false) | |||
author = insert(:user) | |||
user = insert(:user) | |||
User.follow(user, author, "accept") | |||
User.follow(user, author, :follow_accept) | |||
activity = | |||
insert(:note_activity, | |||
@@ -221,7 +221,7 @@ defmodule Pleroma.Web.StreamerTest do | |||
Pleroma.Config.put([:instance, :skip_thread_containment], true) | |||
author = insert(:user) | |||
user = insert(:user) | |||
User.follow(user, author, "accept") | |||
User.follow(user, author, :follow_accept) | |||
activity = | |||
insert(:note_activity, | |||
@@ -244,7 +244,7 @@ defmodule Pleroma.Web.StreamerTest do | |||
Pleroma.Config.put([:instance, :skip_thread_containment], false) | |||
author = insert(:user) | |||
user = insert(:user, skip_thread_containment: true) | |||
User.follow(user, author, "accept") | |||
User.follow(user, author, :follow_accept) | |||
activity = | |||
insert(:note_activity, | |||