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