Git of dcc - anni/blob - test/pleroma/web/node_info_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 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, async: false
   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 roles and privileges", %{conn: conn} do
  44     clear_config([:instance, :moderator_privileges], [:cofe])
  45     clear_config([:instance, :admin_privileges], [:suya, :cofe])
  46
  47     conn =
  48       conn
  49       |> get("/nodeinfo/2.1.json")
  50
  51     assert result = json_response(conn, 200)
  52
  53     assert %{"admin" => ["suya", "cofe"], "moderator" => ["cofe"]} == result["metadata"]["roles"]
  54   end
  55
  56   test "nodeinfo shows restricted nicknames", %{conn: conn} do
  57     conn =
  58       conn
  59       |> get("/nodeinfo/2.1.json")
  60
  61     assert result = json_response(conn, 200)
  62
  63     assert Config.get([Pleroma.User, :restricted_nicknames]) ==
  64              result["metadata"]["restrictedNicknames"]
  65   end
  66
  67   test "returns software.repository field in nodeinfo 2.1", %{conn: conn} do
  68     conn
  69     |> get("/.well-known/nodeinfo")
  70     |> json_response(200)
  71
  72     conn =
  73       conn
  74       |> get("/nodeinfo/2.1.json")
  75
  76     assert result = json_response(conn, 200)
  77     assert Pleroma.Application.repository() == result["software"]["repository"]
  78   end
  79
  80   test "returns fieldsLimits field", %{conn: conn} do
  81     clear_config([:instance, :max_account_fields], 10)
  82     clear_config([:instance, :max_remote_account_fields], 15)
  83     clear_config([:instance, :account_field_name_length], 255)
  84     clear_config([:instance, :account_field_value_length], 2048)
  85
  86     response =
  87       conn
  88       |> get("/nodeinfo/2.1.json")
  89       |> json_response(:ok)
  90
  91     assert response["metadata"]["fieldsLimits"]["maxFields"] == 10
  92     assert response["metadata"]["fieldsLimits"]["maxRemoteFields"] == 15
  93     assert response["metadata"]["fieldsLimits"]["nameLength"] == 255
  94     assert response["metadata"]["fieldsLimits"]["valueLength"] == 2048
  95   end
  96
  97   test "it returns the safe_dm_mentions feature if enabled", %{conn: conn} do
  98     clear_config([:instance, :safe_dm_mentions], true)
  99
 100     response =
 101       conn
 102       |> get("/nodeinfo/2.1.json")
 103       |> json_response(:ok)
 104
 105     assert "safe_dm_mentions" in response["metadata"]["features"]
 106
 107     clear_config([:instance, :safe_dm_mentions], false)
 108
 109     response =
 110       conn
 111       |> get("/nodeinfo/2.1.json")
 112       |> json_response(:ok)
 113
 114     refute "safe_dm_mentions" in response["metadata"]["features"]
 115   end
 116
 117   describe "`metadata/federation/enabled`" do
 118     setup do: clear_config([:instance, :federating])
 119
 120     test "it shows if federation is enabled/disabled", %{conn: conn} do
 121       clear_config([:instance, :federating], true)
 122
 123       response =
 124         conn
 125         |> get("/nodeinfo/2.1.json")
 126         |> json_response(:ok)
 127
 128       assert response["metadata"]["federation"]["enabled"] == true
 129
 130       clear_config([:instance, :federating], false)
 131
 132       response =
 133         conn
 134         |> get("/nodeinfo/2.1.json")
 135         |> json_response(:ok)
 136
 137       assert response["metadata"]["federation"]["enabled"] == false
 138     end
 139   end
 140
 141   test "it shows default features flags", %{conn: conn} do
 142     response =
 143       conn
 144       |> get("/nodeinfo/2.1.json")
 145       |> json_response(:ok)
 146
 147     default_features = [
 148       "pleroma_api",
 149       "mastodon_api",
 150       "mastodon_api_streaming",
 151       "polls",
 152       "pleroma_explicit_addressing",
 153       "shareable_emoji_packs",
 154       "multifetch",
 155       "pleroma_emoji_reactions",
 156       "pleroma:api/v1/notifications:include_types_filter",
 157       "pleroma_chat_messages"
 158     ]
 159
 160     assert MapSet.subset?(
 161              MapSet.new(default_features),
 162              MapSet.new(response["metadata"]["features"])
 163            )
 164   end
 165
 166   describe "Quarantined instances" do
 167     setup do
 168       clear_config([:mrf, :transparency], true)
 169       quarantined_instances = [{"example.com", "reason to quarantine"}]
 170       clear_config([:instance, :quarantined_instances], quarantined_instances)
 171     end
 172
 173     test "shows quarantined instances data if enabled", %{conn: conn} do
 174       expected_config = ["example.com"]
 175
 176       response =
 177         conn
 178         |> get("/nodeinfo/2.1.json")
 179         |> json_response(:ok)
 180
 181       assert response["metadata"]["federation"]["quarantined_instances"] == expected_config
 182     end
 183
 184     test "shows extra information in the quarantined_info field for relevant entries", %{
 185       conn: conn
 186     } do
 187       clear_config([:mrf, :transparency], true)
 188
 189       expected_config = %{
 190         "quarantined_instances" => %{
 191           "example.com" => %{"reason" => "reason to quarantine"}
 192         }
 193       }
 194
 195       response =
 196         conn
 197         |> get("/nodeinfo/2.1.json")
 198         |> json_response(:ok)
 199
 200       assert response["metadata"]["federation"]["quarantined_instances_info"] == expected_config
 201     end
 202   end
 203
 204   describe "MRF SimplePolicy" do
 205     setup do
 206       clear_config([:mrf, :policies], [Pleroma.Web.ActivityPub.MRF.SimplePolicy])
 207       clear_config([:mrf, :transparency], true)
 208     end
 209
 210     test "shows MRF transparency data if enabled", %{conn: conn} do
 211       simple_config = %{"reject" => [{"example.com", ""}]}
 212       clear_config(:mrf_simple, simple_config)
 213
 214       expected_config = %{"reject" => ["example.com"]}
 215
 216       response =
 217         conn
 218         |> get("/nodeinfo/2.1.json")
 219         |> json_response(:ok)
 220
 221       assert response["metadata"]["federation"]["mrf_simple"] == expected_config
 222     end
 223
 224     test "performs exclusions from MRF transparency data if configured", %{conn: conn} do
 225       clear_config([:mrf, :transparency_exclusions], [
 226         {"other.site", "We don't want them to know"}
 227       ])
 228
 229       simple_config = %{"reject" => [{"example.com", ""}, {"other.site", ""}]}
 230       clear_config(:mrf_simple, simple_config)
 231
 232       expected_config = %{"reject" => ["example.com"]}
 233
 234       response =
 235         conn
 236         |> get("/nodeinfo/2.1.json")
 237         |> json_response(:ok)
 238
 239       assert response["metadata"]["federation"]["mrf_simple"] == expected_config
 240       assert response["metadata"]["federation"]["exclusions"] == true
 241     end
 242
 243     test "shows extra information in the mrf_simple_info field for relevant entries", %{
 244       conn: conn
 245     } do
 246       simple_config = %{
 247         media_removal: [{"no.media", "LEEWWWDD >//<"}],
 248         media_nsfw: [],
 249         federated_timeline_removal: [{"no.ftl", ""}],
 250         report_removal: [],
 251         reject: [
 252           {"example.instance", "Some reason"},
 253           {"uwu.owo", "awoo to much"},
 254           {"no.reason", ""}
 255         ],
 256         followers_only: [],
 257         accept: [],
 258         avatar_removal: [],
 259         banner_removal: [],
 260         reject_deletes: [
 261           {"peak.me", "I want to peak at what they don't want me to see, eheh"}
 262         ]
 263       }
 264
 265       clear_config(:mrf_simple, simple_config)
 266
 267       clear_config([:mrf, :transparency_exclusions], [
 268         {"peak.me", "I don't want them to know"}
 269       ])
 270
 271       expected_config = %{
 272         "media_removal" => %{
 273           "no.media" => %{"reason" => "LEEWWWDD >//<"}
 274         },
 275         "reject" => %{
 276           "example.instance" => %{"reason" => "Some reason"},
 277           "uwu.owo" => %{"reason" => "awoo to much"}
 278         }
 279       }
 280
 281       response =
 282         conn
 283         |> get("/nodeinfo/2.1.json")
 284         |> json_response(:ok)
 285
 286       assert response["metadata"]["federation"]["mrf_simple_info"] == expected_config
 287     end
 288   end
 289 end