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.ConfigDBTest do
6 use Pleroma.DataCase, async: true
10 test "get_by_key/1" do
11 config = insert(:config)
14 assert config == ConfigDB.get_by_params(%{group: config.group, key: config.key})
18 {:ok, config} = ConfigDB.create(%{group: ":pleroma", key: ":some_key", value: "some_value"})
19 assert config == ConfigDB.get_by_params(%{group: ":pleroma", key: ":some_key"})
23 config = insert(:config)
24 {:ok, updated} = ConfigDB.update(config, %{value: "some_value"})
25 loaded = ConfigDB.get_by_params(%{group: config.group, key: config.key})
26 assert loaded == updated
29 test "get_all_as_keyword/0" do
31 insert(:config, group: ":quack", key: ":level", value: ConfigDB.to_binary(:info))
32 insert(:config, group: ":quack", key: ":meta", value: ConfigDB.to_binary([:none]))
37 value: ConfigDB.to_binary("https://hooks.slack.com/services/KEY/some_val")
41 pleroma: [{_, %{another: _, another_key: _}}],
45 webhook_url: "https://hooks.slack.com/services/KEY/some_val"
47 ] = ConfigDB.get_all_as_keyword()
50 describe "update_or_create/1" do
52 config = insert(:config)
56 %{group: "pleroma", key: key2, value: "another_value"},
57 %{group: config.group, key: config.key, value: "new_value"}
60 assert Repo.all(ConfigDB) |> length() == 1
62 Enum.each(params, &ConfigDB.update_or_create(&1))
64 assert Repo.all(ConfigDB) |> length() == 2
66 config1 = ConfigDB.get_by_params(%{group: config.group, key: config.key})
67 config2 = ConfigDB.get_by_params(%{group: "pleroma", key: key2})
69 assert config1.value == ConfigDB.transform("new_value")
70 assert config2.value == ConfigDB.transform("another_value")
73 test "partial update" do
74 config = insert(:config, value: ConfigDB.to_binary(key1: "val1", key2: :val2))
77 ConfigDB.update_or_create(%{
80 value: [key1: :val1, key3: :val3]
83 updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})
85 value = ConfigDB.from_binary(updated.value)
86 assert length(value) == 3
87 assert value[:key1] == :val1
88 assert value[:key2] == :val2
89 assert value[:key3] == :val3
93 config = insert(:config, value: ConfigDB.to_binary(key1: "val1", key2: [k1: :v1, k2: "v2"]))
96 ConfigDB.update_or_create(%{
99 value: [key1: :val1, key2: [k2: :v2, k3: :v3], key3: :val3]
102 updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})
104 assert config.value == updated.value
106 value = ConfigDB.from_binary(updated.value)
107 assert value[:key1] == :val1
108 assert value[:key2] == [k1: :v1, k2: :v2, k3: :v3]
109 assert value[:key3] == :val3
112 test "only full update for some keys" do
113 config1 = insert(:config, key: ":ecto_repos", value: ConfigDB.to_binary(repo: Pleroma.Repo))
116 insert(:config, group: ":cors_plug", key: ":max_age", value: ConfigDB.to_binary(18))
119 ConfigDB.update_or_create(%{
120 group: config1.group,
122 value: [another_repo: [Pleroma.Repo]]
126 ConfigDB.update_or_create(%{
127 group: config2.group,
132 updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
133 updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})
135 assert ConfigDB.from_binary(updated1.value) == [another_repo: [Pleroma.Repo]]
136 assert ConfigDB.from_binary(updated2.value) == 777
139 test "full update if value is not keyword" do
144 value: ConfigDB.to_binary(Tesla.Adapter.Hackney)
148 ConfigDB.update_or_create(%{
151 value: Tesla.Adapter.Httpc
154 updated = ConfigDB.get_by_params(%{group: config.group, key: config.key})
156 assert ConfigDB.from_binary(updated.value) == Tesla.Adapter.Httpc
159 test "only full update for some subkeys" do
163 value: ConfigDB.to_binary(groups: [a: 1, b: 2], key: [a: 1])
169 value: ConfigDB.to_binary(mascots: [a: 1, b: 2], key: [a: 1])
173 ConfigDB.update_or_create(%{
174 group: config1.group,
176 value: [groups: [c: 3, d: 4], key: [b: 2]]
180 ConfigDB.update_or_create(%{
181 group: config2.group,
183 value: [mascots: [c: 3, d: 4], key: [b: 2]]
186 updated1 = ConfigDB.get_by_params(%{group: config1.group, key: config1.key})
187 updated2 = ConfigDB.get_by_params(%{group: config2.group, key: config2.key})
189 assert ConfigDB.from_binary(updated1.value) == [groups: [c: 3, d: 4], key: [a: 1, b: 2]]
190 assert ConfigDB.from_binary(updated2.value) == [mascots: [c: 3, d: 4], key: [a: 1, b: 2]]
195 config = insert(:config)
196 {:ok, _} = ConfigDB.delete(%{key: config.key, group: config.group})
197 refute ConfigDB.get_by_params(%{key: config.key, group: config.group})
200 describe "transform/1" do
202 binary = ConfigDB.transform("value as string")
203 assert binary == :erlang.term_to_binary("value as string")
204 assert ConfigDB.from_binary(binary) == "value as string"
208 binary = ConfigDB.transform(false)
209 assert binary == :erlang.term_to_binary(false)
210 assert ConfigDB.from_binary(binary) == false
214 binary = ConfigDB.transform(nil)
215 assert binary == :erlang.term_to_binary(nil)
216 assert ConfigDB.from_binary(binary) == nil
220 binary = ConfigDB.transform(150)
221 assert binary == :erlang.term_to_binary(150)
222 assert ConfigDB.from_binary(binary) == 150
226 binary = ConfigDB.transform(":atom")
227 assert binary == :erlang.term_to_binary(:atom)
228 assert ConfigDB.from_binary(binary) == :atom
231 test "ssl options" do
232 binary = ConfigDB.transform([":tlsv1", ":tlsv1.1", ":tlsv1.2"])
233 assert binary == :erlang.term_to_binary([:tlsv1, :"tlsv1.1", :"tlsv1.2"])
234 assert ConfigDB.from_binary(binary) == [:tlsv1, :"tlsv1.1", :"tlsv1.2"]
237 test "pleroma module" do
238 binary = ConfigDB.transform("Pleroma.Bookmark")
239 assert binary == :erlang.term_to_binary(Pleroma.Bookmark)
240 assert ConfigDB.from_binary(binary) == Pleroma.Bookmark
243 test "pleroma string" do
244 binary = ConfigDB.transform("Pleroma")
245 assert binary == :erlang.term_to_binary("Pleroma")
246 assert ConfigDB.from_binary(binary) == "Pleroma"
249 test "phoenix module" do
250 binary = ConfigDB.transform("Phoenix.Socket.V1.JSONSerializer")
251 assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
252 assert ConfigDB.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
255 test "tesla module" do
256 binary = ConfigDB.transform("Tesla.Adapter.Hackney")
257 assert binary == :erlang.term_to_binary(Tesla.Adapter.Hackney)
258 assert ConfigDB.from_binary(binary) == Tesla.Adapter.Hackney
261 test "ExSyslogger module" do
262 binary = ConfigDB.transform("ExSyslogger")
263 assert binary == :erlang.term_to_binary(ExSyslogger)
264 assert ConfigDB.from_binary(binary) == ExSyslogger
267 test "Quack.Logger module" do
268 binary = ConfigDB.transform("Quack.Logger")
269 assert binary == :erlang.term_to_binary(Quack.Logger)
270 assert ConfigDB.from_binary(binary) == Quack.Logger
274 binary = ConfigDB.transform("~r[comp[lL][aA][iI][nN]er]")
275 assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
276 assert ConfigDB.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
280 binary = ConfigDB.transform("~r/https:\/\/example.com/")
281 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/)
282 assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/
285 test "link sigil with um modifiers" do
286 binary = ConfigDB.transform("~r/https:\/\/example.com/um")
287 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/um)
288 assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/um
291 test "link sigil with i modifier" do
292 binary = ConfigDB.transform("~r/https:\/\/example.com/i")
293 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/i)
294 assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/i
297 test "link sigil with s modifier" do
298 binary = ConfigDB.transform("~r/https:\/\/example.com/s")
299 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/s)
300 assert ConfigDB.from_binary(binary) == ~r/https:\/\/example.com/s
303 test "raise if valid delimiter not found" do
304 assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
305 ConfigDB.transform("~r/https://[]{}<>\"'()|example.com/s")
309 test "2 child tuple" do
310 binary = ConfigDB.transform(%{"tuple" => ["v1", ":v2"]})
311 assert binary == :erlang.term_to_binary({"v1", :v2})
312 assert ConfigDB.from_binary(binary) == {"v1", :v2}
315 test "proxy tuple with localhost" do
317 ConfigDB.transform(%{
318 "tuple" => [":proxy_url", %{"tuple" => [":socks5", "localhost", 1234]}]
321 assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, :localhost, 1234}})
322 assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, :localhost, 1234}}
325 test "proxy tuple with domain" do
327 ConfigDB.transform(%{
328 "tuple" => [":proxy_url", %{"tuple" => [":socks5", "domain.com", 1234]}]
331 assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, 'domain.com', 1234}})
332 assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, 'domain.com', 1234}}
335 test "proxy tuple with ip" do
337 ConfigDB.transform(%{
338 "tuple" => [":proxy_url", %{"tuple" => [":socks5", "127.0.0.1", 1234]}]
341 assert binary == :erlang.term_to_binary({:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}})
342 assert ConfigDB.from_binary(binary) == {:proxy_url, {:socks5, {127, 0, 0, 1}, 1234}}
345 test "tuple with n childs" do
347 ConfigDB.transform(%{
354 "Phoenix.Socket.V1.JSONSerializer"
359 :erlang.term_to_binary(
360 {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
363 assert ConfigDB.from_binary(binary) ==
364 {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
367 test "map with string key" do
368 binary = ConfigDB.transform(%{"key" => "value"})
369 assert binary == :erlang.term_to_binary(%{"key" => "value"})
370 assert ConfigDB.from_binary(binary) == %{"key" => "value"}
373 test "map with atom key" do
374 binary = ConfigDB.transform(%{":key" => "value"})
375 assert binary == :erlang.term_to_binary(%{key: "value"})
376 assert ConfigDB.from_binary(binary) == %{key: "value"}
379 test "list of strings" do
380 binary = ConfigDB.transform(["v1", "v2", "v3"])
381 assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
382 assert ConfigDB.from_binary(binary) == ["v1", "v2", "v3"]
385 test "list of modules" do
386 binary = ConfigDB.transform(["Pleroma.Repo", "Pleroma.Activity"])
387 assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
388 assert ConfigDB.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
391 test "list of atoms" do
392 binary = ConfigDB.transform([":v1", ":v2", ":v3"])
393 assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
394 assert ConfigDB.from_binary(binary) == [:v1, :v2, :v3]
397 test "list of mixed values" do
403 "Phoenix.Socket.V1.JSONSerializer",
409 :erlang.term_to_binary([
413 Phoenix.Socket.V1.JSONSerializer,
418 assert ConfigDB.from_binary(binary) == [
422 Phoenix.Socket.V1.JSONSerializer,
428 test "simple keyword" do
429 binary = ConfigDB.transform([%{"tuple" => [":key", "value"]}])
430 assert binary == :erlang.term_to_binary([{:key, "value"}])
431 assert ConfigDB.from_binary(binary) == [{:key, "value"}]
432 assert ConfigDB.from_binary(binary) == [key: "value"]
435 test "keyword with partial_chain key" do
437 ConfigDB.transform([%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}])
439 assert binary == :erlang.term_to_binary(partial_chain: &:hackney_connect.partial_chain/1)
440 assert ConfigDB.from_binary(binary) == [partial_chain: &:hackney_connect.partial_chain/1]
446 %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
447 %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
448 %{"tuple" => [":migration_lock", nil]},
449 %{"tuple" => [":key1", 150]},
450 %{"tuple" => [":key2", "string"]}
454 :erlang.term_to_binary(
455 types: Pleroma.PostgresTypes,
456 telemetry_event: [Pleroma.Repo.Instrumenter],
462 assert ConfigDB.from_binary(binary) == [
463 types: Pleroma.PostgresTypes,
464 telemetry_event: [Pleroma.Repo.Instrumenter],
471 test "complex keyword with nested mixed childs" do
474 %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
475 %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
476 %{"tuple" => [":link_name", true]},
477 %{"tuple" => [":proxy_remote", false]},
478 %{"tuple" => [":common_map", %{":key" => "value"}]},
483 %{"tuple" => [":redirect_on_failure", false]},
484 %{"tuple" => [":max_body_length", 1_048_576]},
488 [%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
497 :erlang.term_to_binary(
498 uploader: Pleroma.Uploaders.Local,
499 filters: [Pleroma.Upload.Filter.Dedupe],
502 common_map: %{key: "value"},
504 redirect_on_failure: false,
505 max_body_length: 1_048_576,
507 follow_redirect: true,
513 assert ConfigDB.from_binary(binary) ==
515 uploader: Pleroma.Uploaders.Local,
516 filters: [Pleroma.Upload.Filter.Dedupe],
519 common_map: %{key: "value"},
521 redirect_on_failure: false,
522 max_body_length: 1_048_576,
524 follow_redirect: true,
531 test "common keyword" do
534 %{"tuple" => [":level", ":warn"]},
535 %{"tuple" => [":meta", [":all"]]},
536 %{"tuple" => [":path", ""]},
537 %{"tuple" => [":val", nil]},
538 %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
542 :erlang.term_to_binary(
547 webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
550 assert ConfigDB.from_binary(binary) == [
555 webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
559 test "complex keyword with sigil" do
562 %{"tuple" => [":federated_timeline_removal", []]},
563 %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
564 %{"tuple" => [":replace", []]}
568 :erlang.term_to_binary(
569 federated_timeline_removal: [],
570 reject: [~r/comp[lL][aA][iI][nN]er/],
574 assert ConfigDB.from_binary(binary) ==
575 [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
578 test "complex keyword with tuples with more than 2 values" do
596 "Pleroma.Web.MastodonAPI.WebsocketHandler",
603 "Phoenix.Endpoint.CowboyWebSocket",
606 "Phoenix.Transports.WebSocket",
609 "Pleroma.Web.Endpoint",
610 "Pleroma.Web.UserSocket",
621 "Phoenix.Endpoint.Cowboy2Handler",
622 %{"tuple" => ["Pleroma.Web.Endpoint", []]}
637 :erlang.term_to_binary(
641 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
642 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
643 {Phoenix.Transports.WebSocket,
644 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
645 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
651 assert ConfigDB.from_binary(binary) == [
656 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
657 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
658 {Phoenix.Transports.WebSocket,
659 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
660 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}