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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.FederatorTest do
   6   alias Pleroma.Instances
   7   alias Pleroma.Web.CommonAPI
   8   alias Pleroma.Web.Federator
   9   use Pleroma.DataCase
  10   import Pleroma.Factory
  11   import Mock
  12
  13   setup_all do
  14     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  15
  16     config_path = [:instance, :federating]
  17     initial_setting = Pleroma.Config.get(config_path)
  18
  19     Pleroma.Config.put(config_path, true)
  20     on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
  21
  22     :ok
  23   end
  24
  25   describe "Publisher.perform" do
  26     test "call `perform` with unknown task" do
  27       assert {
  28                :error,
  29                "Don't know what to do with this"
  30              } = Pleroma.Web.Federator.Publisher.perform("test", :ok, :ok)
  31     end
  32   end
  33
  34   describe "Publish an activity" do
  35     setup do
  36       user = insert(:user)
  37       {:ok, activity} = CommonAPI.post(user, %{"status" => "HI"})
  38
  39       relay_mock = {
  40         Pleroma.Web.ActivityPub.Relay,
  41         [],
  42         [publish: fn _activity -> send(self(), :relay_publish) end]
  43       }
  44
  45       %{activity: activity, relay_mock: relay_mock}
  46     end
  47
  48     test "with relays active, it publishes to the relay", %{
  49       activity: activity,
  50       relay_mock: relay_mock
  51     } do
  52       with_mocks([relay_mock]) do
  53         Federator.publish(activity)
  54       end
  55
  56       assert_received :relay_publish
  57     end
  58
  59     test "with relays deactivated, it does not publish to the relay", %{
  60       activity: activity,
  61       relay_mock: relay_mock
  62     } do
  63       Pleroma.Config.put([:instance, :allow_relay], false)
  64
  65       with_mocks([relay_mock]) do
  66         Federator.publish(activity)
  67       end
  68
  69       refute_received :relay_publish
  70
  71       Pleroma.Config.put([:instance, :allow_relay], true)
  72     end
  73   end
  74
  75   describe "Targets reachability filtering in `publish`" do
  76     test_with_mock "it federates only to reachable instances via AP",
  77                    Pleroma.Web.ActivityPub.Publisher,
  78                    [:passthrough],
  79                    [] do
  80       user = insert(:user)
  81
  82       {inbox1, inbox2} =
  83         {"https://domain.com/users/nick1/inbox", "https://domain2.com/users/nick2/inbox"}
  84
  85       insert(:user, %{
  86         local: false,
  87         nickname: "nick1@domain.com",
  88         ap_id: "https://domain.com/users/nick1",
  89         info: %{ap_enabled: true, source_data: %{"inbox" => inbox1}}
  90       })
  91
  92       insert(:user, %{
  93         local: false,
  94         nickname: "nick2@domain2.com",
  95         ap_id: "https://domain2.com/users/nick2",
  96         info: %{ap_enabled: true, source_data: %{"inbox" => inbox2}}
  97       })
  98
  99       dt = NaiveDateTime.utc_now()
 100       Instances.set_unreachable(inbox1, dt)
 101
 102       Instances.set_consistently_unreachable(URI.parse(inbox2).host)
 103
 104       {:ok, _activity} =
 105         CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})
 106
 107       assert called(
 108                Pleroma.Web.ActivityPub.Publisher.publish_one(%{
 109                  inbox: inbox1,
 110                  unreachable_since: dt
 111                })
 112              )
 113
 114       refute called(Pleroma.Web.ActivityPub.Publisher.publish_one(%{inbox: inbox2}))
 115     end
 116
 117     test_with_mock "it federates only to reachable instances via Websub",
 118                    Pleroma.Web.Websub,
 119                    [:passthrough],
 120                    [] do
 121       user = insert(:user)
 122       websub_topic = Pleroma.Web.OStatus.feed_path(user)
 123
 124       sub1 =
 125         insert(:websub_subscription, %{
 126           topic: websub_topic,
 127           state: "active",
 128           callback: "http://pleroma.soykaf.com/cb"
 129         })
 130
 131       sub2 =
 132         insert(:websub_subscription, %{
 133           topic: websub_topic,
 134           state: "active",
 135           callback: "https://pleroma2.soykaf.com/cb"
 136         })
 137
 138       dt = NaiveDateTime.utc_now()
 139       Instances.set_unreachable(sub2.callback, dt)
 140
 141       Instances.set_consistently_unreachable(sub1.callback)
 142
 143       {:ok, _activity} = CommonAPI.post(user, %{"status" => "HI"})
 144
 145       assert called(
 146                Pleroma.Web.Websub.publish_one(%{
 147                  callback: sub2.callback,
 148                  unreachable_since: dt
 149                })
 150              )
 151
 152       refute called(Pleroma.Web.Websub.publish_one(%{callback: sub1.callback}))
 153     end
 154
 155     test_with_mock "it federates only to reachable instances via Salmon",
 156                    Pleroma.Web.Salmon,
 157                    [:passthrough],
 158                    [] do
 159       user = insert(:user)
 160
 161       remote_user1 =
 162         insert(:user, %{
 163           local: false,
 164           nickname: "nick1@domain.com",
 165           ap_id: "https://domain.com/users/nick1",
 166           info: %{salmon: "https://domain.com/salmon"}
 167         })
 168
 169       remote_user2 =
 170         insert(:user, %{
 171           local: false,
 172           nickname: "nick2@domain2.com",
 173           ap_id: "https://domain2.com/users/nick2",
 174           info: %{salmon: "https://domain2.com/salmon"}
 175         })
 176
 177       dt = NaiveDateTime.utc_now()
 178       Instances.set_unreachable(remote_user2.ap_id, dt)
 179
 180       Instances.set_consistently_unreachable("domain.com")
 181
 182       {:ok, _activity} =
 183         CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})
 184
 185       assert called(
 186                Pleroma.Web.Salmon.publish_one(%{
 187                  recipient: remote_user2,
 188                  unreachable_since: dt
 189                })
 190              )
 191
 192       refute called(Pleroma.Web.Salmon.publish_one(%{recipient: remote_user1}))
 193     end
 194   end
 195
 196   describe "Receive an activity" do
 197     test "successfully processes incoming AP docs with correct origin" do
 198       params = %{
 199         "@context" => "https://www.w3.org/ns/activitystreams",
 200         "actor" => "http://mastodon.example.org/users/admin",
 201         "type" => "Create",
 202         "id" => "http://mastodon.example.org/users/admin/activities/1",
 203         "object" => %{
 204           "type" => "Note",
 205           "content" => "hi world!",
 206           "id" => "http://mastodon.example.org/users/admin/objects/1",
 207           "attributedTo" => "http://mastodon.example.org/users/admin"
 208         },
 209         "to" => ["https://www.w3.org/ns/activitystreams#Public"]
 210       }
 211
 212       {:ok, _activity} = Federator.incoming_ap_doc(params)
 213     end
 214
 215     test "rejects incoming AP docs with incorrect origin" do
 216       params = %{
 217         "@context" => "https://www.w3.org/ns/activitystreams",
 218         "actor" => "https://niu.moe/users/rye",
 219         "type" => "Create",
 220         "id" => "http://mastodon.example.org/users/admin/activities/1",
 221         "object" => %{
 222           "type" => "Note",
 223           "content" => "hi world!",
 224           "id" => "http://mastodon.example.org/users/admin/objects/1",
 225           "attributedTo" => "http://mastodon.example.org/users/admin"
 226         },
 227         "to" => ["https://www.w3.org/ns/activitystreams#Public"]
 228       }
 229
 230       :error = Federator.incoming_ap_doc(params)
 231     end
 232   end
 233 end