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

   1 defmodule Pleroma.Web.AdminAPI.ConfigTest do
   2   use Pleroma.DataCase, async: true
   3   import Pleroma.Factory
   4   alias Pleroma.Web.AdminAPI.Config
   5
   6   test "get_by_key/1" do
   7     config = insert(:config)
   8     insert(:config)
   9
  10     assert config == Config.get_by_key(config.key)
  11   end
  12
  13   test "create/1" do
  14     {:ok, config} = Config.create(%{key: "some_key", value: "some_value"})
  15     assert config == Config.get_by_key("some_key")
  16   end
  17
  18   test "update/1" do
  19     config = insert(:config)
  20     {:ok, updated} = Config.update(config, %{value: "some_value"})
  21     loaded = Config.get_by_key(config.key)
  22     assert loaded == updated
  23   end
  24
  25   test "update_or_create/1" do
  26     config = insert(:config)
  27     key2 = "another_key"
  28
  29     params = [
  30       %{key: key2, value: "another_value"},
  31       %{key: config.key, value: "new_value"}
  32     ]
  33
  34     assert Repo.all(Config) |> length() == 1
  35
  36     Enum.each(params, &Config.update_or_create(&1))
  37
  38     assert Repo.all(Config) |> length() == 2
  39
  40     config1 = Config.get_by_key(config.key)
  41     config2 = Config.get_by_key(key2)
  42
  43     assert config1.value == Config.transform("new_value")
  44     assert config2.value == Config.transform("another_value")
  45   end
  46
  47   test "delete/1" do
  48     config = insert(:config)
  49     {:ok, _} = Config.delete(config.key)
  50     refute Config.get_by_key(config.key)
  51   end
  52
  53   describe "transform/1" do
  54     test "string" do
  55       binary = Config.transform("value as string")
  56       assert binary == :erlang.term_to_binary("value as string")
  57       assert Config.from_binary(binary) == "value as string"
  58     end
  59
  60     test "list of modules" do
  61       binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
  62       assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
  63       assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
  64     end
  65
  66     test "list of strings" do
  67       binary = Config.transform(["string1", "string2"])
  68       assert binary == :erlang.term_to_binary(["string1", "string2"])
  69       assert Config.from_binary(binary) == ["string1", "string2"]
  70     end
  71
  72     test "map" do
  73       binary =
  74         Config.transform(%{
  75           "types" => "Pleroma.PostgresTypes",
  76           "telemetry_event" => ["Pleroma.Repo.Instrumenter"],
  77           "migration_lock" => ""
  78         })
  79
  80       assert binary ==
  81                :erlang.term_to_binary(
  82                  telemetry_event: [Pleroma.Repo.Instrumenter],
  83                  types: Pleroma.PostgresTypes
  84                )
  85
  86       assert Config.from_binary(binary) == [
  87                telemetry_event: [Pleroma.Repo.Instrumenter],
  88                types: Pleroma.PostgresTypes
  89              ]
  90     end
  91
  92     test "complex map with nested integers, lists and atoms" do
  93       binary =
  94         Config.transform(%{
  95           "uploader" => "Pleroma.Uploaders.Local",
  96           "filters" => ["Pleroma.Upload.Filter.Dedupe"],
  97           "link_name" => ":true",
  98           "proxy_remote" => ":false",
  99           "proxy_opts" => %{
 100             "redirect_on_failure" => ":false",
 101             "max_body_length" => "i:1048576",
 102             "http" => %{
 103               "follow_redirect" => ":true",
 104               "pool" => ":upload"
 105             }
 106           }
 107         })
 108
 109       assert binary ==
 110                :erlang.term_to_binary(
 111                  filters: [Pleroma.Upload.Filter.Dedupe],
 112                  link_name: true,
 113                  proxy_opts: [
 114                    http: [
 115                      follow_redirect: true,
 116                      pool: :upload
 117                    ],
 118                    max_body_length: 1_048_576,
 119                    redirect_on_failure: false
 120                  ],
 121                  proxy_remote: false,
 122                  uploader: Pleroma.Uploaders.Local
 123                )
 124
 125       assert Config.from_binary(binary) ==
 126                [
 127                  filters: [Pleroma.Upload.Filter.Dedupe],
 128                  link_name: true,
 129                  proxy_opts: [
 130                    http: [
 131                      follow_redirect: true,
 132                      pool: :upload
 133                    ],
 134                    max_body_length: 1_048_576,
 135                    redirect_on_failure: false
 136                  ],
 137                  proxy_remote: false,
 138                  uploader: Pleroma.Uploaders.Local
 139                ]
 140     end
 141
 142     test "keyword" do
 143       binary =
 144         Config.transform(%{
 145           "level" => ":warn",
 146           "meta" => [":all"],
 147           "webhook_url" => "https://hooks.slack.com/services/YOUR-KEY-HERE"
 148         })
 149
 150       assert binary ==
 151                :erlang.term_to_binary(
 152                  level: :warn,
 153                  meta: [:all],
 154                  webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 155                )
 156
 157       assert Config.from_binary(binary) == [
 158                level: :warn,
 159                meta: [:all],
 160                webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 161              ]
 162     end
 163
 164     test "complex map with sigil" do
 165       binary =
 166         Config.transform(%{
 167           federated_timeline_removal: [],
 168           reject: [~r/comp[lL][aA][iI][nN]er/],
 169           replace: []
 170         })
 171
 172       assert binary ==
 173                :erlang.term_to_binary(
 174                  federated_timeline_removal: [],
 175                  reject: [~r/comp[lL][aA][iI][nN]er/],
 176                  replace: []
 177                )
 178
 179       assert Config.from_binary(binary) ==
 180                [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
 181     end
 182   end
 183 end