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