1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.AdminAPI.ConfigTest do
6 use Pleroma.DataCase, async: true
8 alias Pleroma.Web.AdminAPI.Config
10 test "get_by_key/1" do
11 config = insert(:config)
14 assert config == Config.get_by_params(%{group: config.group, key: config.key})
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"})
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
29 describe "update_or_create/1" do
31 config = insert(:config)
35 %{group: "pleroma", key: key2, value: "another_value"},
36 %{group: config.group, key: config.key, value: "new_value"}
39 assert Repo.all(Config) |> length() == 1
41 Enum.each(params, &Config.update_or_create(&1))
43 assert Repo.all(Config) |> length() == 2
45 config1 = Config.get_by_params(%{group: config.group, key: config.key})
46 config2 = Config.get_by_params(%{group: "pleroma", key: key2})
48 assert config1.value == Config.transform("new_value")
49 assert config2.value == Config.transform("another_value")
52 test "partial update" do
53 config = insert(:config, value: Config.to_binary(key1: "val1", key2: :val2))
56 Config.update_or_create(%{
59 value: [key1: :val1, key3: :val3]
62 updated = Config.get_by_params(%{group: config.group, key: config.key})
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
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))
76 Config.update_or_create(%{
79 value: [another_repo: [Pleroma.Repo]]
83 Config.update_or_create(%{
89 updated1 = Config.get_by_params(%{group: config1.group, key: config1.key})
90 updated2 = Config.get_by_params(%{group: config2.group, key: config2.key})
92 assert Config.from_binary(updated1.value) == [another_repo: [Pleroma.Repo]]
93 assert Config.from_binary(updated2.value) == 777
96 test "full update if value is not keyword" do
101 value: Config.to_binary(Tesla.Adapter.Hackney)
105 Config.update_or_create(%{
108 value: Tesla.Adapter.Httpc
111 updated = Config.get_by_params(%{group: config.group, key: config.key})
113 assert Config.from_binary(updated.value) == Tesla.Adapter.Httpc
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})
123 describe "transform/1" 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"
131 binary = Config.transform(false)
132 assert binary == :erlang.term_to_binary(false)
133 assert Config.from_binary(binary) == false
137 binary = Config.transform(nil)
138 assert binary == :erlang.term_to_binary(nil)
139 assert Config.from_binary(binary) == nil
143 binary = Config.transform(150)
144 assert binary == :erlang.term_to_binary(150)
145 assert Config.from_binary(binary) == 150
149 binary = Config.transform(":atom")
150 assert binary == :erlang.term_to_binary(:atom)
151 assert Config.from_binary(binary) == :atom
154 test "ssl options" do
155 binary = Config.transform([":tlsv1", ":tlsv1.1", ":tlsv1.2"])
156 assert binary == :erlang.term_to_binary([:tlsv1, :"tlsv1.1", :"tlsv1.2"])
157 assert Config.from_binary(binary) == [:tlsv1, :"tlsv1.1", :"tlsv1.2"]
160 test "pleroma module" do
161 binary = Config.transform("Pleroma.Bookmark")
162 assert binary == :erlang.term_to_binary(Pleroma.Bookmark)
163 assert Config.from_binary(binary) == Pleroma.Bookmark
166 test "pleroma string" do
167 binary = Config.transform("Pleroma")
168 assert binary == :erlang.term_to_binary("Pleroma")
169 assert Config.from_binary(binary) == "Pleroma"
172 test "phoenix module" do
173 binary = Config.transform("Phoenix.Socket.V1.JSONSerializer")
174 assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
175 assert Config.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
178 test "tesla module" do
179 binary = Config.transform("Tesla.Adapter.Hackney")
180 assert binary == :erlang.term_to_binary(Tesla.Adapter.Hackney)
181 assert Config.from_binary(binary) == Tesla.Adapter.Hackney
184 test "ExSyslogger module" do
185 binary = Config.transform("ExSyslogger")
186 assert binary == :erlang.term_to_binary(ExSyslogger)
187 assert Config.from_binary(binary) == ExSyslogger
190 test "Quack.Logger module" do
191 binary = Config.transform("Quack.Logger")
192 assert binary == :erlang.term_to_binary(Quack.Logger)
193 assert Config.from_binary(binary) == Quack.Logger
197 binary = Config.transform("~r[comp[lL][aA][iI][nN]er]")
198 assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
199 assert Config.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
203 binary = Config.transform("~r/https:\/\/example.com/")
204 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/)
205 assert Config.from_binary(binary) == ~r/https:\/\/example.com/
208 test "link sigil with um modifiers" do
209 binary = Config.transform("~r/https:\/\/example.com/um")
210 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/um)
211 assert Config.from_binary(binary) == ~r/https:\/\/example.com/um
214 test "link sigil with i modifier" do
215 binary = Config.transform("~r/https:\/\/example.com/i")
216 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/i)
217 assert Config.from_binary(binary) == ~r/https:\/\/example.com/i
220 test "link sigil with s modifier" do
221 binary = Config.transform("~r/https:\/\/example.com/s")
222 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/s)
223 assert Config.from_binary(binary) == ~r/https:\/\/example.com/s
226 test "raise if valid delimiter not found" do
227 assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
228 Config.transform("~r/https://[]{}<>\"'()|example.com/s")
232 test "2 child tuple" do
233 binary = Config.transform(%{"tuple" => ["v1", ":v2"]})
234 assert binary == :erlang.term_to_binary({"v1", :v2})
235 assert Config.from_binary(binary) == {"v1", :v2}
238 test "proxy tuple with localhost" do
241 "tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
244 assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, :localhost, 1234}})
245 assert Config.from_binary(binary) == {:proxy_url, {:socks5, :localhost, 1234}}
248 test "proxy tuple with domain" do
251 "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
254 assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, 'domain.com', 1234}})
255 assert Config.from_binary(binary) == {:proxy_url, {:socks5, 'domain.com', 1234}}
258 test "proxy tuple with ip" do
261 "tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
264 assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}})
265 assert Config.from_binary(binary) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
268 test "tuple with n childs" do
277 "Phoenix.Socket.V1.JSONSerializer"
282 :erlang.term_to_binary(
283 {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
286 assert Config.from_binary(binary) ==
287 {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
290 test "tuple with dispatch key" do
291 binary = Config.transform(%{"tuple" => [":dispatch", ["{:_,
293 {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
294 {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
295 {Phoenix.Transports.WebSocket,
296 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
297 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
301 :erlang.term_to_binary(
306 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
307 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
308 {Phoenix.Transports.WebSocket,
309 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
310 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
315 assert Config.from_binary(binary) ==
320 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
321 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
322 {Phoenix.Transports.WebSocket,
323 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
324 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
329 test "map with string 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"}
335 test "map with atom key" do
336 binary = Config.transform(%{":key" => "value"})
337 assert binary == :erlang.term_to_binary(%{key: "value"})
338 assert Config.from_binary(binary) == %{key: "value"}
341 test "list of strings" do
342 binary = Config.transform(["v1", "v2", "v3"])
343 assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
344 assert Config.from_binary(binary) == ["v1", "v2", "v3"]
347 test "list of modules" do
348 binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
349 assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
350 assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
353 test "list of atoms" do
354 binary = Config.transform([":v1", ":v2", ":v3"])
355 assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
356 assert Config.from_binary(binary) == [:v1, :v2, :v3]
359 test "list of mixed values" do
365 "Phoenix.Socket.V1.JSONSerializer",
371 :erlang.term_to_binary([
375 Phoenix.Socket.V1.JSONSerializer,
380 assert Config.from_binary(binary) == [
384 Phoenix.Socket.V1.JSONSerializer,
390 test "simple keyword" do
391 binary = Config.transform([%{"tuple" => [":key", "value"]}])
392 assert binary == :erlang.term_to_binary([{:key, "value"}])
393 assert Config.from_binary(binary) == [{:key, "value"}]
394 assert Config.from_binary(binary) == [key: "value"]
397 test "keyword with partial_chain key" do
399 Config.transform([%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}])
401 assert binary == :erlang.term_to_binary(partial_chain: &:hackney_connect.partial_chain/1)
402 assert Config.from_binary(binary) == [partial_chain: &:hackney_connect.partial_chain/1]
408 %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
409 %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
410 %{"tuple" => [":migration_lock", nil]},
411 %{"tuple" => [":key1", 150]},
412 %{"tuple" => [":key2", "string"]}
416 :erlang.term_to_binary(
417 types: Pleroma.PostgresTypes,
418 telemetry_event: [Pleroma.Repo.Instrumenter],
424 assert Config.from_binary(binary) == [
425 types: Pleroma.PostgresTypes,
426 telemetry_event: [Pleroma.Repo.Instrumenter],
433 test "complex keyword with nested mixed childs" do
436 %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
437 %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
438 %{"tuple" => [":link_name", true]},
439 %{"tuple" => [":proxy_remote", false]},
440 %{"tuple" => [":common_map", %{":key" => "value"}]},
445 %{"tuple" => [":redirect_on_failure", false]},
446 %{"tuple" => [":max_body_length", 1_048_576]},
450 [%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
459 :erlang.term_to_binary(
460 uploader: Pleroma.Uploaders.Local,
461 filters: [Pleroma.Upload.Filter.Dedupe],
464 common_map: %{key: "value"},
466 redirect_on_failure: false,
467 max_body_length: 1_048_576,
469 follow_redirect: true,
475 assert Config.from_binary(binary) ==
477 uploader: Pleroma.Uploaders.Local,
478 filters: [Pleroma.Upload.Filter.Dedupe],
481 common_map: %{key: "value"},
483 redirect_on_failure: false,
484 max_body_length: 1_048_576,
486 follow_redirect: true,
493 test "common keyword" do
496 %{"tuple" => [":level", ":warn"]},
497 %{"tuple" => [":meta", [":all"]]},
498 %{"tuple" => [":path", ""]},
499 %{"tuple" => [":val", nil]},
500 %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
504 :erlang.term_to_binary(
509 webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
512 assert Config.from_binary(binary) == [
517 webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
521 test "complex keyword with sigil" do
524 %{"tuple" => [":federated_timeline_removal", []]},
525 %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
526 %{"tuple" => [":replace", []]}
530 :erlang.term_to_binary(
531 federated_timeline_removal: [],
532 reject: [~r/comp[lL][aA][iI][nN]er/],
536 assert Config.from_binary(binary) ==
537 [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
540 test "complex keyword with tuples with more than 2 values" do
558 "Pleroma.Web.MastodonAPI.WebsocketHandler",
565 "Phoenix.Endpoint.CowboyWebSocket",
568 "Phoenix.Transports.WebSocket",
571 "Pleroma.Web.Endpoint",
572 "Pleroma.Web.UserSocket",
583 "Phoenix.Endpoint.Cowboy2Handler",
584 %{"tuple" => ["Pleroma.Web.Endpoint", []]}
599 :erlang.term_to_binary(
603 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
604 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
605 {Phoenix.Transports.WebSocket,
606 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
607 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
613 assert Config.from_binary(binary) == [
618 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
619 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
620 {Phoenix.Transports.WebSocket,
621 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
622 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}