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 "boolean" do
  65       binary = Config.transform(false)
  66       assert binary == :erlang.term_to_binary(false)
  67       assert Config.from_binary(binary) == false
  68     end
  69
  70     test "nil" do
  71       binary = Config.transform(nil)
  72       assert binary == :erlang.term_to_binary(nil)
  73       assert Config.from_binary(binary) == nil
  74     end
  75
  76     test "integer" do
  77       binary = Config.transform(150)
  78       assert binary == :erlang.term_to_binary(150)
  79       assert Config.from_binary(binary) == 150
  80     end
  81
  82     test "atom" do
  83       binary = Config.transform(":atom")
  84       assert binary == :erlang.term_to_binary(:atom)
  85       assert Config.from_binary(binary) == :atom
  86     end
  87
  88     test "pleroma module" do
  89       binary = Config.transform("Pleroma.Bookmark")
  90       assert binary == :erlang.term_to_binary(Pleroma.Bookmark)
  91       assert Config.from_binary(binary) == Pleroma.Bookmark
  92     end
  93
  94     test "phoenix module" do
  95       binary = Config.transform("Phoenix.Socket.V1.JSONSerializer")
  96       assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
  97       assert Config.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
  98     end
  99
 100     test "sigil" do
 101       binary = Config.transform("~r/comp[lL][aA][iI][nN]er/")
 102       assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
 103       assert Config.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
 104     end
 105
 106     test "2 child tuple" do
 107       binary = Config.transform(%{"tuple" => ["v1", ":v2"]})
 108       assert binary == :erlang.term_to_binary({"v1", :v2})
 109       assert Config.from_binary(binary) == {"v1", :v2}
 110     end
 111
 112     test "tuple with n childs" do
 113       binary =
 114         Config.transform(%{
 115           "tuple" => [
 116             "v1",
 117             ":v2",
 118             "Pleroma.Bookmark",
 119             150,
 120             false,
 121             "Phoenix.Socket.V1.JSONSerializer"
 122           ]
 123         })
 124
 125       assert binary ==
 126                :erlang.term_to_binary(
 127                  {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
 128                )
 129
 130       assert Config.from_binary(binary) ==
 131                {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
 132     end
 133
 134     test "tuple with dispatch key" do
 135       binary = Config.transform(%{"tuple" => [":dispatch", ["{:_,
 136        [
 137          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 138          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
 139           {Phoenix.Transports.WebSocket,
 140            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
 141          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 142        ]}"]]})
 143
 144       assert binary ==
 145                :erlang.term_to_binary(
 146                  {:dispatch,
 147                   [
 148                     {:_,
 149                      [
 150                        {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 151                        {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 152                         {Phoenix.Transports.WebSocket,
 153                          {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
 154                        {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 155                      ]}
 156                   ]}
 157                )
 158
 159       assert Config.from_binary(binary) ==
 160                {:dispatch,
 161                 [
 162                   {:_,
 163                    [
 164                      {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 165                      {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 166                       {Phoenix.Transports.WebSocket,
 167                        {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
 168                      {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 169                    ]}
 170                 ]}
 171     end
 172
 173     test "map with string key" do
 174       binary = Config.transform(%{"key" => "value"})
 175       assert binary == :erlang.term_to_binary(%{"key" => "value"})
 176       assert Config.from_binary(binary) == %{"key" => "value"}
 177     end
 178
 179     test "map with atom key" do
 180       binary = Config.transform(%{":key" => "value"})
 181       assert binary == :erlang.term_to_binary(%{key: "value"})
 182       assert Config.from_binary(binary) == %{key: "value"}
 183     end
 184
 185     test "list of strings" do
 186       binary = Config.transform(["v1", "v2", "v3"])
 187       assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
 188       assert Config.from_binary(binary) == ["v1", "v2", "v3"]
 189     end
 190
 191     test "list of modules" do
 192       binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
 193       assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
 194       assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
 195     end
 196
 197     test "list of atoms" do
 198       binary = Config.transform([":v1", ":v2", ":v3"])
 199       assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
 200       assert Config.from_binary(binary) == [:v1, :v2, :v3]
 201     end
 202
 203     test "list of mixed values" do
 204       binary =
 205         Config.transform([
 206           "v1",
 207           ":v2",
 208           "Pleroma.Repo",
 209           "Phoenix.Socket.V1.JSONSerializer",
 210           15,
 211           false
 212         ])
 213
 214       assert binary ==
 215                :erlang.term_to_binary([
 216                  "v1",
 217                  :v2,
 218                  Pleroma.Repo,
 219                  Phoenix.Socket.V1.JSONSerializer,
 220                  15,
 221                  false
 222                ])
 223
 224       assert Config.from_binary(binary) == [
 225                "v1",
 226                :v2,
 227                Pleroma.Repo,
 228                Phoenix.Socket.V1.JSONSerializer,
 229                15,
 230                false
 231              ]
 232     end
 233
 234     test "simple keyword" do
 235       binary = Config.transform([%{"tuple" => [":key", "value"]}])
 236       assert binary == :erlang.term_to_binary([{:key, "value"}])
 237       assert Config.from_binary(binary) == [{:key, "value"}]
 238       assert Config.from_binary(binary) == [key: "value"]
 239     end
 240
 241     test "keyword" do
 242       binary =
 243         Config.transform([
 244           %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
 245           %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
 246           %{"tuple" => [":migration_lock", nil]},
 247           %{"tuple" => [":key1", 150]},
 248           %{"tuple" => [":key2", "string"]}
 249         ])
 250
 251       assert binary ==
 252                :erlang.term_to_binary(
 253                  types: Pleroma.PostgresTypes,
 254                  telemetry_event: [Pleroma.Repo.Instrumenter],
 255                  migration_lock: nil,
 256                  key1: 150,
 257                  key2: "string"
 258                )
 259
 260       assert Config.from_binary(binary) == [
 261                types: Pleroma.PostgresTypes,
 262                telemetry_event: [Pleroma.Repo.Instrumenter],
 263                migration_lock: nil,
 264                key1: 150,
 265                key2: "string"
 266              ]
 267     end
 268
 269     test "complex keyword with nested mixed childs" do
 270       binary =
 271         Config.transform([
 272           %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
 273           %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
 274           %{"tuple" => [":link_name", true]},
 275           %{"tuple" => [":proxy_remote", false]},
 276           %{"tuple" => [":common_map", %{":key" => "value"}]},
 277           %{
 278             "tuple" => [
 279               ":proxy_opts",
 280               [
 281                 %{"tuple" => [":redirect_on_failure", false]},
 282                 %{"tuple" => [":max_body_length", 1_048_576]},
 283                 %{
 284                   "tuple" => [
 285                     ":http",
 286                     [%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
 287                   ]
 288                 }
 289               ]
 290             ]
 291           }
 292         ])
 293
 294       assert binary ==
 295                :erlang.term_to_binary(
 296                  uploader: Pleroma.Uploaders.Local,
 297                  filters: [Pleroma.Upload.Filter.Dedupe],
 298                  link_name: true,
 299                  proxy_remote: false,
 300                  common_map: %{key: "value"},
 301                  proxy_opts: [
 302                    redirect_on_failure: false,
 303                    max_body_length: 1_048_576,
 304                    http: [
 305                      follow_redirect: true,
 306                      pool: :upload
 307                    ]
 308                  ]
 309                )
 310
 311       assert Config.from_binary(binary) ==
 312                [
 313                  uploader: Pleroma.Uploaders.Local,
 314                  filters: [Pleroma.Upload.Filter.Dedupe],
 315                  link_name: true,
 316                  proxy_remote: false,
 317                  common_map: %{key: "value"},
 318                  proxy_opts: [
 319                    redirect_on_failure: false,
 320                    max_body_length: 1_048_576,
 321                    http: [
 322                      follow_redirect: true,
 323                      pool: :upload
 324                    ]
 325                  ]
 326                ]
 327     end
 328
 329     test "common keyword" do
 330       binary =
 331         Config.transform([
 332           %{"tuple" => [":level", ":warn"]},
 333           %{"tuple" => [":meta", [":all"]]},
 334           %{"tuple" => [":path", ""]},
 335           %{"tuple" => [":val", nil]},
 336           %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
 337         ])
 338
 339       assert binary ==
 340                :erlang.term_to_binary(
 341                  level: :warn,
 342                  meta: [:all],
 343                  path: "",
 344                  val: nil,
 345                  webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 346                )
 347
 348       assert Config.from_binary(binary) == [
 349                level: :warn,
 350                meta: [:all],
 351                path: "",
 352                val: nil,
 353                webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 354              ]
 355     end
 356
 357     test "complex keyword with sigil" do
 358       binary =
 359         Config.transform([
 360           %{"tuple" => [":federated_timeline_removal", []]},
 361           %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
 362           %{"tuple" => [":replace", []]}
 363         ])
 364
 365       assert binary ==
 366                :erlang.term_to_binary(
 367                  federated_timeline_removal: [],
 368                  reject: [~r/comp[lL][aA][iI][nN]er/],
 369                  replace: []
 370                )
 371
 372       assert Config.from_binary(binary) ==
 373                [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
 374     end
 375
 376     test "complex keyword with tuples with more than 2 values" do
 377       binary =
 378         Config.transform([
 379           %{
 380             "tuple" => [
 381               ":http",
 382               [
 383                 %{
 384                   "tuple" => [
 385                     ":key1",
 386                     [
 387                       %{
 388                         "tuple" => [
 389                           ":_",
 390                           [
 391                             %{
 392                               "tuple" => [
 393                                 "/api/v1/streaming",
 394                                 "Pleroma.Web.MastodonAPI.WebsocketHandler",
 395                                 []
 396                               ]
 397                             },
 398                             %{
 399                               "tuple" => [
 400                                 "/websocket",
 401                                 "Phoenix.Endpoint.CowboyWebSocket",
 402                                 %{
 403                                   "tuple" => [
 404                                     "Phoenix.Transports.WebSocket",
 405                                     %{
 406                                       "tuple" => [
 407                                         "Pleroma.Web.Endpoint",
 408                                         "Pleroma.Web.UserSocket",
 409                                         []
 410                                       ]
 411                                     }
 412                                   ]
 413                                 }
 414                               ]
 415                             },
 416                             %{
 417                               "tuple" => [
 418                                 ":_",
 419                                 "Phoenix.Endpoint.Cowboy2Handler",
 420                                 %{"tuple" => ["Pleroma.Web.Endpoint", []]}
 421                               ]
 422                             }
 423                           ]
 424                         ]
 425                       }
 426                     ]
 427                   ]
 428                 }
 429               ]
 430             ]
 431           }
 432         ])
 433
 434       assert binary ==
 435                :erlang.term_to_binary(
 436                  http: [
 437                    key1: [
 438                      _: [
 439                        {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 440                        {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 441                         {Phoenix.Transports.WebSocket,
 442                          {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
 443                        {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 444                      ]
 445                    ]
 446                  ]
 447                )
 448
 449       assert Config.from_binary(binary) == [
 450                http: [
 451                  key1: [
 452                    {:_,
 453                     [
 454                       {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 455                       {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 456                        {Phoenix.Transports.WebSocket,
 457                         {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
 458                       {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 459                     ]}
 460                  ]
 461                ]
 462              ]
 463     end
 464   end
 465 end