forked from AkkomaGang/akkoma
9d09755291
Every time someone tries to use it, it goes mad and tries to scrape the entire fediverse for no visible reason, it's better to just remove it than continue shipping it in it's current state. idea acked by lain and feld on irc Closes #1595 #1422
587 lines
18 KiB
Elixir
587 lines
18 KiB
Elixir
# Pleroma: A lightweight social networking server
|
|
# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
|
|
# SPDX-License-Identifier: AGPL-3.0-only
|
|
|
|
defmodule Pleroma.Web.ActivityPub.UtilsTest do
|
|
use Pleroma.DataCase
|
|
alias Pleroma.Activity
|
|
alias Pleroma.Object
|
|
alias Pleroma.Repo
|
|
alias Pleroma.User
|
|
alias Pleroma.Web.ActivityPub.ActivityPub
|
|
alias Pleroma.Web.ActivityPub.Utils
|
|
alias Pleroma.Web.AdminAPI.AccountView
|
|
alias Pleroma.Web.CommonAPI
|
|
|
|
import Pleroma.Factory
|
|
|
|
require Pleroma.Constants
|
|
|
|
describe "fetch the latest Follow" do
|
|
test "fetches the latest Follow activity" do
|
|
%Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
|
|
follower = User.get_cached_by_ap_id(activity.data["actor"])
|
|
followed = User.get_cached_by_ap_id(activity.data["object"])
|
|
|
|
assert activity == Utils.fetch_latest_follow(follower, followed)
|
|
end
|
|
end
|
|
|
|
describe "fetch the latest Block" do
|
|
test "fetches the latest Block activity" do
|
|
blocker = insert(:user)
|
|
blocked = insert(:user)
|
|
{:ok, activity} = ActivityPub.block(blocker, blocked)
|
|
|
|
assert activity == Utils.fetch_latest_block(blocker, blocked)
|
|
end
|
|
end
|
|
|
|
describe "determine_explicit_mentions()" do
|
|
test "works with an object that has mentions" do
|
|
object = %{
|
|
"tag" => [
|
|
%{
|
|
"type" => "Mention",
|
|
"href" => "https://example.com/~alyssa",
|
|
"name" => "Alyssa P. Hacker"
|
|
}
|
|
]
|
|
}
|
|
|
|
assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
|
|
end
|
|
|
|
test "works with an object that does not have mentions" do
|
|
object = %{
|
|
"tag" => [
|
|
%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
|
|
]
|
|
}
|
|
|
|
assert Utils.determine_explicit_mentions(object) == []
|
|
end
|
|
|
|
test "works with an object that has mentions and other tags" do
|
|
object = %{
|
|
"tag" => [
|
|
%{
|
|
"type" => "Mention",
|
|
"href" => "https://example.com/~alyssa",
|
|
"name" => "Alyssa P. Hacker"
|
|
},
|
|
%{"type" => "Hashtag", "href" => "https://example.com/tag/2hu", "name" => "2hu"}
|
|
]
|
|
}
|
|
|
|
assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
|
|
end
|
|
|
|
test "works with an object that has no tags" do
|
|
object = %{}
|
|
|
|
assert Utils.determine_explicit_mentions(object) == []
|
|
end
|
|
|
|
test "works with an object that has only IR tags" do
|
|
object = %{"tag" => ["2hu"]}
|
|
|
|
assert Utils.determine_explicit_mentions(object) == []
|
|
end
|
|
|
|
test "works with an object has tags as map" do
|
|
object = %{
|
|
"tag" => %{
|
|
"type" => "Mention",
|
|
"href" => "https://example.com/~alyssa",
|
|
"name" => "Alyssa P. Hacker"
|
|
}
|
|
}
|
|
|
|
assert Utils.determine_explicit_mentions(object) == ["https://example.com/~alyssa"]
|
|
end
|
|
end
|
|
|
|
describe "make_unlike_data/3" do
|
|
test "returns data for unlike activity" do
|
|
user = insert(:user)
|
|
like_activity = insert(:like_activity, data_attrs: %{"context" => "test context"})
|
|
|
|
object = Object.normalize(like_activity.data["object"])
|
|
|
|
assert Utils.make_unlike_data(user, like_activity, nil) == %{
|
|
"type" => "Undo",
|
|
"actor" => user.ap_id,
|
|
"object" => like_activity.data,
|
|
"to" => [user.follower_address, object.data["actor"]],
|
|
"cc" => [Pleroma.Constants.as_public()],
|
|
"context" => like_activity.data["context"]
|
|
}
|
|
|
|
assert Utils.make_unlike_data(user, like_activity, "9mJEZK0tky1w2xD2vY") == %{
|
|
"type" => "Undo",
|
|
"actor" => user.ap_id,
|
|
"object" => like_activity.data,
|
|
"to" => [user.follower_address, object.data["actor"]],
|
|
"cc" => [Pleroma.Constants.as_public()],
|
|
"context" => like_activity.data["context"],
|
|
"id" => "9mJEZK0tky1w2xD2vY"
|
|
}
|
|
end
|
|
end
|
|
|
|
describe "make_like_data" do
|
|
setup do
|
|
user = insert(:user)
|
|
other_user = insert(:user)
|
|
third_user = insert(:user)
|
|
[user: user, other_user: other_user, third_user: third_user]
|
|
end
|
|
|
|
test "addresses actor's follower address if the activity is public", %{
|
|
user: user,
|
|
other_user: other_user,
|
|
third_user: third_user
|
|
} do
|
|
expected_to = Enum.sort([user.ap_id, other_user.follower_address])
|
|
expected_cc = Enum.sort(["https://www.w3.org/ns/activitystreams#Public", third_user.ap_id])
|
|
|
|
{:ok, activity} =
|
|
CommonAPI.post(user, %{
|
|
"status" =>
|
|
"hey @#{other_user.nickname}, @#{third_user.nickname} how about beering together this weekend?"
|
|
})
|
|
|
|
%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
|
|
assert Enum.sort(to) == expected_to
|
|
assert Enum.sort(cc) == expected_cc
|
|
end
|
|
|
|
test "does not adress actor's follower address if the activity is not public", %{
|
|
user: user,
|
|
other_user: other_user,
|
|
third_user: third_user
|
|
} do
|
|
expected_to = Enum.sort([user.ap_id])
|
|
expected_cc = [third_user.ap_id]
|
|
|
|
{:ok, activity} =
|
|
CommonAPI.post(user, %{
|
|
"status" => "@#{other_user.nickname} @#{third_user.nickname} bought a new swimsuit!",
|
|
"visibility" => "private"
|
|
})
|
|
|
|
%{"to" => to, "cc" => cc} = Utils.make_like_data(other_user, activity, nil)
|
|
assert Enum.sort(to) == expected_to
|
|
assert Enum.sort(cc) == expected_cc
|
|
end
|
|
end
|
|
|
|
test "make_json_ld_header/0" do
|
|
assert Utils.make_json_ld_header() == %{
|
|
"@context" => [
|
|
"https://www.w3.org/ns/activitystreams",
|
|
"http://localhost:4001/schemas/litepub-0.1.jsonld",
|
|
%{
|
|
"@language" => "und"
|
|
}
|
|
]
|
|
}
|
|
end
|
|
|
|
describe "get_existing_votes" do
|
|
test "fetches existing votes" do
|
|
user = insert(:user)
|
|
other_user = insert(:user)
|
|
|
|
{:ok, activity} =
|
|
CommonAPI.post(user, %{
|
|
"status" => "How do I pronounce LaTeX?",
|
|
"poll" => %{
|
|
"options" => ["laytekh", "lahtekh", "latex"],
|
|
"expires_in" => 20,
|
|
"multiple" => true
|
|
}
|
|
})
|
|
|
|
object = Object.normalize(activity)
|
|
{:ok, votes, object} = CommonAPI.vote(other_user, object, [0, 1])
|
|
assert Enum.sort(Utils.get_existing_votes(other_user.ap_id, object)) == Enum.sort(votes)
|
|
end
|
|
|
|
test "fetches only Create activities" do
|
|
user = insert(:user)
|
|
other_user = insert(:user)
|
|
|
|
{:ok, activity} =
|
|
CommonAPI.post(user, %{
|
|
"status" => "Are we living in a society?",
|
|
"poll" => %{
|
|
"options" => ["yes", "no"],
|
|
"expires_in" => 20
|
|
}
|
|
})
|
|
|
|
object = Object.normalize(activity)
|
|
{:ok, [vote], object} = CommonAPI.vote(other_user, object, [0])
|
|
vote_object = Object.normalize(vote)
|
|
{:ok, _activity, _object} = ActivityPub.like(user, vote_object)
|
|
[fetched_vote] = Utils.get_existing_votes(other_user.ap_id, object)
|
|
assert fetched_vote.id == vote.id
|
|
end
|
|
end
|
|
|
|
describe "update_follow_state_for_all/2" do
|
|
test "updates the state of all Follow activities with the same actor and object" do
|
|
user = insert(:user, locked: true)
|
|
follower = insert(:user)
|
|
|
|
{:ok, follow_activity} = ActivityPub.follow(follower, user)
|
|
{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
|
|
|
|
data =
|
|
follow_activity_two.data
|
|
|> Map.put("state", "accept")
|
|
|
|
cng = Ecto.Changeset.change(follow_activity_two, data: data)
|
|
|
|
{:ok, follow_activity_two} = Repo.update(cng)
|
|
|
|
{:ok, follow_activity_two} =
|
|
Utils.update_follow_state_for_all(follow_activity_two, "accept")
|
|
|
|
assert refresh_record(follow_activity).data["state"] == "accept"
|
|
assert refresh_record(follow_activity_two).data["state"] == "accept"
|
|
end
|
|
end
|
|
|
|
describe "update_follow_state/2" do
|
|
test "updates the state of the given follow activity" do
|
|
user = insert(:user, locked: true)
|
|
follower = insert(:user)
|
|
|
|
{:ok, follow_activity} = ActivityPub.follow(follower, user)
|
|
{:ok, follow_activity_two} = ActivityPub.follow(follower, user)
|
|
|
|
data =
|
|
follow_activity_two.data
|
|
|> Map.put("state", "accept")
|
|
|
|
cng = Ecto.Changeset.change(follow_activity_two, data: data)
|
|
|
|
{:ok, follow_activity_two} = Repo.update(cng)
|
|
|
|
{:ok, follow_activity_two} = Utils.update_follow_state(follow_activity_two, "reject")
|
|
|
|
assert refresh_record(follow_activity).data["state"] == "pending"
|
|
assert refresh_record(follow_activity_two).data["state"] == "reject"
|
|
end
|
|
end
|
|
|
|
describe "update_element_in_object/3" do
|
|
test "updates likes" do
|
|
user = insert(:user)
|
|
activity = insert(:note_activity)
|
|
object = Object.normalize(activity)
|
|
|
|
assert {:ok, updated_object} =
|
|
Utils.update_element_in_object(
|
|
"like",
|
|
[user.ap_id],
|
|
object
|
|
)
|
|
|
|
assert updated_object.data["likes"] == [user.ap_id]
|
|
assert updated_object.data["like_count"] == 1
|
|
end
|
|
end
|
|
|
|
describe "add_like_to_object/2" do
|
|
test "add actor to likes" do
|
|
user = insert(:user)
|
|
user2 = insert(:user)
|
|
object = insert(:note)
|
|
|
|
assert {:ok, updated_object} =
|
|
Utils.add_like_to_object(
|
|
%Activity{data: %{"actor" => user.ap_id}},
|
|
object
|
|
)
|
|
|
|
assert updated_object.data["likes"] == [user.ap_id]
|
|
assert updated_object.data["like_count"] == 1
|
|
|
|
assert {:ok, updated_object2} =
|
|
Utils.add_like_to_object(
|
|
%Activity{data: %{"actor" => user2.ap_id}},
|
|
updated_object
|
|
)
|
|
|
|
assert updated_object2.data["likes"] == [user2.ap_id, user.ap_id]
|
|
assert updated_object2.data["like_count"] == 2
|
|
end
|
|
end
|
|
|
|
describe "remove_like_from_object/2" do
|
|
test "removes ap_id from likes" do
|
|
user = insert(:user)
|
|
user2 = insert(:user)
|
|
object = insert(:note, data: %{"likes" => [user.ap_id, user2.ap_id], "like_count" => 2})
|
|
|
|
assert {:ok, updated_object} =
|
|
Utils.remove_like_from_object(
|
|
%Activity{data: %{"actor" => user.ap_id}},
|
|
object
|
|
)
|
|
|
|
assert updated_object.data["likes"] == [user2.ap_id]
|
|
assert updated_object.data["like_count"] == 1
|
|
end
|
|
end
|
|
|
|
describe "get_existing_like/2" do
|
|
test "fetches existing like" do
|
|
note_activity = insert(:note_activity)
|
|
assert object = Object.normalize(note_activity)
|
|
|
|
user = insert(:user)
|
|
refute Utils.get_existing_like(user.ap_id, object)
|
|
{:ok, like_activity, _object} = ActivityPub.like(user, object)
|
|
|
|
assert ^like_activity = Utils.get_existing_like(user.ap_id, object)
|
|
end
|
|
end
|
|
|
|
describe "get_get_existing_announce/2" do
|
|
test "returns nil if announce not found" do
|
|
actor = insert(:user)
|
|
refute Utils.get_existing_announce(actor.ap_id, %{data: %{"id" => "test"}})
|
|
end
|
|
|
|
test "fetches existing announce" do
|
|
note_activity = insert(:note_activity)
|
|
assert object = Object.normalize(note_activity)
|
|
actor = insert(:user)
|
|
|
|
{:ok, announce, _object} = ActivityPub.announce(actor, object)
|
|
assert Utils.get_existing_announce(actor.ap_id, object) == announce
|
|
end
|
|
end
|
|
|
|
describe "fetch_latest_block/2" do
|
|
test "fetches last block activities" do
|
|
user1 = insert(:user)
|
|
user2 = insert(:user)
|
|
|
|
assert {:ok, %Activity{} = _} = ActivityPub.block(user1, user2)
|
|
assert {:ok, %Activity{} = _} = ActivityPub.block(user1, user2)
|
|
assert {:ok, %Activity{} = activity} = ActivityPub.block(user1, user2)
|
|
|
|
assert Utils.fetch_latest_block(user1, user2) == activity
|
|
end
|
|
end
|
|
|
|
describe "recipient_in_message/3" do
|
|
test "returns true when recipient in `to`" do
|
|
recipient = insert(:user)
|
|
actor = insert(:user)
|
|
assert Utils.recipient_in_message(recipient, actor, %{"to" => recipient.ap_id})
|
|
|
|
assert Utils.recipient_in_message(
|
|
recipient,
|
|
actor,
|
|
%{"to" => [recipient.ap_id], "cc" => ""}
|
|
)
|
|
end
|
|
|
|
test "returns true when recipient in `cc`" do
|
|
recipient = insert(:user)
|
|
actor = insert(:user)
|
|
assert Utils.recipient_in_message(recipient, actor, %{"cc" => recipient.ap_id})
|
|
|
|
assert Utils.recipient_in_message(
|
|
recipient,
|
|
actor,
|
|
%{"cc" => [recipient.ap_id], "to" => ""}
|
|
)
|
|
end
|
|
|
|
test "returns true when recipient in `bto`" do
|
|
recipient = insert(:user)
|
|
actor = insert(:user)
|
|
assert Utils.recipient_in_message(recipient, actor, %{"bto" => recipient.ap_id})
|
|
|
|
assert Utils.recipient_in_message(
|
|
recipient,
|
|
actor,
|
|
%{"bcc" => "", "bto" => [recipient.ap_id]}
|
|
)
|
|
end
|
|
|
|
test "returns true when recipient in `bcc`" do
|
|
recipient = insert(:user)
|
|
actor = insert(:user)
|
|
assert Utils.recipient_in_message(recipient, actor, %{"bcc" => recipient.ap_id})
|
|
|
|
assert Utils.recipient_in_message(
|
|
recipient,
|
|
actor,
|
|
%{"bto" => "", "bcc" => [recipient.ap_id]}
|
|
)
|
|
end
|
|
|
|
test "returns true when message without addresses fields" do
|
|
recipient = insert(:user)
|
|
actor = insert(:user)
|
|
assert Utils.recipient_in_message(recipient, actor, %{"bccc" => recipient.ap_id})
|
|
|
|
assert Utils.recipient_in_message(
|
|
recipient,
|
|
actor,
|
|
%{"btod" => "", "bccc" => [recipient.ap_id]}
|
|
)
|
|
end
|
|
|
|
test "returns false" do
|
|
recipient = insert(:user)
|
|
actor = insert(:user)
|
|
refute Utils.recipient_in_message(recipient, actor, %{"to" => "ap_id"})
|
|
end
|
|
end
|
|
|
|
describe "lazy_put_activity_defaults/2" do
|
|
test "returns map with id and published data" do
|
|
note_activity = insert(:note_activity)
|
|
object = Object.normalize(note_activity)
|
|
res = Utils.lazy_put_activity_defaults(%{"context" => object.data["id"]})
|
|
assert res["context"] == object.data["id"]
|
|
assert res["context_id"] == object.id
|
|
assert res["id"]
|
|
assert res["published"]
|
|
end
|
|
|
|
test "returns map with fake id and published data" do
|
|
assert %{
|
|
"context" => "pleroma:fakecontext",
|
|
"context_id" => -1,
|
|
"id" => "pleroma:fakeid",
|
|
"published" => _
|
|
} = Utils.lazy_put_activity_defaults(%{}, true)
|
|
end
|
|
|
|
test "returns activity data with object" do
|
|
note_activity = insert(:note_activity)
|
|
object = Object.normalize(note_activity)
|
|
|
|
res =
|
|
Utils.lazy_put_activity_defaults(%{
|
|
"context" => object.data["id"],
|
|
"object" => %{}
|
|
})
|
|
|
|
assert res["context"] == object.data["id"]
|
|
assert res["context_id"] == object.id
|
|
assert res["id"]
|
|
assert res["published"]
|
|
assert res["object"]["id"]
|
|
assert res["object"]["published"]
|
|
assert res["object"]["context"] == object.data["id"]
|
|
assert res["object"]["context_id"] == object.id
|
|
end
|
|
end
|
|
|
|
describe "make_flag_data" do
|
|
test "returns empty map when params is invalid" do
|
|
assert Utils.make_flag_data(%{}, %{}) == %{}
|
|
end
|
|
|
|
test "returns map with Flag object" do
|
|
reporter = insert(:user)
|
|
target_account = insert(:user)
|
|
{:ok, activity} = CommonAPI.post(target_account, %{"status" => "foobar"})
|
|
context = Utils.generate_context_id()
|
|
content = "foobar"
|
|
|
|
target_ap_id = target_account.ap_id
|
|
activity_ap_id = activity.data["id"]
|
|
|
|
res =
|
|
Utils.make_flag_data(
|
|
%{
|
|
actor: reporter,
|
|
context: context,
|
|
account: target_account,
|
|
statuses: [%{"id" => activity.data["id"]}],
|
|
content: content
|
|
},
|
|
%{}
|
|
)
|
|
|
|
note_obj = %{
|
|
"type" => "Note",
|
|
"id" => activity_ap_id,
|
|
"content" => content,
|
|
"published" => activity.object.data["published"],
|
|
"actor" => AccountView.render("show.json", %{user: target_account})
|
|
}
|
|
|
|
assert %{
|
|
"type" => "Flag",
|
|
"content" => ^content,
|
|
"context" => ^context,
|
|
"object" => [^target_ap_id, ^note_obj],
|
|
"state" => "open"
|
|
} = res
|
|
end
|
|
end
|
|
|
|
describe "add_announce_to_object/2" do
|
|
test "adds actor to announcement" do
|
|
user = insert(:user)
|
|
object = insert(:note)
|
|
|
|
activity =
|
|
insert(:note_activity,
|
|
data: %{
|
|
"actor" => user.ap_id,
|
|
"cc" => [Pleroma.Constants.as_public()]
|
|
}
|
|
)
|
|
|
|
assert {:ok, updated_object} = Utils.add_announce_to_object(activity, object)
|
|
assert updated_object.data["announcements"] == [user.ap_id]
|
|
assert updated_object.data["announcement_count"] == 1
|
|
end
|
|
end
|
|
|
|
describe "remove_announce_from_object/2" do
|
|
test "removes actor from announcements" do
|
|
user = insert(:user)
|
|
user2 = insert(:user)
|
|
|
|
object =
|
|
insert(:note,
|
|
data: %{"announcements" => [user.ap_id, user2.ap_id], "announcement_count" => 2}
|
|
)
|
|
|
|
activity = insert(:note_activity, data: %{"actor" => user.ap_id})
|
|
|
|
assert {:ok, updated_object} = Utils.remove_announce_from_object(activity, object)
|
|
assert updated_object.data["announcements"] == [user2.ap_id]
|
|
assert updated_object.data["announcement_count"] == 1
|
|
end
|
|
end
|
|
|
|
describe "get_cached_emoji_reactions/1" do
|
|
test "returns the data or an emtpy list" do
|
|
object = insert(:note)
|
|
assert Utils.get_cached_emoji_reactions(object) == []
|
|
|
|
object = insert(:note, data: %{"reactions" => [["x", ["lain"]]]})
|
|
assert Utils.get_cached_emoji_reactions(object) == [["x", ["lain"]]]
|
|
|
|
object = insert(:note, data: %{"reactions" => %{}})
|
|
assert Utils.get_cached_emoji_reactions(object) == []
|
|
end
|
|
end
|
|
end
|