git.squeep.com Git - akkoma/blob - test/pleroma/web/node_info_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.NodeInfoTest do
   6   use Pleroma.Web.ConnCase
   7
   8   import Pleroma.Factory
   9
  10   setup do: clear_config([:mrf_simple])
  11   setup do: clear_config(:instance)
  12
  13   test "GET /.well-known/nodeinfo", %{conn: conn} do
  14     links =
  15       conn
  16       |> get("/.well-known/nodeinfo")
  17       |> json_response(200)
  18       |> Map.fetch!("links")
  19
  20     Enum.each(links, fn link ->
  21       href = Map.fetch!(link, "href")
  22
  23       conn
  24       |> get(href)
  25       |> json_response(200)
  26     end)
  27   end
  28
  29   test "nodeinfo shows staff accounts", %{conn: conn} do
  30     moderator = insert(:user, local: true, is_moderator: true)
  31     admin = insert(:user, local: true, is_admin: true)
  32
  33     conn =
  34       conn
  35       |> get("/nodeinfo/2.1.json")
  36
  37     assert result = json_response(conn, 200)
  38
  39     assert moderator.ap_id in result["metadata"]["staffAccounts"]
  40     assert admin.ap_id in result["metadata"]["staffAccounts"]
  41   end
  42
  43   test "nodeinfo shows restricted nicknames", %{conn: conn} do
  44     conn =
  45       conn
  46       |> get("/nodeinfo/2.1.json")
  47
  48     assert result = json_response(conn, 200)
  49
  50     assert Config.get([Pleroma.User, :restricted_nicknames]) ==
  51              result["metadata"]["restrictedNicknames"]
  52   end
  53
  54   test "returns software.repository field in nodeinfo 2.1", %{conn: conn} do
  55     conn
  56     |> get("/.well-known/nodeinfo")
  57     |> json_response(200)
  58
  59     conn =
  60       conn
  61       |> get("/nodeinfo/2.1.json")
  62
  63     assert result = json_response(conn, 200)
  64     assert Pleroma.Application.repository() == result["software"]["repository"]
  65   end
  66
  67   test "returns fieldsLimits field", %{conn: conn} do
  68     clear_config([:instance, :max_account_fields], 10)
  69     clear_config([:instance, :max_remote_account_fields], 15)
  70     clear_config([:instance, :account_field_name_length], 255)
  71     clear_config([:instance, :account_field_value_length], 2048)
  72
  73     response =
  74       conn
  75       |> get("/nodeinfo/2.1.json")
  76       |> json_response(:ok)
  77
  78     assert response["metadata"]["fieldsLimits"]["maxFields"] == 10
  79     assert response["metadata"]["fieldsLimits"]["maxRemoteFields"] == 15
  80     assert response["metadata"]["fieldsLimits"]["nameLength"] == 255
  81     assert response["metadata"]["fieldsLimits"]["valueLength"] == 2048
  82   end
  83
  84   test "it returns the safe_dm_mentions feature if enabled", %{conn: conn} do
  85     clear_config([:instance, :safe_dm_mentions], true)
  86
  87     response =
  88       conn
  89       |> get("/nodeinfo/2.1.json")
  90       |> json_response(:ok)
  91
  92     assert "safe_dm_mentions" in response["metadata"]["features"]
  93
  94     clear_config([:instance, :safe_dm_mentions], false)
  95
  96     response =
  97       conn
  98       |> get("/nodeinfo/2.1.json")
  99       |> json_response(:ok)
 100
 101     refute "safe_dm_mentions" in response["metadata"]["features"]
 102   end
 103
 104   describe "`metadata/federation/enabled`" do
 105     setup do: clear_config([:instance, :federating])
 106
 107     test "it shows if federation is enabled/disabled", %{conn: conn} do
 108       clear_config([:instance, :federating], true)
 109
 110       response =
 111         conn
 112         |> get("/nodeinfo/2.1.json")
 113         |> json_response(:ok)
 114
 115       assert response["metadata"]["federation"]["enabled"] == true
 116
 117       clear_config([:instance, :federating], false)
 118
 119       response =
 120         conn
 121         |> get("/nodeinfo/2.1.json")
 122         |> json_response(:ok)
 123
 124       assert response["metadata"]["federation"]["enabled"] == false
 125     end
 126   end
 127
 128   test "it shows default features flags", %{conn: conn} do
 129     response =
 130       conn
 131       |> get("/nodeinfo/2.1.json")
 132       |> json_response(:ok)
 133
 134     default_features = [
 135       "pleroma_api",
 136       "mastodon_api",
 137       "mastodon_api_streaming",
 138       "polls",
 139       "pleroma_explicit_addressing",
 140       "shareable_emoji_packs",
 141       "multifetch",
 142       "pleroma_emoji_reactions",
 143       "pleroma:api/v1/notifications:include_types_filter",
 144       "pleroma_chat_messages"
 145     ]
 146
 147     assert MapSet.subset?(
 148              MapSet.new(default_features),
 149              MapSet.new(response["metadata"]["features"])
 150            )
 151   end
 152
 153   test "it shows quarantined instances data if enabled", %{conn: conn} do
 154     clear_config([:mrf, :transparency], true)
 155
 156     quarantined_instances = [{"example.com", ""}]
 157     clear_config([:instance, :quarantined_instances], quarantined_instances)
 158
 159     expected_config = [%{"instance" => "example.com", "reason" => ""}]
 160
 161     response =
 162       conn
 163       |> get("/nodeinfo/2.1.json")
 164       |> json_response(:ok)
 165
 166     assert response["metadata"]["federation"]["quarantined_instances"] == expected_config
 167   end
 168
 169   describe "MRF SimplePolicy" do
 170     setup do
 171       clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])
 172       clear_config([:mrf, :transparency], true)
 173     end
 174
 175     test "shows MRF transparency data if enabled", %{conn: conn} do
 176       simple_config = %{"reject" => [{"example.com", ""}]}
 177       clear_config(:mrf_simple, simple_config)
 178
 179       expected_config = %{"reject" => ["example.com"]}
 180
 181       response =
 182         conn
 183         |> get("/nodeinfo/2.1.json")
 184         |> json_response(:ok)
 185
 186       assert response["metadata"]["federation"]["mrf_simple"] == expected_config
 187     end
 188
 189     test "performs exclusions from MRF transparency data if configured", %{conn: conn} do
 190       clear_config([:mrf, :transparency_exclusions], [
 191         {"other.site", "We don't want them to know"}
 192       ])
 193
 194       simple_config = %{"reject" => [{"example.com", ""}, {"other.site", ""}]}
 195       clear_config(:mrf_simple, simple_config)
 196
 197       expected_config = %{"reject" => ["example.com"]}
 198
 199       response =
 200         conn
 201         |> get("/nodeinfo/2.1.json")
 202         |> json_response(:ok)
 203
 204       assert response["metadata"]["federation"]["mrf_simple"] == expected_config
 205       assert response["metadata"]["federation"]["exclusions"] == true
 206     end
 207
 208     test "shows extra information in the mrf_simple_extra field for relevant entries", %{
 209       conn: conn
 210     } do
 211       simple_config = %{
 212         media_removal: [{"no.media", "LEEWWWDD >//<"}],
 213         media_nsfw: [],
 214         federated_timeline_removal: [{"no.ftl", ""}],
 215         report_removal: [],
 216         reject: [
 217           {"example.instance", "Some reason"},
 218           {"uwu.owo", "awoo to much"},
 219           {"no.reason", ""}
 220         ],
 221         followers_only: [],
 222         accept: [],
 223         avatar_removal: [],
 224         banner_removal: [],
 225         reject_deletes: [
 226           {"peak.me", "I want to peak at what they don't want me to see, eheh"}
 227         ]
 228       }
 229
 230       clear_config(:mrf_simple, simple_config)
 231
 232       clear_config([:mrf, :transparency_exclusions], [
 233         {"peak.me", "I don't want them to know"}
 234       ])
 235
 236       expected_config = %{
 237         "media_removal" => %{
 238           "no.media" => %{"reason" => "LEEWWWDD >//<"}
 239         },
 240         "reject" => %{
 241           "example.instance" => %{"reason" => "Some reason"},
 242           "uwu.owo" => %{"reason" => "awoo to much"}
 243         }
 244       }
 245
 246       response =
 247         conn
 248         |> get("/nodeinfo/2.1.json")
 249         |> json_response(:ok)
 250
 251       assert response["metadata"]["federation"]["mrf_simple_info"] == expected_config
 252     end
 253   end
 254 end