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