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   describe "update_or_create/1" do
  30     test "common" do
  31       config = insert(:config)
  32       key2 = "another_key"
  33
  34       params = [
  35         %{group: "pleroma", key: key2, value: "another_value"},
  36         %{group: config.group, key: config.key, value: "new_value"}
  37       ]
  38
  39       assert Repo.all(Config) |> length() == 1
  40
  41       Enum.each(params, &Config.update_or_create(&1))
  42
  43       assert Repo.all(Config) |> length() == 2
  44
  45       config1 = Config.get_by_params(%{group: config.group, key: config.key})
  46       config2 = Config.get_by_params(%{group: "pleroma", key: key2})
  47
  48       assert config1.value == Config.transform("new_value")
  49       assert config2.value == Config.transform("another_value")
  50     end
  51
  52     test "partial update" do
  53       config = insert(:config, value: Config.to_binary(key1: "val1", key2: :val2))
  54
  55       {:ok, _config} =
  56         Config.update_or_create(%{
  57           group: config.group,
  58           key: config.key,
  59           value: [key1: :val1, key3: :val3]
  60         })
  61
  62       updated = Config.get_by_params(%{group: config.group, key: config.key})
  63
  64       value = Config.from_binary(updated.value)
  65       assert length(value) == 3
  66       assert value[:key1] == :val1
  67       assert value[:key2] == :val2
  68       assert value[:key3] == :val3
  69     end
  70
  71     test "only full update for some keys" do
  72       config1 = insert(:config, key: ":ecto_repos", value: Config.to_binary(repo: Pleroma.Repo))
  73       config2 = insert(:config, group: ":cors_plug", key: ":max_age", value: Config.to_binary(18))
  74
  75       {:ok, _config} =
  76         Config.update_or_create(%{
  77           group: config1.group,
  78           key: config1.key,
  79           value: [another_repo: [Pleroma.Repo]]
  80         })
  81
  82       {:ok, _config} =
  83         Config.update_or_create(%{
  84           group: config2.group,
  85           key: config2.key,
  86           value: 777
  87         })
  88
  89       updated1 = Config.get_by_params(%{group: config1.group, key: config1.key})
  90       updated2 = Config.get_by_params(%{group: config2.group, key: config2.key})
  91
  92       assert Config.from_binary(updated1.value) == [another_repo: [Pleroma.Repo]]
  93       assert Config.from_binary(updated2.value) == 777
  94     end
  95
  96     test "full update if value is not keyword" do
  97       config =
  98         insert(:config,
  99           group: ":tesla",
 100           key: ":adapter",
 101           value: Config.to_binary(Tesla.Adapter.Hackney)
 102         )
 103
 104       {:ok, _config} =
 105         Config.update_or_create(%{
 106           group: config.group,
 107           key: config.key,
 108           value: Tesla.Adapter.Httpc
 109         })
 110
 111       updated = Config.get_by_params(%{group: config.group, key: config.key})
 112
 113       assert Config.from_binary(updated.value) == Tesla.Adapter.Httpc
 114     end
 115   end
 116
 117   test "delete/1" do
 118     config = insert(:config)
 119     {:ok, _} = Config.delete(%{key: config.key, group: config.group})
 120     refute Config.get_by_params(%{key: config.key, group: config.group})
 121   end
 122
 123   describe "transform/1" do
 124     test "string" do
 125       binary = Config.transform("value as string")
 126       assert binary == :erlang.term_to_binary("value as string")
 127       assert Config.from_binary(binary) == "value as string"
 128     end
 129
 130     test "boolean" do
 131       binary = Config.transform(false)
 132       assert binary == :erlang.term_to_binary(false)
 133       assert Config.from_binary(binary) == false
 134     end
 135
 136     test "nil" do
 137       binary = Config.transform(nil)
 138       assert binary == :erlang.term_to_binary(nil)
 139       assert Config.from_binary(binary) == nil
 140     end
 141
 142     test "integer" do
 143       binary = Config.transform(150)
 144       assert binary == :erlang.term_to_binary(150)
 145       assert Config.from_binary(binary) == 150
 146     end
 147
 148     test "atom" do
 149       binary = Config.transform(":atom")
 150       assert binary == :erlang.term_to_binary(:atom)
 151       assert Config.from_binary(binary) == :atom
 152     end
 153
 154     test "pleroma module" do
 155       binary = Config.transform("Pleroma.Bookmark")
 156       assert binary == :erlang.term_to_binary(Pleroma.Bookmark)
 157       assert Config.from_binary(binary) == Pleroma.Bookmark
 158     end
 159
 160     test "pleroma string" do
 161       binary = Config.transform("Pleroma")
 162       assert binary == :erlang.term_to_binary("Pleroma")
 163       assert Config.from_binary(binary) == "Pleroma"
 164     end
 165
 166     test "phoenix module" do
 167       binary = Config.transform("Phoenix.Socket.V1.JSONSerializer")
 168       assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
 169       assert Config.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
 170     end
 171
 172     test "tesla module" do
 173       binary = Config.transform("Tesla.Adapter.Hackney")
 174       assert binary == :erlang.term_to_binary(Tesla.Adapter.Hackney)
 175       assert Config.from_binary(binary) == Tesla.Adapter.Hackney
 176     end
 177
 178     test "ExSyslogger module" do
 179       binary = Config.transform("ExSyslogger")
 180       assert binary == :erlang.term_to_binary(ExSyslogger)
 181       assert Config.from_binary(binary) == ExSyslogger
 182     end
 183
 184     test "Quack.Logger module" do
 185       binary = Config.transform("Quack.Logger")
 186       assert binary == :erlang.term_to_binary(Quack.Logger)
 187       assert Config.from_binary(binary) == Quack.Logger
 188     end
 189
 190     test "sigil" do
 191       binary = Config.transform("~r[comp[lL][aA][iI][nN]er]")
 192       assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
 193       assert Config.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
 194     end
 195
 196     test "link sigil" do
 197       binary = Config.transform("~r/https:\/\/example.com/")
 198       assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/)
 199       assert Config.from_binary(binary) == ~r/https:\/\/example.com/
 200     end
 201
 202     test "link sigil with um modifiers" do
 203       binary = Config.transform("~r/https:\/\/example.com/um")
 204       assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/um)
 205       assert Config.from_binary(binary) == ~r/https:\/\/example.com/um
 206     end
 207
 208     test "link sigil with i modifier" do
 209       binary = Config.transform("~r/https:\/\/example.com/i")
 210       assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/i)
 211       assert Config.from_binary(binary) == ~r/https:\/\/example.com/i
 212     end
 213
 214     test "link sigil with s modifier" do
 215       binary = Config.transform("~r/https:\/\/example.com/s")
 216       assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/s)
 217       assert Config.from_binary(binary) == ~r/https:\/\/example.com/s
 218     end
 219
 220     test "raise if valid delimiter not found" do
 221       assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
 222         Config.transform("~r/https://[]{}<>\"'()|example.com/s")
 223       end
 224     end
 225
 226     test "2 child tuple" do
 227       binary = Config.transform(%{"tuple" => ["v1", ":v2"]})
 228       assert binary == :erlang.term_to_binary({"v1", :v2})
 229       assert Config.from_binary(binary) == {"v1", :v2}
 230     end
 231
 232     test "proxy tuple with localhost" do
 233       binary =
 234         Config.transform(%{
 235           "tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
 236         })
 237
 238       assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, :localhost, 1234}})
 239       assert Config.from_binary(binary) == {:proxy_url, {:socks5, :localhost, 1234}}
 240     end
 241
 242     test "proxy tuple with domain" do
 243       binary =
 244         Config.transform(%{
 245           "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
 246         })
 247
 248       assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, 'domain.com', 1234}})
 249       assert Config.from_binary(binary) == {:proxy_url, {:socks5, 'domain.com', 1234}}
 250     end
 251
 252     test "proxy tuple with ip" do
 253       binary =
 254         Config.transform(%{
 255           "tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
 256         })
 257
 258       assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}})
 259       assert Config.from_binary(binary) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
 260     end
 261
 262     test "tuple with n childs" do
 263       binary =
 264         Config.transform(%{
 265           "tuple" => [
 266             "v1",
 267             ":v2",
 268             "Pleroma.Bookmark",
 269             150,
 270             false,
 271             "Phoenix.Socket.V1.JSONSerializer"
 272           ]
 273         })
 274
 275       assert binary ==
 276                :erlang.term_to_binary(
 277                  {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
 278                )
 279
 280       assert Config.from_binary(binary) ==
 281                {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
 282     end
 283
 284     test "tuple with dispatch key" do
 285       binary = Config.transform(%{"tuple" => [":dispatch", ["{:_,
 286        [
 287          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 288          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
 289           {Phoenix.Transports.WebSocket,
 290            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
 291          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 292        ]}"]]})
 293
 294       assert binary ==
 295                :erlang.term_to_binary(
 296                  {:dispatch,
 297                   [
 298                     {:_,
 299                      [
 300                        {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 301                        {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 302                         {Phoenix.Transports.WebSocket,
 303                          {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
 304                        {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 305                      ]}
 306                   ]}
 307                )
 308
 309       assert Config.from_binary(binary) ==
 310                {:dispatch,
 311                 [
 312                   {:_,
 313                    [
 314                      {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 315                      {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 316                       {Phoenix.Transports.WebSocket,
 317                        {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
 318                      {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 319                    ]}
 320                 ]}
 321     end
 322
 323     test "map with string key" do
 324       binary = Config.transform(%{"key" => "value"})
 325       assert binary == :erlang.term_to_binary(%{"key" => "value"})
 326       assert Config.from_binary(binary) == %{"key" => "value"}
 327     end
 328
 329     test "map with atom key" do
 330       binary = Config.transform(%{":key" => "value"})
 331       assert binary == :erlang.term_to_binary(%{key: "value"})
 332       assert Config.from_binary(binary) == %{key: "value"}
 333     end
 334
 335     test "list of strings" do
 336       binary = Config.transform(["v1", "v2", "v3"])
 337       assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
 338       assert Config.from_binary(binary) == ["v1", "v2", "v3"]
 339     end
 340
 341     test "list of modules" do
 342       binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
 343       assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
 344       assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
 345     end
 346
 347     test "list of atoms" do
 348       binary = Config.transform([":v1", ":v2", ":v3"])
 349       assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
 350       assert Config.from_binary(binary) == [:v1, :v2, :v3]
 351     end
 352
 353     test "list of mixed values" do
 354       binary =
 355         Config.transform([
 356           "v1",
 357           ":v2",
 358           "Pleroma.Repo",
 359           "Phoenix.Socket.V1.JSONSerializer",
 360           15,
 361           false
 362         ])
 363
 364       assert binary ==
 365                :erlang.term_to_binary([
 366                  "v1",
 367                  :v2,
 368                  Pleroma.Repo,
 369                  Phoenix.Socket.V1.JSONSerializer,
 370                  15,
 371                  false
 372                ])
 373
 374       assert Config.from_binary(binary) == [
 375                "v1",
 376                :v2,
 377                Pleroma.Repo,
 378                Phoenix.Socket.V1.JSONSerializer,
 379                15,
 380                false
 381              ]
 382     end
 383
 384     test "simple keyword" do
 385       binary = Config.transform([%{"tuple" => [":key", "value"]}])
 386       assert binary == :erlang.term_to_binary([{:key, "value"}])
 387       assert Config.from_binary(binary) == [{:key, "value"}]
 388       assert Config.from_binary(binary) == [key: "value"]
 389     end
 390
 391     test "keyword with partial_chain key" do
 392       binary =
 393         Config.transform([%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}])
 394
 395       assert binary == :erlang.term_to_binary(partial_chain: &:hackney_connect.partial_chain/1)
 396       assert Config.from_binary(binary) == [partial_chain: &:hackney_connect.partial_chain/1]
 397     end
 398
 399     test "keyword" do
 400       binary =
 401         Config.transform([
 402           %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
 403           %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
 404           %{"tuple" => [":migration_lock", nil]},
 405           %{"tuple" => [":key1", 150]},
 406           %{"tuple" => [":key2", "string"]}
 407         ])
 408
 409       assert binary ==
 410                :erlang.term_to_binary(
 411                  types: Pleroma.PostgresTypes,
 412                  telemetry_event: [Pleroma.Repo.Instrumenter],
 413                  migration_lock: nil,
 414                  key1: 150,
 415                  key2: "string"
 416                )
 417
 418       assert Config.from_binary(binary) == [
 419                types: Pleroma.PostgresTypes,
 420                telemetry_event: [Pleroma.Repo.Instrumenter],
 421                migration_lock: nil,
 422                key1: 150,
 423                key2: "string"
 424              ]
 425     end
 426
 427     test "complex keyword with nested mixed childs" do
 428       binary =
 429         Config.transform([
 430           %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
 431           %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
 432           %{"tuple" => [":link_name", true]},
 433           %{"tuple" => [":proxy_remote", false]},
 434           %{"tuple" => [":common_map", %{":key" => "value"}]},
 435           %{
 436             "tuple" => [
 437               ":proxy_opts",
 438               [
 439                 %{"tuple" => [":redirect_on_failure", false]},
 440                 %{"tuple" => [":max_body_length", 1_048_576]},
 441                 %{
 442                   "tuple" => [
 443                     ":http",
 444                     [%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
 445                   ]
 446                 }
 447               ]
 448             ]
 449           }
 450         ])
 451
 452       assert binary ==
 453                :erlang.term_to_binary(
 454                  uploader: Pleroma.Uploaders.Local,
 455                  filters: [Pleroma.Upload.Filter.Dedupe],
 456                  link_name: true,
 457                  proxy_remote: false,
 458                  common_map: %{key: "value"},
 459                  proxy_opts: [
 460                    redirect_on_failure: false,
 461                    max_body_length: 1_048_576,
 462                    http: [
 463                      follow_redirect: true,
 464                      pool: :upload
 465                    ]
 466                  ]
 467                )
 468
 469       assert Config.from_binary(binary) ==
 470                [
 471                  uploader: Pleroma.Uploaders.Local,
 472                  filters: [Pleroma.Upload.Filter.Dedupe],
 473                  link_name: true,
 474                  proxy_remote: false,
 475                  common_map: %{key: "value"},
 476                  proxy_opts: [
 477                    redirect_on_failure: false,
 478                    max_body_length: 1_048_576,
 479                    http: [
 480                      follow_redirect: true,
 481                      pool: :upload
 482                    ]
 483                  ]
 484                ]
 485     end
 486
 487     test "common keyword" do
 488       binary =
 489         Config.transform([
 490           %{"tuple" => [":level", ":warn"]},
 491           %{"tuple" => [":meta", [":all"]]},
 492           %{"tuple" => [":path", ""]},
 493           %{"tuple" => [":val", nil]},
 494           %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
 495         ])
 496
 497       assert binary ==
 498                :erlang.term_to_binary(
 499                  level: :warn,
 500                  meta: [:all],
 501                  path: "",
 502                  val: nil,
 503                  webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 504                )
 505
 506       assert Config.from_binary(binary) == [
 507                level: :warn,
 508                meta: [:all],
 509                path: "",
 510                val: nil,
 511                webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
 512              ]
 513     end
 514
 515     test "complex keyword with sigil" do
 516       binary =
 517         Config.transform([
 518           %{"tuple" => [":federated_timeline_removal", []]},
 519           %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
 520           %{"tuple" => [":replace", []]}
 521         ])
 522
 523       assert binary ==
 524                :erlang.term_to_binary(
 525                  federated_timeline_removal: [],
 526                  reject: [~r/comp[lL][aA][iI][nN]er/],
 527                  replace: []
 528                )
 529
 530       assert Config.from_binary(binary) ==
 531                [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
 532     end
 533
 534     test "complex keyword with tuples with more than 2 values" do
 535       binary =
 536         Config.transform([
 537           %{
 538             "tuple" => [
 539               ":http",
 540               [
 541                 %{
 542                   "tuple" => [
 543                     ":key1",
 544                     [
 545                       %{
 546                         "tuple" => [
 547                           ":_",
 548                           [
 549                             %{
 550                               "tuple" => [
 551                                 "/api/v1/streaming",
 552                                 "Pleroma.Web.MastodonAPI.WebsocketHandler",
 553                                 []
 554                               ]
 555                             },
 556                             %{
 557                               "tuple" => [
 558                                 "/websocket",
 559                                 "Phoenix.Endpoint.CowboyWebSocket",
 560                                 %{
 561                                   "tuple" => [
 562                                     "Phoenix.Transports.WebSocket",
 563                                     %{
 564                                       "tuple" => [
 565                                         "Pleroma.Web.Endpoint",
 566                                         "Pleroma.Web.UserSocket",
 567                                         []
 568                                       ]
 569                                     }
 570                                   ]
 571                                 }
 572                               ]
 573                             },
 574                             %{
 575                               "tuple" => [
 576                                 ":_",
 577                                 "Phoenix.Endpoint.Cowboy2Handler",
 578                                 %{"tuple" => ["Pleroma.Web.Endpoint", []]}
 579                               ]
 580                             }
 581                           ]
 582                         ]
 583                       }
 584                     ]
 585                   ]
 586                 }
 587               ]
 588             ]
 589           }
 590         ])
 591
 592       assert binary ==
 593                :erlang.term_to_binary(
 594                  http: [
 595                    key1: [
 596                      _: [
 597                        {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 598                        {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 599                         {Phoenix.Transports.WebSocket,
 600                          {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
 601                        {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 602                      ]
 603                    ]
 604                  ]
 605                )
 606
 607       assert Config.from_binary(binary) == [
 608                http: [
 609                  key1: [
 610                    {:_,
 611                     [
 612                       {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
 613                       {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
 614                        {Phoenix.Transports.WebSocket,
 615                         {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
 616                       {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
 617                     ]}
 618                  ]
 619                ]
 620              ]
 621     end
 622   end
 623 end