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