git.squeep.com Git - akkoma/blob - test/web/activity_pub/relay_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.RelayTest do
   6   use Pleroma.DataCase
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.User
  10   alias Pleroma.Web.ActivityPub.ActivityPub
  11   alias Pleroma.Web.ActivityPub.Relay
  12
  13   import ExUnit.CaptureLog
  14   import Pleroma.Factory
  15   import Mock
  16
  17   test "gets an actor for the relay" do
  18     user = Relay.get_actor()
  19     assert user.ap_id == "#{Pleroma.Web.Endpoint.url()}/relay"
  20   end
  21
  22   test "relay actor is invisible" do
  23     user = Relay.get_actor()
  24     assert User.invisible?(user)
  25   end
  26
  27   describe "follow/1" do
  28     test "returns errors when user not found" do
  29       assert capture_log(fn ->
  30                {:error, _} = Relay.follow("test-ap-id")
  31              end) =~ "Could not decode user at fetch"
  32     end
  33
  34     test "returns activity" do
  35       user = insert(:user)
  36       service_actor = Relay.get_actor()
  37       assert {:ok, %Activity{} = activity} = Relay.follow(user.ap_id)
  38       assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
  39       assert user.ap_id in activity.recipients
  40       assert activity.data["type"] == "Follow"
  41       assert activity.data["actor"] == service_actor.ap_id
  42       assert activity.data["object"] == user.ap_id
  43     end
  44   end
  45
  46   describe "unfollow/1" do
  47     test "returns errors when user not found" do
  48       assert capture_log(fn ->
  49                {:error, _} = Relay.unfollow("test-ap-id")
  50              end) =~ "Could not decode user at fetch"
  51     end
  52
  53     test "returns activity" do
  54       user = insert(:user)
  55       service_actor = Relay.get_actor()
  56       ActivityPub.follow(service_actor, user)
  57       Pleroma.User.follow(service_actor, user)
  58       assert "#{user.ap_id}/followers" in User.following(service_actor)
  59       assert {:ok, %Activity{} = activity} = Relay.unfollow(user.ap_id)
  60       assert activity.actor == "#{Pleroma.Web.Endpoint.url()}/relay"
  61       assert user.ap_id in activity.recipients
  62       assert activity.data["type"] == "Undo"
  63       assert activity.data["actor"] == service_actor.ap_id
  64       assert activity.data["to"] == [user.ap_id]
  65       refute "#{user.ap_id}/followers" in User.following(service_actor)
  66     end
  67   end
  68
  69   describe "publish/1" do
  70     setup do: clear_config([:instance, :federating])
  71
  72     test "returns error when activity not `Create` type" do
  73       activity = insert(:like_activity)
  74       assert Relay.publish(activity) == {:error, "Not implemented"}
  75     end
  76
  77     test "returns error when activity not public" do
  78       activity = insert(:direct_note_activity)
  79       assert Relay.publish(activity) == {:error, false}
  80     end
  81
  82     test "returns error when object is unknown" do
  83       activity =
  84         insert(:note_activity,
  85           data: %{
  86             "type" => "Create",
  87             "object" => "http://mastodon.example.org/eee/99541947525187367"
  88           }
  89         )
  90
  91       Tesla.Mock.mock(fn
  92         %{method: :get, url: "http://mastodon.example.org/eee/99541947525187367"} ->
  93           %Tesla.Env{status: 500, body: ""}
  94       end)
  95
  96       assert capture_log(fn ->
  97                assert Relay.publish(activity) == {:error, false}
  98              end) =~ "[error] error: false"
  99     end
 100
 101     test_with_mock "returns announce activity and publish to federate",
 102                    Pleroma.Web.Federator,
 103                    [:passthrough],
 104                    [] do
 105       clear_config([:instance, :federating], true)
 106       service_actor = Relay.get_actor()
 107       note = insert(:note_activity)
 108       assert {:ok, %Activity{} = activity} = Relay.publish(note)
 109       assert activity.data["type"] == "Announce"
 110       assert activity.data["actor"] == service_actor.ap_id
 111       assert activity.data["to"] == [service_actor.follower_address]
 112       assert called(Pleroma.Web.Federator.publish(activity))
 113     end
 114
 115     test_with_mock "returns announce activity and not publish to federate",
 116                    Pleroma.Web.Federator,
 117                    [:passthrough],
 118                    [] do
 119       clear_config([:instance, :federating], false)
 120       service_actor = Relay.get_actor()
 121       note = insert(:note_activity)
 122       assert {:ok, %Activity{} = activity} = Relay.publish(note)
 123       assert activity.data["type"] == "Announce"
 124       assert activity.data["actor"] == service_actor.ap_id
 125       refute called(Pleroma.Web.Federator.publish(activity))
 126     end
 127   end
 128 end