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

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