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.Web.CommonAPI
   7   alias Pleroma.Web.Federator
   8   alias Pleroma.Instances
   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     :ok
  16   end
  17
  18   test "enqueues an element according to priority" do
  19     queue = [%{item: 1, priority: 2}]
  20
  21     new_queue = Federator.enqueue_sorted(queue, 2, 1)
  22     assert new_queue == [%{item: 2, priority: 1}, %{item: 1, priority: 2}]
  23
  24     new_queue = Federator.enqueue_sorted(queue, 2, 3)
  25     assert new_queue == [%{item: 1, priority: 2}, %{item: 2, priority: 3}]
  26   end
  27
  28   test "pop first item" do
  29     queue = [%{item: 2, priority: 1}, %{item: 1, priority: 2}]
  30
  31     assert {2, [%{item: 1, priority: 2}]} = Federator.queue_pop(queue)
  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.handle(: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.handle(: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                    Federator,
  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                Federator.enqueue(:publish_single_ap, %{inbox: inbox1, unreachable_since: dt})
 109              )
 110
 111       refute called(Federator.enqueue(:publish_single_ap, %{inbox: inbox2}))
 112     end
 113
 114     test_with_mock "it federates only to reachable instances via Websub",
 115                    Federator,
 116                    [:passthrough],
 117                    [] do
 118       user = insert(:user)
 119       websub_topic = Pleroma.Web.OStatus.feed_path(user)
 120
 121       sub1 =
 122         insert(:websub_subscription, %{
 123           topic: websub_topic,
 124           state: "active",
 125           callback: "http://pleroma.soykaf.com/cb"
 126         })
 127
 128       sub2 =
 129         insert(:websub_subscription, %{
 130           topic: websub_topic,
 131           state: "active",
 132           callback: "https://pleroma2.soykaf.com/cb"
 133         })
 134
 135       dt = NaiveDateTime.utc_now()
 136       Instances.set_unreachable(sub2.callback, dt)
 137
 138       Instances.set_consistently_unreachable(sub1.callback)
 139
 140       {:ok, _activity} = CommonAPI.post(user, %{"status" => "HI"})
 141
 142       assert called(
 143                Federator.enqueue(:publish_single_websub, %{
 144                  callback: sub2.callback,
 145                  unreachable_since: dt
 146                })
 147              )
 148
 149       refute called(Federator.enqueue(:publish_single_websub, %{callback: sub1.callback}))
 150     end
 151
 152     test_with_mock "it federates only to reachable instances via Salmon",
 153                    Federator,
 154                    [:passthrough],
 155                    [] do
 156       user = insert(:user)
 157
 158       remote_user1 =
 159         insert(:user, %{
 160           local: false,
 161           nickname: "nick1@domain.com",
 162           ap_id: "https://domain.com/users/nick1",
 163           info: %{salmon: "https://domain.com/salmon"}
 164         })
 165
 166       remote_user2 =
 167         insert(:user, %{
 168           local: false,
 169           nickname: "nick2@domain2.com",
 170           ap_id: "https://domain2.com/users/nick2",
 171           info: %{salmon: "https://domain2.com/salmon"}
 172         })
 173
 174       dt = NaiveDateTime.utc_now()
 175       Instances.set_unreachable(remote_user2.ap_id, dt)
 176
 177       Instances.set_consistently_unreachable("domain.com")
 178
 179       {:ok, _activity} =
 180         CommonAPI.post(user, %{"status" => "HI @nick1@domain.com, @nick2@domain2.com!"})
 181
 182       assert called(
 183                Federator.enqueue(:publish_single_salmon, %{
 184                  recipient: remote_user2,
 185                  unreachable_since: dt
 186                })
 187              )
 188
 189       refute called(Federator.enqueue(:publish_single_websub, %{recipient: remote_user1}))
 190     end
 191   end
 192
 193   describe "Receive an activity" do
 194     test "successfully processes incoming AP docs with correct origin" do
 195       params = %{
 196         "@context" => "https://www.w3.org/ns/activitystreams",
 197         "actor" => "http://mastodon.example.org/users/admin",
 198         "type" => "Create",
 199         "id" => "http://mastodon.example.org/users/admin/activities/1",
 200         "object" => %{
 201           "type" => "Note",
 202           "content" => "hi world!",
 203           "id" => "http://mastodon.example.org/users/admin/objects/1",
 204           "attributedTo" => "http://mastodon.example.org/users/admin"
 205         },
 206         "to" => ["https://www.w3.org/ns/activitystreams#Public"]
 207       }
 208
 209       {:ok, _activity} = Federator.handle(:incoming_ap_doc, params)
 210     end
 211
 212     test "rejects incoming AP docs with incorrect origin" do
 213       params = %{
 214         "@context" => "https://www.w3.org/ns/activitystreams",
 215         "actor" => "https://niu.moe/users/rye",
 216         "type" => "Create",
 217         "id" => "http://mastodon.example.org/users/admin/activities/1",
 218         "object" => %{
 219           "type" => "Note",
 220           "content" => "hi world!",
 221           "id" => "http://mastodon.example.org/users/admin/objects/1",
 222           "attributedTo" => "http://mastodon.example.org/users/admin"
 223         },
 224         "to" => ["https://www.w3.org/ns/activitystreams#Public"]
 225       }
 226
 227       :error = Federator.handle(:incoming_ap_doc, params)
 228     end
 229   end
 230 end