git.squeep.com Git - akkoma/blob - test/web/websub/websub_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.WebsubTest do
   6   use Pleroma.DataCase
   7   use Oban.Testing, repo: Pleroma.Repo
   8
   9   alias Pleroma.Tests.ObanHelpers
  10   alias Pleroma.Web.Router.Helpers
  11   alias Pleroma.Web.Websub
  12   alias Pleroma.Web.Websub.WebsubClientSubscription
  13   alias Pleroma.Web.Websub.WebsubServerSubscription
  14   alias Pleroma.Workers.Subscriber, as: SubscriberWorker
  15
  16   import Pleroma.Factory
  17   import Tesla.Mock
  18
  19   setup do
  20     mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
  21     :ok
  22   end
  23
  24   test "a verification of a request that is accepted" do
  25     sub = insert(:websub_subscription)
  26     topic = sub.topic
  27
  28     getter = fn _path, _headers, options ->
  29       %{
  30         "hub.challenge": challenge,
  31         "hub.lease_seconds": seconds,
  32         "hub.topic": ^topic,
  33         "hub.mode": "subscribe"
  34       } = Keyword.get(options, :params)
  35
  36       assert String.to_integer(seconds) > 0
  37
  38       {:ok,
  39        %Tesla.Env{
  40          status: 200,
  41          body: challenge
  42        }}
  43     end
  44
  45     {:ok, sub} = Websub.verify(sub, getter)
  46     assert sub.state == "active"
  47   end
  48
  49   test "a verification of a request that doesn't return 200" do
  50     sub = insert(:websub_subscription)
  51
  52     getter = fn _path, _headers, _options ->
  53       {:ok,
  54        %Tesla.Env{
  55          status: 500,
  56          body: ""
  57        }}
  58     end
  59
  60     {:error, sub} = Websub.verify(sub, getter)
  61     # Keep the current state.
  62     assert sub.state == "requested"
  63   end
  64
  65   test "an incoming subscription request" do
  66     user = insert(:user)
  67
  68     data = %{
  69       "hub.callback" => "http://example.org/sub",
  70       "hub.mode" => "subscribe",
  71       "hub.topic" => Pleroma.Web.OStatus.feed_path(user),
  72       "hub.secret" => "a random secret",
  73       "hub.lease_seconds" => "100"
  74     }
  75
  76     {:ok, subscription} = Websub.incoming_subscription_request(user, data)
  77     assert subscription.topic == Pleroma.Web.OStatus.feed_path(user)
  78     assert subscription.state == "requested"
  79     assert subscription.secret == "a random secret"
  80     assert subscription.callback == "http://example.org/sub"
  81   end
  82
  83   test "an incoming subscription request for an existing subscription" do
  84     user = insert(:user)
  85
  86     sub =
  87       insert(:websub_subscription, state: "accepted", topic: Pleroma.Web.OStatus.feed_path(user))
  88
  89     data = %{
  90       "hub.callback" => sub.callback,
  91       "hub.mode" => "subscribe",
  92       "hub.topic" => Pleroma.Web.OStatus.feed_path(user),
  93       "hub.secret" => "a random secret",
  94       "hub.lease_seconds" => "100"
  95     }
  96
  97     {:ok, subscription} = Websub.incoming_subscription_request(user, data)
  98     assert subscription.topic == Pleroma.Web.OStatus.feed_path(user)
  99     assert subscription.state == sub.state
 100     assert subscription.secret == "a random secret"
 101     assert subscription.callback == sub.callback
 102     assert length(Repo.all(WebsubServerSubscription)) == 1
 103     assert subscription.id == sub.id
 104   end
 105
 106   def accepting_verifier(subscription) do
 107     {:ok, %{subscription | state: "accepted"}}
 108   end
 109
 110   test "initiate a subscription for a given user and topic" do
 111     subscriber = insert(:user)
 112     user = insert(:user, %{info: %Pleroma.User.Info{topic: "some_topic", hub: "some_hub"}})
 113
 114     {:ok, websub} = Websub.subscribe(subscriber, user, &accepting_verifier/1)
 115     assert websub.subscribers == [subscriber.ap_id]
 116     assert websub.topic == "some_topic"
 117     assert websub.hub == "some_hub"
 118     assert is_binary(websub.secret)
 119     assert websub.user == user
 120     assert websub.state == "accepted"
 121   end
 122
 123   test "discovers the hub and canonical url" do
 124     topic = "https://mastodon.social/users/lambadalambda.atom"
 125
 126     {:ok, discovered} = Websub.gather_feed_data(topic)
 127
 128     expected = %{
 129       "hub" => "https://mastodon.social/api/push",
 130       "uri" => "https://mastodon.social/users/lambadalambda",
 131       "nickname" => "lambadalambda",
 132       "name" => "Critical Value",
 133       "host" => "mastodon.social",
 134       "bio" => "a cool dude.",
 135       "avatar" => %{
 136         "type" => "Image",
 137         "url" => [
 138           %{
 139             "href" =>
 140               "https://files.mastodon.social/accounts/avatars/000/000/264/original/1429214160519.gif?1492379244",
 141             "mediaType" => "image/gif",
 142             "type" => "Link"
 143           }
 144         ]
 145       }
 146     }
 147
 148     assert expected == discovered
 149   end
 150
 151   test "calls the hub, requests topic" do
 152     hub = "https://social.heldscal.la/main/push/hub"
 153     topic = "https://social.heldscal.la/api/statuses/user_timeline/23211.atom"
 154     websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})
 155
 156     poster = fn ^hub, {:form, data}, _headers ->
 157       assert Keyword.get(data, :"hub.mode") == "subscribe"
 158
 159       assert Keyword.get(data, :"hub.callback") ==
 160                Helpers.websub_url(
 161                  Pleroma.Web.Endpoint,
 162                  :websub_subscription_confirmation,
 163                  websub.id
 164                )
 165
 166       {:ok, %{status: 202}}
 167     end
 168
 169     task = Task.async(fn -> Websub.request_subscription(websub, poster) end)
 170
 171     change = Ecto.Changeset.change(websub, %{state: "accepted"})
 172     {:ok, _} = Repo.update(change)
 173
 174     {:ok, websub} = Task.await(task)
 175
 176     assert websub.state == "accepted"
 177   end
 178
 179   test "rejects the subscription if it can't be accepted" do
 180     hub = "https://social.heldscal.la/main/push/hub"
 181     topic = "https://social.heldscal.la/api/statuses/user_timeline/23211.atom"
 182     websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})
 183
 184     poster = fn ^hub, {:form, _data}, _headers ->
 185       {:ok, %{status: 202}}
 186     end
 187
 188     {:error, websub} = Websub.request_subscription(websub, poster, 1000)
 189     assert websub.state == "rejected"
 190
 191     websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})
 192
 193     poster = fn ^hub, {:form, _data}, _headers ->
 194       {:ok, %{status: 400}}
 195     end
 196
 197     {:error, websub} = Websub.request_subscription(websub, poster, 1000)
 198     assert websub.state == "rejected"
 199   end
 200
 201   test "sign a text" do
 202     signed = Websub.sign("secret", "text")
 203     assert signed == "B8392C23690CCF871F37EC270BE1582DEC57A503" |> String.downcase()
 204
 205     _signed = Websub.sign("secret", [["て"], ['す']])
 206   end
 207
 208   describe "renewing subscriptions" do
 209     test "it renews subscriptions that have less than a day of time left" do
 210       day = 60 * 60 * 24
 211       now = NaiveDateTime.utc_now()
 212
 213       still_good =
 214         insert(:websub_client_subscription, %{
 215           valid_until: NaiveDateTime.add(now, 2 * day),
 216           topic: "http://example.org/still_good",
 217           hub: "http://example.org/still_good",
 218           state: "accepted"
 219         })
 220
 221       needs_refresh =
 222         insert(:websub_client_subscription, %{
 223           valid_until: NaiveDateTime.add(now, day - 100),
 224           topic: "http://example.org/needs_refresh",
 225           hub: "http://example.org/needs_refresh",
 226           state: "accepted"
 227         })
 228
 229       _refresh = Websub.refresh_subscriptions()
 230       ObanHelpers.perform(all_enqueued(worker: SubscriberWorker))
 231
 232       assert still_good == Repo.get(WebsubClientSubscription, still_good.id)
 233       refute needs_refresh == Repo.get(WebsubClientSubscription, needs_refresh.id)
 234     end
 235   end
 236 end