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 test "update_or_create/1" do
30 config = insert(:config)
34 %{group: "pleroma", key: key2, value: "another_value"},
35 %{group: config.group, key: config.key, value: "new_value"}
38 assert Repo.all(Config) |> length() == 1
40 Enum.each(params, &Config.update_or_create(&1))
42 assert Repo.all(Config) |> length() == 2
44 config1 = Config.get_by_params(%{group: config.group, key: config.key})
45 config2 = Config.get_by_params(%{group: "pleroma", key: key2})
47 assert config1.value == Config.transform("new_value")
48 assert config2.value == Config.transform("another_value")
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})
57 describe "transform/1" 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"
65 binary = Config.transform(false)
66 assert binary == :erlang.term_to_binary(false)
67 assert Config.from_binary(binary) == false
71 binary = Config.transform(nil)
72 assert binary == :erlang.term_to_binary(nil)
73 assert Config.from_binary(binary) == nil
77 binary = Config.transform(150)
78 assert binary == :erlang.term_to_binary(150)
79 assert Config.from_binary(binary) == 150
83 binary = Config.transform(":atom")
84 assert binary == :erlang.term_to_binary(:atom)
85 assert Config.from_binary(binary) == :atom
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
94 test "pleroma string" do
95 binary = Config.transform("Pleroma")
96 assert binary == :erlang.term_to_binary("Pleroma")
97 assert Config.from_binary(binary) == "Pleroma"
100 test "phoenix module" do
101 binary = Config.transform("Phoenix.Socket.V1.JSONSerializer")
102 assert binary == :erlang.term_to_binary(Phoenix.Socket.V1.JSONSerializer)
103 assert Config.from_binary(binary) == Phoenix.Socket.V1.JSONSerializer
106 test "tesla module" do
107 binary = Config.transform("Tesla.Adapter.Hackney")
108 assert binary == :erlang.term_to_binary(Tesla.Adapter.Hackney)
109 assert Config.from_binary(binary) == Tesla.Adapter.Hackney
113 binary = Config.transform("~r[comp[lL][aA][iI][nN]er]")
114 assert binary == :erlang.term_to_binary(~r/comp[lL][aA][iI][nN]er/)
115 assert Config.from_binary(binary) == ~r/comp[lL][aA][iI][nN]er/
119 binary = Config.transform("~r/https:\/\/example.com/")
120 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/)
121 assert Config.from_binary(binary) == ~r/https:\/\/example.com/
124 test "link sigil with um modifiers" do
125 binary = Config.transform("~r/https:\/\/example.com/um")
126 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/um)
127 assert Config.from_binary(binary) == ~r/https:\/\/example.com/um
130 test "link sigil with i modifier" do
131 binary = Config.transform("~r/https:\/\/example.com/i")
132 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/i)
133 assert Config.from_binary(binary) == ~r/https:\/\/example.com/i
136 test "link sigil with s modifier" do
137 binary = Config.transform("~r/https:\/\/example.com/s")
138 assert binary == :erlang.term_to_binary(~r/https:\/\/example.com/s)
139 assert Config.from_binary(binary) == ~r/https:\/\/example.com/s
142 test "raise if valid delimiter not found" do
143 assert_raise ArgumentError, "valid delimiter for Regex expression not found", fn ->
144 Config.transform("~r/https://[]{}<>\"'()|example.com/s")
148 test "2 child tuple" do
149 binary = Config.transform(%{"tuple" => ["v1", ":v2"]})
150 assert binary == :erlang.term_to_binary({"v1", :v2})
151 assert Config.from_binary(binary) == {"v1", :v2}
154 test "tuple with n childs" do
163 "Phoenix.Socket.V1.JSONSerializer"
168 :erlang.term_to_binary(
169 {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
172 assert Config.from_binary(binary) ==
173 {"v1", :v2, Pleroma.Bookmark, 150, false, Phoenix.Socket.V1.JSONSerializer}
176 test "tuple with dispatch key" do
177 binary = Config.transform(%{"tuple" => [":dispatch", ["{:_,
179 {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
180 {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
181 {Phoenix.Transports.WebSocket,
182 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
183 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
187 :erlang.term_to_binary(
192 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
193 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
194 {Phoenix.Transports.WebSocket,
195 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
196 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
201 assert Config.from_binary(binary) ==
206 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
207 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
208 {Phoenix.Transports.WebSocket,
209 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: "/websocket"]}}},
210 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
215 test "map with string key" do
216 binary = Config.transform(%{"key" => "value"})
217 assert binary == :erlang.term_to_binary(%{"key" => "value"})
218 assert Config.from_binary(binary) == %{"key" => "value"}
221 test "map with atom key" do
222 binary = Config.transform(%{":key" => "value"})
223 assert binary == :erlang.term_to_binary(%{key: "value"})
224 assert Config.from_binary(binary) == %{key: "value"}
227 test "list of strings" do
228 binary = Config.transform(["v1", "v2", "v3"])
229 assert binary == :erlang.term_to_binary(["v1", "v2", "v3"])
230 assert Config.from_binary(binary) == ["v1", "v2", "v3"]
233 test "list of modules" do
234 binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
235 assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
236 assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
239 test "list of atoms" do
240 binary = Config.transform([":v1", ":v2", ":v3"])
241 assert binary == :erlang.term_to_binary([:v1, :v2, :v3])
242 assert Config.from_binary(binary) == [:v1, :v2, :v3]
245 test "list of mixed values" do
251 "Phoenix.Socket.V1.JSONSerializer",
257 :erlang.term_to_binary([
261 Phoenix.Socket.V1.JSONSerializer,
266 assert Config.from_binary(binary) == [
270 Phoenix.Socket.V1.JSONSerializer,
276 test "simple keyword" do
277 binary = Config.transform([%{"tuple" => [":key", "value"]}])
278 assert binary == :erlang.term_to_binary([{:key, "value"}])
279 assert Config.from_binary(binary) == [{:key, "value"}]
280 assert Config.from_binary(binary) == [key: "value"]
283 test "keyword with partial_chain key" do
285 Config.transform([%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}])
287 assert binary == :erlang.term_to_binary(partial_chain: &:hackney_connect.partial_chain/1)
288 assert Config.from_binary(binary) == [partial_chain: &:hackney_connect.partial_chain/1]
294 %{"tuple" => [":types", "Pleroma.PostgresTypes"]},
295 %{"tuple" => [":telemetry_event", ["Pleroma.Repo.Instrumenter"]]},
296 %{"tuple" => [":migration_lock", nil]},
297 %{"tuple" => [":key1", 150]},
298 %{"tuple" => [":key2", "string"]}
302 :erlang.term_to_binary(
303 types: Pleroma.PostgresTypes,
304 telemetry_event: [Pleroma.Repo.Instrumenter],
310 assert Config.from_binary(binary) == [
311 types: Pleroma.PostgresTypes,
312 telemetry_event: [Pleroma.Repo.Instrumenter],
319 test "complex keyword with nested mixed childs" do
322 %{"tuple" => [":uploader", "Pleroma.Uploaders.Local"]},
323 %{"tuple" => [":filters", ["Pleroma.Upload.Filter.Dedupe"]]},
324 %{"tuple" => [":link_name", true]},
325 %{"tuple" => [":proxy_remote", false]},
326 %{"tuple" => [":common_map", %{":key" => "value"}]},
331 %{"tuple" => [":redirect_on_failure", false]},
332 %{"tuple" => [":max_body_length", 1_048_576]},
336 [%{"tuple" => [":follow_redirect", true]}, %{"tuple" => [":pool", ":upload"]}]
345 :erlang.term_to_binary(
346 uploader: Pleroma.Uploaders.Local,
347 filters: [Pleroma.Upload.Filter.Dedupe],
350 common_map: %{key: "value"},
352 redirect_on_failure: false,
353 max_body_length: 1_048_576,
355 follow_redirect: true,
361 assert Config.from_binary(binary) ==
363 uploader: Pleroma.Uploaders.Local,
364 filters: [Pleroma.Upload.Filter.Dedupe],
367 common_map: %{key: "value"},
369 redirect_on_failure: false,
370 max_body_length: 1_048_576,
372 follow_redirect: true,
379 test "common keyword" do
382 %{"tuple" => [":level", ":warn"]},
383 %{"tuple" => [":meta", [":all"]]},
384 %{"tuple" => [":path", ""]},
385 %{"tuple" => [":val", nil]},
386 %{"tuple" => [":webhook_url", "https://hooks.slack.com/services/YOUR-KEY-HERE"]}
390 :erlang.term_to_binary(
395 webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
398 assert Config.from_binary(binary) == [
403 webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
407 test "complex keyword with sigil" do
410 %{"tuple" => [":federated_timeline_removal", []]},
411 %{"tuple" => [":reject", ["~r/comp[lL][aA][iI][nN]er/"]]},
412 %{"tuple" => [":replace", []]}
416 :erlang.term_to_binary(
417 federated_timeline_removal: [],
418 reject: [~r/comp[lL][aA][iI][nN]er/],
422 assert Config.from_binary(binary) ==
423 [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
426 test "complex keyword with tuples with more than 2 values" do
444 "Pleroma.Web.MastodonAPI.WebsocketHandler",
451 "Phoenix.Endpoint.CowboyWebSocket",
454 "Phoenix.Transports.WebSocket",
457 "Pleroma.Web.Endpoint",
458 "Pleroma.Web.UserSocket",
469 "Phoenix.Endpoint.Cowboy2Handler",
470 %{"tuple" => ["Pleroma.Web.Endpoint", []]}
485 :erlang.term_to_binary(
489 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
490 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
491 {Phoenix.Transports.WebSocket,
492 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
493 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
499 assert Config.from_binary(binary) == [
504 {"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
505 {"/websocket", Phoenix.Endpoint.CowboyWebSocket,
506 {Phoenix.Transports.WebSocket,
507 {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, []}}},
508 {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}