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