Pleroma/test/web/activity_pub/visibilty_test.exs

231 lines
6.4 KiB
Elixir
Raw Normal View History

# Pleroma: A lightweight social networking server
2020-03-03 23:44:49 +01:00
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
2019-02-22 13:29:52 +01:00
defmodule Pleroma.Web.ActivityPub.VisibilityTest do
use Pleroma.DataCase
2019-06-03 15:04:39 +02:00
alias Pleroma.Activity
2019-02-22 13:29:52 +01:00
alias Pleroma.Web.ActivityPub.Visibility
alias Pleroma.Web.CommonAPI
2019-02-22 13:29:52 +01:00
import Pleroma.Factory
setup do
user = insert(:user)
mentioned = insert(:user)
following = insert(:user)
unrelated = insert(:user)
{:ok, following} = Pleroma.User.follow(following, user)
2019-07-11 14:29:24 +02:00
{:ok, list} = Pleroma.List.create("foo", user)
Pleroma.List.follow(list, unrelated)
2019-02-22 13:29:52 +01:00
{:ok, public} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "public"})
{:ok, private} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "private"})
{:ok, direct} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "direct"})
{:ok, unlisted} =
CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "unlisted"})
2019-07-11 14:29:24 +02:00
{:ok, list} =
CommonAPI.post(user, %{
"status" => "@#{mentioned.nickname}",
"visibility" => "list:#{list.id}"
})
2019-02-22 13:29:52 +01:00
%{
public: public,
private: private,
direct: direct,
unlisted: unlisted,
user: user,
mentioned: mentioned,
following: following,
2019-07-11 14:29:24 +02:00
unrelated: unrelated,
list: list
2019-02-22 13:29:52 +01:00
}
end
2019-07-11 14:29:24 +02:00
test "is_direct?", %{
public: public,
private: private,
direct: direct,
unlisted: unlisted,
list: list
} do
2019-02-22 13:29:52 +01:00
assert Visibility.is_direct?(direct)
refute Visibility.is_direct?(public)
refute Visibility.is_direct?(private)
refute Visibility.is_direct?(unlisted)
2019-07-11 14:29:24 +02:00
assert Visibility.is_direct?(list)
2019-02-22 13:29:52 +01:00
end
2019-07-11 14:29:24 +02:00
test "is_public?", %{
public: public,
private: private,
direct: direct,
unlisted: unlisted,
list: list
} do
2019-02-22 13:29:52 +01:00
refute Visibility.is_public?(direct)
assert Visibility.is_public?(public)
refute Visibility.is_public?(private)
assert Visibility.is_public?(unlisted)
2019-07-11 14:29:24 +02:00
refute Visibility.is_public?(list)
2019-02-22 13:29:52 +01:00
end
2019-07-11 14:29:24 +02:00
test "is_private?", %{
public: public,
private: private,
direct: direct,
unlisted: unlisted,
list: list
} do
2019-02-22 13:29:52 +01:00
refute Visibility.is_private?(direct)
refute Visibility.is_private?(public)
assert Visibility.is_private?(private)
refute Visibility.is_private?(unlisted)
2019-07-11 14:29:24 +02:00
refute Visibility.is_private?(list)
end
test "is_list?", %{
public: public,
private: private,
direct: direct,
unlisted: unlisted,
list: list
} do
refute Visibility.is_list?(direct)
refute Visibility.is_list?(public)
refute Visibility.is_list?(private)
refute Visibility.is_list?(unlisted)
assert Visibility.is_list?(list)
2019-02-22 13:29:52 +01:00
end
test "visible_for_user?", %{
public: public,
private: private,
direct: direct,
unlisted: unlisted,
user: user,
mentioned: mentioned,
following: following,
2019-07-11 14:29:24 +02:00
unrelated: unrelated,
list: list
2019-02-22 13:29:52 +01:00
} do
# All visible to author
assert Visibility.visible_for_user?(public, user)
assert Visibility.visible_for_user?(private, user)
assert Visibility.visible_for_user?(unlisted, user)
assert Visibility.visible_for_user?(direct, user)
2019-07-11 14:29:24 +02:00
assert Visibility.visible_for_user?(list, user)
2019-02-22 13:29:52 +01:00
# All visible to a mentioned user
2019-02-22 13:29:52 +01:00
assert Visibility.visible_for_user?(public, mentioned)
assert Visibility.visible_for_user?(private, mentioned)
assert Visibility.visible_for_user?(unlisted, mentioned)
assert Visibility.visible_for_user?(direct, mentioned)
assert Visibility.visible_for_user?(list, mentioned)
2019-02-22 13:29:52 +01:00
# DM not visible for just follower
assert Visibility.visible_for_user?(public, following)
assert Visibility.visible_for_user?(private, following)
assert Visibility.visible_for_user?(unlisted, following)
refute Visibility.visible_for_user?(direct, following)
2019-07-11 14:29:24 +02:00
refute Visibility.visible_for_user?(list, following)
2019-02-22 13:29:52 +01:00
# Public and unlisted visible for unrelated user
assert Visibility.visible_for_user?(public, unrelated)
assert Visibility.visible_for_user?(unlisted, unrelated)
refute Visibility.visible_for_user?(private, unrelated)
refute Visibility.visible_for_user?(direct, unrelated)
2019-07-11 14:29:24 +02:00
# Visible for a list member
assert Visibility.visible_for_user?(list, unrelated)
2019-02-22 13:29:52 +01:00
end
2019-05-08 18:08:50 +02:00
test "doesn't die when the user doesn't exist",
%{
direct: direct,
user: user
} do
Repo.delete(user)
Cachex.clear(:user_cache)
refute Visibility.is_private?(direct)
end
test "get_visibility", %{
public: public,
private: private,
direct: direct,
2019-07-11 14:29:24 +02:00
unlisted: unlisted,
list: list
} do
assert Visibility.get_visibility(public) == "public"
assert Visibility.get_visibility(private) == "private"
assert Visibility.get_visibility(direct) == "direct"
assert Visibility.get_visibility(unlisted) == "unlisted"
2019-07-11 14:29:24 +02:00
assert Visibility.get_visibility(list) == "list"
end
test "get_visibility with directMessage flag" do
assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
end
2019-06-03 15:04:39 +02:00
2019-07-11 14:29:24 +02:00
test "get_visibility with listMessage flag" do
assert Visibility.get_visibility(%{data: %{"listMessage" => ""}}) == "list"
end
2019-06-03 15:04:39 +02:00
describe "entire_thread_visible_for_user?/2" do
test "returns false if not found activity", %{user: user} do
refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)
end
test "returns true if activity hasn't 'Create' type", %{user: user} do
activity = insert(:like_activity)
assert Visibility.entire_thread_visible_for_user?(activity, user)
end
test "returns false when invalid recipients", %{user: user} do
author = insert(:user)
activity =
insert(:note_activity,
note:
insert(:note,
user: author,
data: %{"to" => ["test-user"]}
)
)
refute Visibility.entire_thread_visible_for_user?(activity, user)
end
test "returns true if user following to author" do
author = insert(:user)
user = insert(:user)
Pleroma.User.follow(user, author)
2019-06-03 15:04:39 +02:00
activity =
insert(:note_activity,
note:
insert(:note,
user: author,
data: %{"to" => [user.ap_id]}
)
)
assert Visibility.entire_thread_visible_for_user?(activity, user)
end
end
2019-02-22 13:29:52 +01:00
end