git.squeep.com Git - akkoma/blob - test/web/admin_api/config_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.ConfigTest do
   6   use Pleroma.DataCase, async: true
   7   import Pleroma.Factory
   8   alias Pleroma.Web.AdminAPI.Config
   9
  10   test "get_by_key/1" do
  11     config = insert(:config)
  12     insert(:config)
  13
  14     assert config == Config.get_by_params(%{group: config.group, key: config.key})
  15   end
  16
  17   test "create/1" do
  18     {:ok, config} = Config.create(%{group: "pleroma", key: "some_key", value: "some_value"})
  19     assert config == Config.get_by_params(%{group: "pleroma", key: "some_key"})
  20   end
  21
  22   test "update/1" do
  23     config = insert(:config)
  24     {:ok, updated} = Config.update(config, %{value: "some_value"})
  25     loaded = Config.get_by_params(%{group: config.group, key: config.key})
  26     assert loaded == updated
  27   end
  28
  29   test "update_or_create/1" do
  30     config = insert(:config)
  31     key2 = "another_key"
  32
  33     params = [
  34       %{group: "pleroma", key: key2, value: "another_value"},
  35       %{group: config.group, key: config.key, value: "new_value"}
  36     ]
  37
  38     assert Repo.all(Config) |> length() == 1
  39
  40     Enum.each(params, &Config.update_or_create(&1))
  41
  42     assert Repo.all(Config) |> length() == 2
  43
  44     config1 = Config.get_by_params(%{group: config.group, key: config.key})
  45     config2 = Config.get_by_params(%{group: "pleroma", key: key2})
  46
  47     assert config1.value == Config.transform("new_value")
  48     assert config2.value == Config.transform("another_value")
  49   end
  50
  51   test "delete/1" do
  52     config = insert(:config)
  53     {:ok, _} = Config.delete(%{key: config.key, group: config.group})
  54     refute Config.get_by_params(%{key: config.key, group: config.group})
  55   end
  56
  57   describe "transform/1" do
  58     test "string" do
  59       binary = Config.transform("value as string")
  60       assert binary == :erlang.term_to_binary("value as string")
  61       assert Config.from_binary(binary) == "value as string"
  62     end
  63
  64     test "list of modules" do
  65       binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
  66       assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
  67       assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
  68     end
  69
  70     test "list of strings" do
  71       binary = Config.transform(["string1", "string2"])
  72       assert binary == :erlang.term_to_binary(["string1", "string2"])
  73       assert Config.from_binary(binary) == ["string1", "string2"]
  74     end
  75
  76     test "map" do
  77       binary =
  78         Config.transform(%{
  79           "types" => "Pleroma.PostgresTypes",
  80           "telemetry_event" => ["Pleroma.Repo.Instrumenter"],
  81           "migration_lock" => ""
  82         })
  83
  84       assert binary ==
  85                :erlang.term_to_binary(
  86                  telemetry_event: [Pleroma.Repo.Instrumenter],
  87                  types: Pleroma.PostgresTypes
  88                )
  89
  90       assert Config.from_binary(binary) == [
  91                telemetry_event: [Pleroma.Repo.Instrumenter],
  92                types: Pleroma.PostgresTypes
  93              ]
  94     end
  95
  96     test "complex map with nested integers, lists and atoms" do
  97       binary =
  98         Config.transform(%{
  99           "uploader" => "Pleroma.Uploaders.Local",
 100           "filters" => ["Pleroma.Upload.Filter.Dedupe"],
 101           "link_name" => ":true",
 102           "proxy_remote" => ":false",
 103           "proxy_opts" => %{
 104             "redirect_on_failure" => ":false",
 105             "max_body_length" => "i:1048576",
 106             "http" => %{
 107               "follow_redirect" => ":true",
 108               "pool" => ":upload"
 109             }
 110           }
 111         })
 112
 113       assert binary ==
 114                :erlang.term_to_binary(
 115                  filters: [Pleroma.Upload.Filter.Dedupe],
 116                  link_name: true,
 117                  proxy_opts: [
 118                    http: [
 119                      follow_redirect: true,
 120                      pool: :upload
 121                    ],
 122                    max_body_length: 1_048_576,
 123                    redirect_on_failure: false
 124                  ],
 125                  proxy_remote: false,
 126                  uploader: Pleroma.Uploaders.Local
 127                )
 128
 129       assert Config.from_binary(binary) ==
 130                [
 131                  filters: [Pleroma.Upload.Filter.Dedupe],
 132                  link_name: true,
 133                  proxy_opts: [
 134                    http: [
 135                      follow_redirect: true,
 136                      pool: :upload
 137                    ],
 138                    max_body_length: 1_048_576,
 139                    redirect_on_failure: false
 140                  ],
 141                  proxy_remote: false,
 142                  uploader: Pleroma.Uploaders.Local
 143                ]
 144     end
 145
 146     test "keyword" do
 147       binary =
 148         Config.transform(%{
 149           "level" => ":warn",
 150           "meta" => [":all"],
 151           "webhook_url" => "https://hooks.slack.com/services/YOUR-KEY-HERE"
 152         })
 153
 154       assert binary ==
 155                :erlang.term_to_binary(
 156                  level: :warn,
 157                  meta: [:all],
 158                  webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 159                )
 160
 161       assert Config.from_binary(binary) == [
 162                level: :warn,
 163                meta: [:all],
 164                webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 165              ]
 166     end
 167
 168     test "complex map with sigil" do
 169       binary =
 170         Config.transform(%{
 171           federated_timeline_removal: [],
 172           reject: [~r/comp[lL][aA][iI][nN]er/],
 173           replace: []
 174         })
 175
 176       assert binary ==
 177                :erlang.term_to_binary(
 178                  federated_timeline_removal: [],
 179                  reject: [~r/comp[lL][aA][iI][nN]er/],
 180                  replace: []
 181                )
 182
 183       assert Config.from_binary(binary) ==
 184                [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
 185     end
 186
 187     test "complex map with tuples with more than 2 values" do
 188       binary =
 189         Config.transform(%{
 190           "http" => %{
 191             "dispatch" => [
 192               %{
 193                 "tuple" => [
 194                   ":_",
 195                   [
 196                     %{
 197                       "tuple" => [
 198                         "/api/v1/streaming",
 199                         "Pleroma.Web.MastodonAPI.WebsocketHandler",
 200                         []
 201                       ]
 202                     },
 203                     %{
 204                       "tuple" => [
 205                         "/websocket",
 206                         "Phoenix.Endpoint.CowboyWebSocket",
 207                         %{
 208                           "tuple" => [
 209                             "Phoenix.Transports.WebSocket",
 210                             %{"tuple" => ["Pleroma.Web.Endpoint", "Pleroma.Web.UserSocket", []]}
 211                           ]
 212                         }
 213                       ]
 214                     },
 215                     %{
 216                       "tuple" => [
 217                         ":_",
 218                         "Phoenix.Endpoint.Cowboy2Handler",
 219                         %{
 220                           "tuple" => ["Pleroma.Web.Endpoint", []]
 221                         }
 222                       ]
 223                     }
 224                   ]
 225                 ]
 226               }
 227             ]
 228           }
 229         })
 230
 231       assert binary ==
 232                :erlang.term_to_binary(
 233                  http: [
 234                    dispatch: [
 235                      _: [
 236                        {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 237                        {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 238                         {Phoenix.Transports.WebSocket,
 239                          {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
 240                        {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 241                      ]
 242                    ]
 243                  ]
 244                )
 245
 246       assert Config.from_binary(binary) == [
 247                http: [
 248                  dispatch: [
 249                    {:_,
 250                     [
 251                       {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 252                       {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 253                        {Phoenix.Transports.WebSocket,
 254                         {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
 255                       {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 256                     ]}
 257                  ]
 258                ]
 259              ]
 260     end
 261   end
 262 end