moon
/
spc-pleroma
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[#1335] User: refactored :blocks field into :blocked_users relation. 

Introduced UserBlock.
This commit is contained in:
Ivan Tashkinov 2019-11-10 16:30:21 +03:00
parent 3a1aaadc18
commit 3db988250b
20 changed files with 234 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/pleroma/notification.ex
View File

@ -60,8 +60,10 @@ def for_user_query(user, opts \\ []) do
end
defp exclude_blocked(query, user) do
blocked_ap_ids = User.blocked_ap_ids(user)
query
|> where([n, a], a.actor not in ^user.blocks)
|> where([n, a], a.actor not in ^blocked_ap_ids)
|> where(
[n, a],
fragment("substring(? from '.*://([^/]*)')", a.actor) not in ^user.domain_blocks

57
lib/pleroma/user.ex
View File

@ -7,6 +7,7 @@ defmodule Pleroma.User do
import Ecto.Changeset
import Ecto.Query
import Ecto, only: [assoc: 2]
alias Comeonin.Pbkdf2
alias Ecto.Multi
@ -21,6 +22,7 @@ defmodule Pleroma.User do
alias Pleroma.Repo
alias Pleroma.RepoStreamer
alias Pleroma.User
alias Pleroma.UserBlock
alias Pleroma.Web
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.ActivityPub.Utils
@ -74,7 +76,6 @@ defmodule Pleroma.User do
field(:password_reset_pending, :boolean, default: false)
field(:confirmation_token, :string, default: nil)
field(:default_scope, :string, default: "public")
field(:blocks, {:array, :string}, default: [])
field(:domain_blocks, {:array, :string}, default: [])
field(:mutes, {:array, :string}, default: [])
field(:muted_reblogs, {:array, :string}, default: [])
@ -118,9 +119,16 @@ defmodule Pleroma.User do
has_many(:notifications, Notification)
has_many(:registrations, Registration)
has_many(:deliveries, Delivery)
has_many(:blocker_blocks, UserBlock, foreign_key: :blocker_id)
has_many(:blockee_blocks, UserBlock, foreign_key: :blockee_id)
has_many(:blocked_users, through: [:blocker_blocks, :blockee])
has_many(:blocker_users, through: [:blockee_blocks, :blocker])
field(:info, :map, default: %{})
# `:blocks` is deprecated (replaced with `blocked_users` relation)
field(:blocks, {:array, :string}, default: [])
timestamps()
end
@ -986,7 +994,7 @@ def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
end
end
def block(blocker, %User{ap_id: ap_id} = blocked) do
def block(blocker, %User{} = blocked) do
# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
blocker =
if following?(blocker, blocked) do
@ -1015,7 +1023,7 @@ def block(blocker, %User{ap_id: ap_id} = blocked) do
{:ok, blocker} = update_follower_count(blocker)
{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
add_to_block(blocker, ap_id)
add_to_block(blocker, blocked)
end
# helper to handle the block given only an actor's AP id
@ -1023,8 +1031,13 @@ def block(blocker, %{ap_id: ap_id}) do
block(blocker, get_cached_by_ap_id(ap_id))
end
def unblock(blocker, %User{} = blocked) do
remove_from_block(blocker, blocked)
end
# helper to handle the block given only an actor's AP id
def unblock(blocker, %{ap_id: ap_id}) do
remove_from_block(blocker, ap_id)
unblock(blocker, get_cached_by_ap_id(ap_id))
end
def mutes?(nil, _), do: false
@ -1043,7 +1056,7 @@ def blocks?(%User{} = user, %User{} = target) do
def blocks?(nil, _), do: false
def blocks_ap_id?(%User{} = user, %User{} = target) do
Enum.member?(user.blocks, target.ap_id)
UserBlock.exists?(user, target)
end
def blocks_ap_id?(_, _), do: false
@ -1070,10 +1083,20 @@ def muted_users(user) do
@spec blocked_users(User.t()) :: [User.t()]
def blocked_users(user) do
User.Query.build(%{ap_id: user.blocks, deactivated: false})
user
|> assoc(:blocked_users)
|> restrict_deactivated()
|> Repo.all()
end
def blocked_ap_ids(user) do
Repo.all(
from(u in assoc(user, :blocked_users),
select: u.ap_id
)
)
end
@spec subscribers(User.t()) :: [User.t()]
def subscribers(user) do
User.Query.build(%{ap_id: user.subscribers, deactivated: false})
@ -1179,7 +1202,7 @@ def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
blocked_identifiers,
fn blocked_identifier ->
with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
{:ok, blocker} <- block(blocker, blocked),
{:ok, _user_block} <- block(blocker, blocked),
{:ok, _} <- ActivityPub.block(blocker, blocked) do
blocked
else
@ -1844,21 +1867,15 @@ def unblock_domain(user, domain_blocked) do
set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
end
defp set_blocks(user, blocks) do
params = %{blocks: blocks}
user
|> cast(params, [:blocks])
|> validate_required([:blocks])
|> update_and_set_cache()
@spec add_to_block(User.t(), User.t()) :: {:ok, UserBlock.t()} | {:error, Ecto.Changeset.t()}
defp add_to_block(%User{} = user, %User{} = blocked) do
UserBlock.create(user, blocked)
end
def add_to_block(user, blocked) do
set_blocks(user, Enum.uniq([blocked | user.blocks]))
end
def remove_from_block(user, blocked) do
set_blocks(user, List.delete(user.blocks, blocked))
@spec add_to_block(User.t(), User.t()) ::
{:ok, UserBlock.t()} | {:ok, nil} | {:error, Ecto.Changeset.t()}
defp remove_from_block(%User{} = user, %User{} = blocked) do
UserBlock.delete(user, blocked)
end
defp set_mutes(user, mutes) do

15
lib/pleroma/user/search.ex
View File

@ -98,9 +98,18 @@ defp trigram_rank(query, query_string) do
defp base_query(_user, false), do: User
defp base_query(user, true), do: User.get_followers_query(user)
defp filter_blocked_user(query, %User{blocks: blocks})
when length(blocks) > 0 do
from(q in query, where: not (q.ap_id in ^blocks))
defp filter_blocked_user(query, %User{} = blocker) do
blocker_id = FlakeId.from_string(blocker.id)
from(
q in query,
where:
fragment(
"? NOT IN (SELECT blockee_id FROM user_blocks WHERE user_blocks.blocker_id = ?)",
q.id,
^blocker_id
)
)
end
defp filter_blocked_user(query, _), do: query

72
lib/pleroma/user_block.ex Normal file
View File

@ -0,0 +1,72 @@
# Pleroma: A lightweight social networking server
# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.UserBlock do
use Ecto.Schema
import Ecto.Changeset
import Ecto.Query
alias Pleroma.Repo
alias Pleroma.User
alias Pleroma.UserBlock
schema "user_blocks" do
belongs_to(:blocker, User, type: FlakeId.Ecto.CompatType)
belongs_to(:blockee, User, type: FlakeId.Ecto.CompatType)
timestamps(updated_at: false)
end
def changeset(%UserBlock{} = user_block, params \\ %{}) do
user_block
|> cast(params, [:blocker_id, :blockee_id])
|> validate_required([:blocker_id, :blockee_id])
|> unique_constraint(:blockee_id, name: :user_blocks_blocker_id_blockee_id_index)
|> validate_not_self_block()
end
def exists?(%User{} = blocker, %User{} = blockee) do
UserBlock
|> where(blocker_id: ^blocker.id, blockee_id: ^blockee.id)
|> Repo.exists?()
end
def create(%User{} = blocker, %User{} = blockee) do
%UserBlock{}
|> changeset(%{blocker_id: blocker.id, blockee_id: blockee.id})
|> Repo.insert(
on_conflict: :replace_all_except_primary_key,
conflict_target: [:blocker_id, :blockee_id]
)
end
def delete(%User{} = blocker, %User{} = blockee) do
attrs = %{blocker_id: blocker.id, blockee_id: blockee.id}
if is_nil(existing_record = Repo.get_by(UserBlock, attrs)) do
{:ok, nil}
else
Repo.delete(existing_record)
end
end
defp validate_not_self_block(%Ecto.Changeset{} = changeset) do
changeset
|> validate_change(:blockee_id, fn _, blockee_id ->
if blockee_id == changeset.changes[:blocker_id] || changeset.data.blocker_id do
[blockee_id: "can't be equal to blocker_id"]
else
[]
end
end)
|> validate_change(:blocker_id, fn _, blocker_id ->
if blocker_id == changeset.changes[:blockee_id] || changeset.data.blockee_id do
[blocker_id: "can't be equal to blockee_id"]
else
[]
end
end)
end
end

8
lib/pleroma/web/activity_pub/activity_pub.ex
View File

@ -876,7 +876,7 @@ defp restrict_muted(query, %{"muting_user" => %User{} = user} = opts) do
defp restrict_muted(query, _), do: query
defp restrict_blocked(query, %{"blocking_user" => %User{} = user}) do
blocks = user.blocks || []
blocked_ap_ids = User.blocked_ap_ids(user)
domain_blocks = user.domain_blocks || []
query =
@ -884,14 +884,14 @@ defp restrict_blocked(query, %{"blocking_user" => %User{} = user}) do
from(
[activity, object: o] in query,
where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
where: fragment("not (? && ?)", activity.recipients, ^blocks),
where: fragment("not (? = ANY(?))", activity.actor, ^blocked_ap_ids),
where: fragment("not (? && ?)", activity.recipients, ^blocked_ap_ids),
where:
fragment(
"not (?->>'type' = 'Announce' and ?->'to' \\?| ?)",
activity.data,
activity.data,
^blocks
^blocked_ap_ids
),
where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks),
where: fragment("not (split_part(?->>'actor', '/', 3) = ANY(?))", o.data, ^domain_blocks)

4
lib/pleroma/web/mastodon_api/controllers/account_controller.ex
View File

@ -341,7 +341,7 @@ def unmute(%{assigns: %{user: muter, account: muted}} = conn, _params) do
@doc "POST /api/v1/accounts/:id/block"
def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
with {:ok, blocker} <- User.block(blocker, blocked),
with {:ok, _user_block} <- User.block(blocker, blocked),
{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
render(conn, "relationship.json", user: blocker, target: blocked)
else
@ -351,7 +351,7 @@ def block(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
@doc "POST /api/v1/accounts/:id/unblock"
def unblock(%{assigns: %{user: blocker, account: blocked}} = conn, _params) do
with {:ok, blocker} <- User.unblock(blocker, blocked),
with {:ok, _user_block} <- User.unblock(blocker, blocked),
{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
render(conn, "relationship.json", user: blocker, target: blocked)
else

2
lib/pleroma/web/streamer/worker.ex
View File

@ -129,7 +129,7 @@ defp do_stream(%{topic: topic, item: item}) do
end
defp should_send?(%User{} = user, %Activity{} = item) do
blocks = user.blocks || []
blocks = User.blocked_ap_ids(user)
mutes = user.mutes || []
reblog_mutes = user.muted_reblogs || []
recipient_blocks = MapSet.new(blocks ++ mutes)

14
priv/repo/migrations/20191108161911_create_user_blocks.exs Normal file
View File

@ -0,0 +1,14 @@
defmodule Pleroma.Repo.Migrations.CreateUserBlocks do
use Ecto.Migration
def change do
create_if_not_exists table(:user_blocks) do
add(:blocker_id, references(:users, type: :uuid, on_delete: :delete_all))
add(:blockee_id, references(:users, type: :uuid, on_delete: :delete_all))
timestamps(updated_at: false)
end
create_if_not_exists(unique_index(:user_blocks, [:blocker_id, :blockee_id]))
end
end

50
priv/repo/migrations/20191108173911_data_migration_populate_user_blocks.exs Normal file
View File

@ -0,0 +1,50 @@
defmodule Pleroma.Repo.Migrations.DataMigrationPopulateUserBlocks do
use Ecto.Migration
alias Ecto.Adapters.SQL
alias Pleroma.Repo
require Logger
def up do
{:ok, %{rows: block_rows}} =
SQL.query(Repo, "SELECT id, blocks FROM users WHERE blocks != '{}'")
blockee_ap_ids =
Enum.flat_map(
block_rows,
fn [_, ap_ids] -> ap_ids end
)
|> Enum.uniq()
# Selecting ids of all blockees at once in order to reduce the number of SELECT queries
{:ok, %{rows: blockee_ap_id_id}} =
SQL.query(Repo, "SELECT ap_id, id FROM users WHERE ap_id = ANY($1)", [blockee_ap_ids])
blockee_id_by_ap_id = Enum.into(blockee_ap_id_id, %{}, fn [k, v] -> {k, v} end)
Enum.each(
block_rows,
fn [blocker_id, blockee_ap_ids] ->
blocker_uuid = Ecto.UUID.cast!(blocker_id)
for blockee_ap_id <- blockee_ap_ids do
blockee_id = blockee_id_by_ap_id[blockee_ap_id]
blockee_uuid = blockee_id && Ecto.UUID.cast!(blockee_id)
with {:ok, blockee_uuid} <- Ecto.UUID.cast(blockee_id) do
execute(
"INSERT INTO user_blocks(blocker_id, blockee_id, inserted_at) " <>
"VALUES('#{blocker_uuid}'::uuid, '#{blockee_uuid}'::uuid, now()) " <>
"ON CONFLICT (blocker_id, blockee_id) DO NOTHING"
)
else
_ -> Logger.warn("Missing reference: (#{blocker_uuid}, #{blockee_id})")
end
end
end
)
end
def down, do: :noop
end

6
test/conversation/participation_test.exs
View File

@ -252,7 +252,7 @@ test "when the user blocks a recipient, the existing conversations with them are
assert User.get_cached_by_id(blocker.id).unread_conversation_count == 4
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
# The conversations with the blocked user are marked as read
assert [%{read: true}, %{read: true}, %{read: true}, %{read: false}] =
@ -274,7 +274,7 @@ test "the new conversation with the blocked user is not marked as unread " do
blocked = insert(:user)
third_user = insert(:user)
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
# When the blocked user is the author
{:ok, _direct1} =
@ -311,7 +311,7 @@ test "the conversation with the blocked user is not marked as unread on a reply"
"visibility" => "direct"
})
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
assert [%{read: true}] = Participation.for_user(blocker)
assert User.get_cached_by_id(blocker.id).unread_conversation_count == 0

6
test/notification_test.exs
View File

@ -93,7 +93,7 @@ test "it creates a notification for user if the user blocks the activity author"
activity = insert(:note_activity)
author = User.get_cached_by_ap_id(activity.data["actor"])
user = insert(:user)
{:ok, user} = User.block(user, author)
{:ok, _user_block} = User.block(user, author)
assert Notification.create_notification(activity, user)
end
@ -656,7 +656,7 @@ test "it doesn't return notifications for muted user with notifications" do
test "it doesn't return notifications for blocked user" do
user = insert(:user)
blocked = insert(:user)
{:ok, user} = User.block(user, blocked)
{:ok, _user_block} = User.block(user, blocked)
{:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
@ -696,7 +696,7 @@ test "it returns notifications from a muted user when with_muted is set" do
test "it doesn't return notifications from a blocked user when with_muted is set" do
user = insert(:user)
blocked = insert(:user)
{:ok, user} = User.block(user, blocked)
{:ok, _user_block} = User.block(user, blocked)
{:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})

27
test/user_test.exs
View File

@ -100,7 +100,7 @@ test "clears follow requests when requester is blocked" do
CommonAPI.follow(follower, followed)
assert [_activity] = User.get_follow_requests(followed)
{:ok, _follower} = User.block(followed, follower)
{:ok, _user_block} = User.block(followed, follower)
assert [] = User.get_follow_requests(followed)
end
@ -113,8 +113,8 @@ test "follow_all follows mutliple users" do
not_followed = insert(:user)
reverse_blocked = insert(:user)
{:ok, user} = User.block(user, blocked)
{:ok, reverse_blocked} = User.block(reverse_blocked, user)
{:ok, _user_block} = User.block(user, blocked)
{:ok, _user_block} = User.block(reverse_blocked, user)
{:ok, user} = User.follow(user, followed_zero)
@ -166,7 +166,7 @@ test "can't follow a user who blocked us" do
blocker = insert(:user)
blockee = insert(:user)
{:ok, blocker} = User.block(blocker, blockee)
{:ok, _user_block} = User.block(blocker, blockee)
{:error, _} = User.follow(blockee, blocker)
end
@ -175,7 +175,7 @@ test "can't subscribe to a user who blocked us" do
blocker = insert(:user)
blocked = insert(:user)
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
{:error, _} = User.subscribe(blocked, blocker)
end
@ -711,7 +711,7 @@ test "it blocks people" do
refute User.blocks?(user, blocked_user)
{:ok, user} = User.block(user, blocked_user)
{:ok, _user_block} = User.block(user, blocked_user)
assert User.blocks?(user, blocked_user)
end
@ -720,8 +720,8 @@ test "it unblocks users" do
user = insert(:user)
blocked_user = insert(:user)
{:ok, user} = User.block(user, blocked_user)
{:ok, user} = User.unblock(user, blocked_user)
{:ok, _user_block} = User.block(user, blocked_user)
{:ok, _user_block} = User.unblock(user, blocked_user)
refute User.blocks?(user, blocked_user)
end
@ -736,7 +736,7 @@ test "blocks tear down cyclical follow relationships" do
assert User.following?(blocker, blocked)
assert User.following?(blocked, blocker)
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
blocked = User.get_cached_by_id(blocked.id)
assert User.blocks?(blocker, blocked)
@ -754,7 +754,7 @@ test "blocks tear down blocker->blocked follow relationships" do
assert User.following?(blocker, blocked)
refute User.following?(blocked, blocker)
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
blocked = User.get_cached_by_id(blocked.id)
assert User.blocks?(blocker, blocked)
@ -772,7 +772,7 @@ test "blocks tear down blocked->blocker follow relationships" do
refute User.following?(blocker, blocked)
assert User.following?(blocked, blocker)
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
blocked = User.get_cached_by_id(blocked.id)
assert User.blocks?(blocker, blocked)
@ -790,7 +790,7 @@ test "blocks tear down blocked->blocker subscription relationships" do
assert User.subscribed_to?(blocked, blocker)
refute User.subscribed_to?(blocker, blocked)
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
assert User.blocks?(blocker, blocked)
refute User.subscribed_to?(blocker, blocked)
@ -1313,7 +1313,8 @@ test "follower count is updated when a follower is blocked" do
{:ok, _follower2} = User.follow(follower2, user)
{:ok, _follower3} = User.follow(follower3, user)
{:ok, user} = User.block(user, follower)
{:ok, _user_block} = User.block(user, follower)
user = refresh_record(user)
assert User.user_info(user).follower_count == 2
end

12
test/web/activity_pub/activity_pub_test.exs
View File

@ -484,7 +484,7 @@ test "retrieves activities that have a given context" do
activity_five = insert(:note_activity)
user = insert(:user)
{:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})
{:ok, _user_block} = User.block(user, %{ap_id: activity_five.data["actor"]})
activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
assert activities == [activity_two, activity]
@ -497,7 +497,7 @@ test "doesn't return blocked activities" do
activity_three = insert(:note_activity)
user = insert(:user)
booster = insert(:user)
{:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})
{:ok, _user_block} = User.block(user, %{ap_id: activity_one.data["actor"]})
activities =
ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
@ -506,7 +506,7 @@ test "doesn't return blocked activities" do
assert Enum.member?(activities, activity_three)
refute Enum.member?(activities, activity_one)
{:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
{:ok, _user_block} = User.unblock(user, %{ap_id: activity_one.data["actor"]})
activities =
ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})
@ -515,7 +515,7 @@ test "doesn't return blocked activities" do
assert Enum.member?(activities, activity_three)
assert Enum.member?(activities, activity_one)
{:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
{:ok, _user_block} = User.block(user, %{ap_id: activity_three.data["actor"]})
{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
activity_three = Activity.get_by_id(activity_three.id)
@ -542,7 +542,7 @@ test "doesn't return transitive interactions concerning blocked users" do
blockee = insert(:user)
friend = insert(:user)
{:ok, blocker} = User.block(blocker, blockee)
{:ok, _user_block} = User.block(blocker, blockee)
{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})
@ -565,7 +565,7 @@ test "doesn't return announce activities concerning blocked users" do
blockee = insert(:user)
friend = insert(:user)
{:ok, blocker} = User.block(blocker, blockee)
{:ok, _user_block} = User.block(blocker, blockee)
{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})

2
test/web/activity_pub/transmogrifier/follow_handling_test.exs
View File

@ -128,7 +128,7 @@ test "it rejects incoming follow requests from blocked users when deny_follow_bl
user = insert(:user)
{:ok, target} = User.get_or_fetch("http://mastodon.example.org/users/admin")
{:ok, user} = User.block(user, target)
{:ok, _user_block} = User.block(user, target)
data =
File.read!("test/fixtures/mastodon-follow-activity.json")

2
test/web/mastodon_api/controllers/account_controller_test.exs
View File

@ -883,7 +883,7 @@ test "getting a list of blocks", %{conn: conn} do
user = insert(:user)
other_user = insert(:user)
{:ok, user} = User.block(user, other_user)
{:ok, _user_block} = User.block(user, other_user)
conn =
conn

4
test/web/mastodon_api/controllers/status_controller_test.exs
View File

@ -1108,7 +1108,7 @@ test "does not return users who have favorited the status but are blocked", %{
activity: activity
} do
other_user = insert(:user)
{:ok, user} = User.block(user, other_user)
{:ok, _user_block} = User.block(user, other_user)
{:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
@ -1205,7 +1205,7 @@ test "does not return users who have reblogged the status but are blocked", %{
activity: activity
} do
other_user = insert(:user)
{:ok, user} = User.block(user, other_user)
{:ok, _user_block} = User.block(user, other_user)
{:ok, _, _} = CommonAPI.repeat(activity.id, other_user)

2
test/web/mastodon_api/controllers/timeline_controller_test.exs
View File

@ -194,7 +194,7 @@ test "doesn't include DMs from blocked users", %{conn: conn} do
blocker = insert(:user)
blocked = insert(:user)
user = insert(:user)
{:ok, blocker} = User.block(blocker, blocked)
{:ok, _user_block} = User.block(blocker, blocked)
{:ok, _blocked_direct} =
CommonAPI.post(blocked, %{

6
test/web/mastodon_api/views/account_view_test.exs
View File

@ -219,8 +219,8 @@ test "represent a relationship for the blocking and blocked user" do
{:ok, user} = User.follow(user, other_user)
{:ok, other_user} = User.subscribe(user, other_user)
{:ok, user} = User.block(user, other_user)
{:ok, other_user} = User.block(other_user, user)
{:ok, _user_block} = User.block(user, other_user)
{:ok, _user_block} = User.block(other_user, user)
expected = %{
id: to_string(other_user.id),
@ -291,7 +291,7 @@ test "represent an embedded relationship" do
other_user = insert(:user)
{:ok, other_user} = User.follow(other_user, user)
{:ok, other_user} = User.block(other_user, user)
{:ok, _user_block} = User.block(other_user, user)
{:ok, _} = User.follow(insert(:user), user)
expected = %{

6
test/web/streamer/streamer_test.exs
View File

@ -59,7 +59,7 @@ test "it doesn't send notify to the 'user:notification' stream when a user is bl
user: user
} do
blocked = insert(:user)
{:ok, user} = User.block(user, blocked)
{:ok, _user_block} = User.block(user, blocked)
task = Task.async(fn -> refute_receive {:text, _}, 4_000 end)
@ -259,7 +259,7 @@ test "it sends message if recipients invalid and thread containment is enabled b
test "it doesn't send messages involving blocked users" do
user = insert(:user)
blocked_user = insert(:user)
{:ok, user} = User.block(user, blocked_user)
{:ok, _user_block} = User.block(user, blocked_user)
task =
Task.async(fn ->
@ -301,7 +301,7 @@ test "it doesn't send messages transitively involving blocked users" do
"public" => [fake_socket]
}
{:ok, blocker} = User.block(blocker, blockee)
{:ok, _user_block} = User.block(blocker, blockee)
{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})

4
test/web/twitter_api/util_controller_test.exs
View File

@ -387,7 +387,7 @@ test "returns error when user is blocked", %{conn: conn} do
user = insert(:user)
user2 = insert(:user)
{:ok, _user} = Pleroma.User.block(user2, user)
{:ok, _user_block} = Pleroma.User.block(user2, user)
response =
conn
@ -485,7 +485,7 @@ test "returns error when user is blocked", %{conn: conn} do
Pleroma.Config.put([:user, :deny_follow_blocked], true)
user = insert(:user)
user2 = insert(:user)
{:ok, _user} = Pleroma.User.block(user2, user)
{:ok, _user_block} = Pleroma.User.block(user2, user)
response =
conn