git.squeep.com Git - akkoma/blob - test/web/admin_api/admin_api_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.HTML
  10   alias Pleroma.User
  11   alias Pleroma.UserInviteToken
  12   alias Pleroma.Web.CommonAPI
  13   alias Pleroma.Web.MediaProxy
  14   import Pleroma.Factory
  15
  16   describe "/api/pleroma/admin/users" do
  17     test "Delete" do
  18       admin = insert(:user, info: %{is_admin: true})
  19       user = insert(:user)
  20
  21       conn =
  22         build_conn()
  23         |> assign(:user, admin)
  24         |> put_req_header("accept", "application/json")
  25         |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
  26
  27       assert json_response(conn, 200) == user.nickname
  28     end
  29
  30     test "Create" do
  31       admin = insert(:user, info: %{is_admin: true})
  32
  33       conn =
  34         build_conn()
  35         |> assign(:user, admin)
  36         |> put_req_header("accept", "application/json")
  37         |> post("/api/pleroma/admin/users", %{
  38           "nickname" => "lain",
  39           "email" => "lain@example.org",
  40           "password" => "test"
  41         })
  42
  43       assert json_response(conn, 200) == "lain"
  44     end
  45   end
  46
  47   describe "/api/pleroma/admin/users/:nickname" do
  48     test "Show", %{conn: conn} do
  49       admin = insert(:user, info: %{is_admin: true})
  50       user = insert(:user)
  51
  52       conn =
  53         conn
  54         |> assign(:user, admin)
  55         |> get("/api/pleroma/admin/users/#{user.nickname}")
  56
  57       expected = %{
  58         "deactivated" => false,
  59         "id" => to_string(user.id),
  60         "local" => true,
  61         "nickname" => user.nickname,
  62         "roles" => %{"admin" => false, "moderator" => false},
  63         "tags" => [],
  64         "avatar" => User.avatar_url(user) |> MediaProxy.url(),
  65         "display_name" => HTML.strip_tags(user.name || user.nickname)
  66       }
  67
  68       assert expected == json_response(conn, 200)
  69     end
  70
  71     test "when the user doesn't exist", %{conn: conn} do
  72       admin = insert(:user, info: %{is_admin: true})
  73       user = build(:user)
  74
  75       conn =
  76         conn
  77         |> assign(:user, admin)
  78         |> get("/api/pleroma/admin/users/#{user.nickname}")
  79
  80       assert "Not found" == json_response(conn, 404)
  81     end
  82   end
  83
  84   describe "/api/pleroma/admin/users/follow" do
  85     test "allows to force-follow another user" do
  86       admin = insert(:user, info: %{is_admin: true})
  87       user = insert(:user)
  88       follower = insert(:user)
  89
  90       build_conn()
  91       |> assign(:user, admin)
  92       |> put_req_header("accept", "application/json")
  93       |> post("/api/pleroma/admin/users/follow", %{
  94         "follower" => follower.nickname,
  95         "followed" => user.nickname
  96       })
  97
  98       user = User.get_cached_by_id(user.id)
  99       follower = User.get_cached_by_id(follower.id)
 100
 101       assert User.following?(follower, user)
 102     end
 103   end
 104
 105   describe "/api/pleroma/admin/users/unfollow" do
 106     test "allows to force-unfollow another user" do
 107       admin = insert(:user, info: %{is_admin: true})
 108       user = insert(:user)
 109       follower = insert(:user)
 110
 111       User.follow(follower, user)
 112
 113       build_conn()
 114       |> assign(:user, admin)
 115       |> put_req_header("accept", "application/json")
 116       |> post("/api/pleroma/admin/users/unfollow", %{
 117         "follower" => follower.nickname,
 118         "followed" => user.nickname
 119       })
 120
 121       user = User.get_cached_by_id(user.id)
 122       follower = User.get_cached_by_id(follower.id)
 123
 124       refute User.following?(follower, user)
 125     end
 126   end
 127
 128   describe "PUT /api/pleroma/admin/users/tag" do
 129     setup do
 130       admin = insert(:user, info: %{is_admin: true})
 131       user1 = insert(:user, %{tags: ["x"]})
 132       user2 = insert(:user, %{tags: ["y"]})
 133       user3 = insert(:user, %{tags: ["unchanged"]})
 134
 135       conn =
 136         build_conn()
 137         |> assign(:user, admin)
 138         |> put_req_header("accept", "application/json")
 139         |> put(
 140           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 141             user2.nickname
 142           }&tags[]=foo&tags[]=bar"
 143         )
 144
 145       %{conn: conn, user1: user1, user2: user2, user3: user3}
 146     end
 147
 148     test "it appends specified tags to users with specified nicknames", %{
 149       conn: conn,
 150       user1: user1,
 151       user2: user2
 152     } do
 153       assert json_response(conn, :no_content)
 154       assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
 155       assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
 156     end
 157
 158     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 159       assert json_response(conn, :no_content)
 160       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 161     end
 162   end
 163
 164   describe "DELETE /api/pleroma/admin/users/tag" do
 165     setup do
 166       admin = insert(:user, info: %{is_admin: true})
 167       user1 = insert(:user, %{tags: ["x"]})
 168       user2 = insert(:user, %{tags: ["y", "z"]})
 169       user3 = insert(:user, %{tags: ["unchanged"]})
 170
 171       conn =
 172         build_conn()
 173         |> assign(:user, admin)
 174         |> put_req_header("accept", "application/json")
 175         |> delete(
 176           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 177             user2.nickname
 178           }&tags[]=x&tags[]=z"
 179         )
 180
 181       %{conn: conn, user1: user1, user2: user2, user3: user3}
 182     end
 183
 184     test "it removes specified tags from users with specified nicknames", %{
 185       conn: conn,
 186       user1: user1,
 187       user2: user2
 188     } do
 189       assert json_response(conn, :no_content)
 190       assert User.get_cached_by_id(user1.id).tags == []
 191       assert User.get_cached_by_id(user2.id).tags == ["y"]
 192     end
 193
 194     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 195       assert json_response(conn, :no_content)
 196       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 197     end
 198   end
 199
 200   describe "/api/pleroma/admin/users/:nickname/permission_group" do
 201     test "GET is giving user_info" do
 202       admin = insert(:user, info: %{is_admin: true})
 203
 204       conn =
 205         build_conn()
 206         |> assign(:user, admin)
 207         |> put_req_header("accept", "application/json")
 208         |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
 209
 210       assert json_response(conn, 200) == %{
 211                "is_admin" => true,
 212                "is_moderator" => false
 213              }
 214     end
 215
 216     test "/:right POST, can add to a permission group" do
 217       admin = insert(:user, info: %{is_admin: true})
 218       user = insert(:user)
 219
 220       conn =
 221         build_conn()
 222         |> assign(:user, admin)
 223         |> put_req_header("accept", "application/json")
 224         |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 225
 226       assert json_response(conn, 200) == %{
 227                "is_admin" => true
 228              }
 229     end
 230
 231     test "/:right DELETE, can remove from a permission group" do
 232       admin = insert(:user, info: %{is_admin: true})
 233       user = insert(:user, info: %{is_admin: true})
 234
 235       conn =
 236         build_conn()
 237         |> assign(:user, admin)
 238         |> put_req_header("accept", "application/json")
 239         |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 240
 241       assert json_response(conn, 200) == %{
 242                "is_admin" => false
 243              }
 244     end
 245   end
 246
 247   describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
 248     setup %{conn: conn} do
 249       admin = insert(:user, info: %{is_admin: true})
 250
 251       conn =
 252         conn
 253         |> assign(:user, admin)
 254         |> put_req_header("accept", "application/json")
 255
 256       %{conn: conn}
 257     end
 258
 259     test "deactivates the user", %{conn: conn} do
 260       user = insert(:user)
 261
 262       conn =
 263         conn
 264         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 265
 266       user = User.get_cached_by_id(user.id)
 267       assert user.info.deactivated == true
 268       assert json_response(conn, :no_content)
 269     end
 270
 271     test "activates the user", %{conn: conn} do
 272       user = insert(:user, info: %{deactivated: true})
 273
 274       conn =
 275         conn
 276         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
 277
 278       user = User.get_cached_by_id(user.id)
 279       assert user.info.deactivated == false
 280       assert json_response(conn, :no_content)
 281     end
 282
 283     test "returns 403 when requested by a non-admin", %{conn: conn} do
 284       user = insert(:user)
 285
 286       conn =
 287         conn
 288         |> assign(:user, user)
 289         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 290
 291       assert json_response(conn, :forbidden)
 292     end
 293   end
 294
 295   describe "POST /api/pleroma/admin/email_invite, with valid config" do
 296     setup do
 297       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 298       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 299       Pleroma.Config.put([:instance, :registrations_open], false)
 300       Pleroma.Config.put([:instance, :invites_enabled], true)
 301
 302       on_exit(fn ->
 303         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 304         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 305         :ok
 306       end)
 307
 308       [user: insert(:user, info: %{is_admin: true})]
 309     end
 310
 311     test "sends invitation and returns 204", %{conn: conn, user: user} do
 312       recipient_email = "foo@bar.com"
 313       recipient_name = "J. D."
 314
 315       conn =
 316         conn
 317         |> assign(:user, user)
 318         |> post(
 319           "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
 320         )
 321
 322       assert json_response(conn, :no_content)
 323
 324       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 325       assert token_record
 326       refute token_record.used
 327
 328       notify_email = Pleroma.Config.get([:instance, :notify_email])
 329       instance_name = Pleroma.Config.get([:instance, :name])
 330
 331       email =
 332         Pleroma.Emails.UserEmail.user_invitation_email(
 333           user,
 334           token_record,
 335           recipient_email,
 336           recipient_name
 337         )
 338
 339       Swoosh.TestAssertions.assert_email_sent(
 340         from: {instance_name, notify_email},
 341         to: {recipient_name, recipient_email},
 342         html_body: email.html_body
 343       )
 344     end
 345
 346     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 347       non_admin_user = insert(:user)
 348
 349       conn =
 350         conn
 351         |> assign(:user, non_admin_user)
 352         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 353
 354       assert json_response(conn, :forbidden)
 355     end
 356   end
 357
 358   describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
 359     setup do
 360       [user: insert(:user, info: %{is_admin: true})]
 361     end
 362
 363     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 364       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 365       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 366       Pleroma.Config.put([:instance, :registrations_open], false)
 367       Pleroma.Config.put([:instance, :invites_enabled], false)
 368
 369       on_exit(fn ->
 370         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 371         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 372         :ok
 373       end)
 374
 375       conn =
 376         conn
 377         |> assign(:user, user)
 378         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 379
 380       assert json_response(conn, :internal_server_error)
 381     end
 382
 383     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 384       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 385       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 386       Pleroma.Config.put([:instance, :registrations_open], true)
 387       Pleroma.Config.put([:instance, :invites_enabled], true)
 388
 389       on_exit(fn ->
 390         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 391         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 392         :ok
 393       end)
 394
 395       conn =
 396         conn
 397         |> assign(:user, user)
 398         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 399
 400       assert json_response(conn, :internal_server_error)
 401     end
 402   end
 403
 404   test "/api/pleroma/admin/users/invite_token" do
 405     admin = insert(:user, info: %{is_admin: true})
 406
 407     conn =
 408       build_conn()
 409       |> assign(:user, admin)
 410       |> put_req_header("accept", "application/json")
 411       |> get("/api/pleroma/admin/users/invite_token")
 412
 413     assert conn.status == 200
 414   end
 415
 416   test "/api/pleroma/admin/users/:nickname/password_reset" do
 417     admin = insert(:user, info: %{is_admin: true})
 418     user = insert(:user)
 419
 420     conn =
 421       build_conn()
 422       |> assign(:user, admin)
 423       |> put_req_header("accept", "application/json")
 424       |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
 425
 426     assert conn.status == 200
 427   end
 428
 429   describe "GET /api/pleroma/admin/users" do
 430     setup do
 431       admin = insert(:user, info: %{is_admin: true})
 432
 433       conn =
 434         build_conn()
 435         |> assign(:user, admin)
 436
 437       {:ok, conn: conn, admin: admin}
 438     end
 439
 440     test "renders users array for the first page", %{conn: conn, admin: admin} do
 441       user = insert(:user, local: false, tags: ["foo", "bar"])
 442       conn = get(conn, "/api/pleroma/admin/users?page=1")
 443
 444       users =
 445         [
 446           %{
 447             "deactivated" => admin.info.deactivated,
 448             "id" => admin.id,
 449             "nickname" => admin.nickname,
 450             "roles" => %{"admin" => true, "moderator" => false},
 451             "local" => true,
 452             "tags" => [],
 453             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 454             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 455           },
 456           %{
 457             "deactivated" => user.info.deactivated,
 458             "id" => user.id,
 459             "nickname" => user.nickname,
 460             "roles" => %{"admin" => false, "moderator" => false},
 461             "local" => false,
 462             "tags" => ["foo", "bar"],
 463             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 464             "display_name" => HTML.strip_tags(user.name || user.nickname)
 465           }
 466         ]
 467         |> Enum.sort_by(& &1["nickname"])
 468
 469       assert json_response(conn, 200) == %{
 470                "count" => 2,
 471                "page_size" => 50,
 472                "users" => users
 473              }
 474     end
 475
 476     test "renders empty array for the second page", %{conn: conn} do
 477       insert(:user)
 478
 479       conn = get(conn, "/api/pleroma/admin/users?page=2")
 480
 481       assert json_response(conn, 200) == %{
 482                "count" => 2,
 483                "page_size" => 50,
 484                "users" => []
 485              }
 486     end
 487
 488     test "regular search", %{conn: conn} do
 489       user = insert(:user, nickname: "bob")
 490
 491       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 492
 493       assert json_response(conn, 200) == %{
 494                "count" => 1,
 495                "page_size" => 50,
 496                "users" => [
 497                  %{
 498                    "deactivated" => user.info.deactivated,
 499                    "id" => user.id,
 500                    "nickname" => user.nickname,
 501                    "roles" => %{"admin" => false, "moderator" => false},
 502                    "local" => true,
 503                    "tags" => [],
 504                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 505                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 506                  }
 507                ]
 508              }
 509     end
 510
 511     test "search by domain", %{conn: conn} do
 512       user = insert(:user, nickname: "nickname@domain.com")
 513       insert(:user)
 514
 515       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 516
 517       assert json_response(conn, 200) == %{
 518                "count" => 1,
 519                "page_size" => 50,
 520                "users" => [
 521                  %{
 522                    "deactivated" => user.info.deactivated,
 523                    "id" => user.id,
 524                    "nickname" => user.nickname,
 525                    "roles" => %{"admin" => false, "moderator" => false},
 526                    "local" => true,
 527                    "tags" => [],
 528                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 529                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 530                  }
 531                ]
 532              }
 533     end
 534
 535     test "search by full nickname", %{conn: conn} do
 536       user = insert(:user, nickname: "nickname@domain.com")
 537       insert(:user)
 538
 539       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 540
 541       assert json_response(conn, 200) == %{
 542                "count" => 1,
 543                "page_size" => 50,
 544                "users" => [
 545                  %{
 546                    "deactivated" => user.info.deactivated,
 547                    "id" => user.id,
 548                    "nickname" => user.nickname,
 549                    "roles" => %{"admin" => false, "moderator" => false},
 550                    "local" => true,
 551                    "tags" => [],
 552                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 553                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 554                  }
 555                ]
 556              }
 557     end
 558
 559     test "search by display name", %{conn: conn} do
 560       user = insert(:user, name: "Display name")
 561       insert(:user)
 562
 563       conn = get(conn, "/api/pleroma/admin/users?name=display")
 564
 565       assert json_response(conn, 200) == %{
 566                "count" => 1,
 567                "page_size" => 50,
 568                "users" => [
 569                  %{
 570                    "deactivated" => user.info.deactivated,
 571                    "id" => user.id,
 572                    "nickname" => user.nickname,
 573                    "roles" => %{"admin" => false, "moderator" => false},
 574                    "local" => true,
 575                    "tags" => [],
 576                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 577                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 578                  }
 579                ]
 580              }
 581     end
 582
 583     test "search by email", %{conn: conn} do
 584       user = insert(:user, email: "email@example.com")
 585       insert(:user)
 586
 587       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 588
 589       assert json_response(conn, 200) == %{
 590                "count" => 1,
 591                "page_size" => 50,
 592                "users" => [
 593                  %{
 594                    "deactivated" => user.info.deactivated,
 595                    "id" => user.id,
 596                    "nickname" => user.nickname,
 597                    "roles" => %{"admin" => false, "moderator" => false},
 598                    "local" => true,
 599                    "tags" => [],
 600                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 601                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 602                  }
 603                ]
 604              }
 605     end
 606
 607     test "regular search with page size", %{conn: conn} do
 608       user = insert(:user, nickname: "aalice")
 609       user2 = insert(:user, nickname: "alice")
 610
 611       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 612
 613       assert json_response(conn1, 200) == %{
 614                "count" => 2,
 615                "page_size" => 1,
 616                "users" => [
 617                  %{
 618                    "deactivated" => user.info.deactivated,
 619                    "id" => user.id,
 620                    "nickname" => user.nickname,
 621                    "roles" => %{"admin" => false, "moderator" => false},
 622                    "local" => true,
 623                    "tags" => [],
 624                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 625                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 626                  }
 627                ]
 628              }
 629
 630       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 631
 632       assert json_response(conn2, 200) == %{
 633                "count" => 2,
 634                "page_size" => 1,
 635                "users" => [
 636                  %{
 637                    "deactivated" => user2.info.deactivated,
 638                    "id" => user2.id,
 639                    "nickname" => user2.nickname,
 640                    "roles" => %{"admin" => false, "moderator" => false},
 641                    "local" => true,
 642                    "tags" => [],
 643                    "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
 644                    "display_name" => HTML.strip_tags(user2.name || user2.nickname)
 645                  }
 646                ]
 647              }
 648     end
 649
 650     test "only local users" do
 651       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 652       user = insert(:user, nickname: "bob")
 653
 654       insert(:user, nickname: "bobb", local: false)
 655
 656       conn =
 657         build_conn()
 658         |> assign(:user, admin)
 659         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 660
 661       assert json_response(conn, 200) == %{
 662                "count" => 1,
 663                "page_size" => 50,
 664                "users" => [
 665                  %{
 666                    "deactivated" => user.info.deactivated,
 667                    "id" => user.id,
 668                    "nickname" => user.nickname,
 669                    "roles" => %{"admin" => false, "moderator" => false},
 670                    "local" => true,
 671                    "tags" => [],
 672                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 673                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 674                  }
 675                ]
 676              }
 677     end
 678
 679     test "only local users with no query", %{admin: old_admin} do
 680       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 681       user = insert(:user, nickname: "bob")
 682
 683       insert(:user, nickname: "bobb", local: false)
 684
 685       conn =
 686         build_conn()
 687         |> assign(:user, admin)
 688         |> get("/api/pleroma/admin/users?filters=local")
 689
 690       users =
 691         [
 692           %{
 693             "deactivated" => user.info.deactivated,
 694             "id" => user.id,
 695             "nickname" => user.nickname,
 696             "roles" => %{"admin" => false, "moderator" => false},
 697             "local" => true,
 698             "tags" => [],
 699             "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 700             "display_name" => HTML.strip_tags(user.name || user.nickname)
 701           },
 702           %{
 703             "deactivated" => admin.info.deactivated,
 704             "id" => admin.id,
 705             "nickname" => admin.nickname,
 706             "roles" => %{"admin" => true, "moderator" => false},
 707             "local" => true,
 708             "tags" => [],
 709             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 710             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 711           },
 712           %{
 713             "deactivated" => false,
 714             "id" => old_admin.id,
 715             "local" => true,
 716             "nickname" => old_admin.nickname,
 717             "roles" => %{"admin" => true, "moderator" => false},
 718             "tags" => [],
 719             "avatar" => User.avatar_url(old_admin) |> MediaProxy.url(),
 720             "display_name" => HTML.strip_tags(old_admin.name || old_admin.nickname)
 721           }
 722         ]
 723         |> Enum.sort_by(& &1["nickname"])
 724
 725       assert json_response(conn, 200) == %{
 726                "count" => 3,
 727                "page_size" => 50,
 728                "users" => users
 729              }
 730     end
 731
 732     test "load only admins", %{conn: conn, admin: admin} do
 733       second_admin = insert(:user, info: %{is_admin: true})
 734       insert(:user)
 735       insert(:user)
 736
 737       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 738
 739       users =
 740         [
 741           %{
 742             "deactivated" => false,
 743             "id" => admin.id,
 744             "nickname" => admin.nickname,
 745             "roles" => %{"admin" => true, "moderator" => false},
 746             "local" => admin.local,
 747             "tags" => [],
 748             "avatar" => User.avatar_url(admin) |> MediaProxy.url(),
 749             "display_name" => HTML.strip_tags(admin.name || admin.nickname)
 750           },
 751           %{
 752             "deactivated" => false,
 753             "id" => second_admin.id,
 754             "nickname" => second_admin.nickname,
 755             "roles" => %{"admin" => true, "moderator" => false},
 756             "local" => second_admin.local,
 757             "tags" => [],
 758             "avatar" => User.avatar_url(second_admin) |> MediaProxy.url(),
 759             "display_name" => HTML.strip_tags(second_admin.name || second_admin.nickname)
 760           }
 761         ]
 762         |> Enum.sort_by(& &1["nickname"])
 763
 764       assert json_response(conn, 200) == %{
 765                "count" => 2,
 766                "page_size" => 50,
 767                "users" => users
 768              }
 769     end
 770
 771     test "load only moderators", %{conn: conn} do
 772       moderator = insert(:user, info: %{is_moderator: true})
 773       insert(:user)
 774       insert(:user)
 775
 776       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
 777
 778       assert json_response(conn, 200) == %{
 779                "count" => 1,
 780                "page_size" => 50,
 781                "users" => [
 782                  %{
 783                    "deactivated" => false,
 784                    "id" => moderator.id,
 785                    "nickname" => moderator.nickname,
 786                    "roles" => %{"admin" => false, "moderator" => true},
 787                    "local" => moderator.local,
 788                    "tags" => [],
 789                    "avatar" => User.avatar_url(moderator) |> MediaProxy.url(),
 790                    "display_name" => HTML.strip_tags(moderator.name || moderator.nickname)
 791                  }
 792                ]
 793              }
 794     end
 795
 796     test "load users with tags list", %{conn: conn} do
 797       user1 = insert(:user, tags: ["first"])
 798       user2 = insert(:user, tags: ["second"])
 799       insert(:user)
 800       insert(:user)
 801
 802       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
 803
 804       users =
 805         [
 806           %{
 807             "deactivated" => false,
 808             "id" => user1.id,
 809             "nickname" => user1.nickname,
 810             "roles" => %{"admin" => false, "moderator" => false},
 811             "local" => user1.local,
 812             "tags" => ["first"],
 813             "avatar" => User.avatar_url(user1) |> MediaProxy.url(),
 814             "display_name" => HTML.strip_tags(user1.name || user1.nickname)
 815           },
 816           %{
 817             "deactivated" => false,
 818             "id" => user2.id,
 819             "nickname" => user2.nickname,
 820             "roles" => %{"admin" => false, "moderator" => false},
 821             "local" => user2.local,
 822             "tags" => ["second"],
 823             "avatar" => User.avatar_url(user2) |> MediaProxy.url(),
 824             "display_name" => HTML.strip_tags(user2.name || user2.nickname)
 825           }
 826         ]
 827         |> Enum.sort_by(& &1["nickname"])
 828
 829       assert json_response(conn, 200) == %{
 830                "count" => 2,
 831                "page_size" => 50,
 832                "users" => users
 833              }
 834     end
 835
 836     test "it works with multiple filters" do
 837       admin = insert(:user, nickname: "john", info: %{is_admin: true})
 838       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
 839
 840       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
 841       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
 842
 843       conn =
 844         build_conn()
 845         |> assign(:user, admin)
 846         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 847
 848       assert json_response(conn, 200) == %{
 849                "count" => 1,
 850                "page_size" => 50,
 851                "users" => [
 852                  %{
 853                    "deactivated" => user.info.deactivated,
 854                    "id" => user.id,
 855                    "nickname" => user.nickname,
 856                    "roles" => %{"admin" => false, "moderator" => false},
 857                    "local" => user.local,
 858                    "tags" => [],
 859                    "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 860                    "display_name" => HTML.strip_tags(user.name || user.nickname)
 861                  }
 862                ]
 863              }
 864     end
 865   end
 866
 867   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
 868     admin = insert(:user, info: %{is_admin: true})
 869     user = insert(:user)
 870
 871     conn =
 872       build_conn()
 873       |> assign(:user, admin)
 874       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 875
 876     assert json_response(conn, 200) ==
 877              %{
 878                "deactivated" => !user.info.deactivated,
 879                "id" => user.id,
 880                "nickname" => user.nickname,
 881                "roles" => %{"admin" => false, "moderator" => false},
 882                "local" => true,
 883                "tags" => [],
 884                "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 885                "display_name" => HTML.strip_tags(user.name || user.nickname)
 886              }
 887   end
 888
 889   describe "GET /api/pleroma/admin/users/invite_token" do
 890     setup do
 891       admin = insert(:user, info: %{is_admin: true})
 892
 893       conn =
 894         build_conn()
 895         |> assign(:user, admin)
 896
 897       {:ok, conn: conn}
 898     end
 899
 900     test "without options", %{conn: conn} do
 901       conn = get(conn, "/api/pleroma/admin/users/invite_token")
 902
 903       token = json_response(conn, 200)
 904       invite = UserInviteToken.find_by_token!(token)
 905       refute invite.used
 906       refute invite.expires_at
 907       refute invite.max_use
 908       assert invite.invite_type == "one_time"
 909     end
 910
 911     test "with expires_at", %{conn: conn} do
 912       conn =
 913         get(conn, "/api/pleroma/admin/users/invite_token", %{
 914           "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
 915         })
 916
 917       token = json_response(conn, 200)
 918       invite = UserInviteToken.find_by_token!(token)
 919
 920       refute invite.used
 921       assert invite.expires_at == Date.utc_today()
 922       refute invite.max_use
 923       assert invite.invite_type == "date_limited"
 924     end
 925
 926     test "with max_use", %{conn: conn} do
 927       conn =
 928         get(conn, "/api/pleroma/admin/users/invite_token", %{
 929           "invite" => %{"max_use" => 150}
 930         })
 931
 932       token = json_response(conn, 200)
 933       invite = UserInviteToken.find_by_token!(token)
 934       refute invite.used
 935       refute invite.expires_at
 936       assert invite.max_use == 150
 937       assert invite.invite_type == "reusable"
 938     end
 939
 940     test "with max use and expires_at", %{conn: conn} do
 941       conn =
 942         get(conn, "/api/pleroma/admin/users/invite_token", %{
 943           "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
 944         })
 945
 946       token = json_response(conn, 200)
 947       invite = UserInviteToken.find_by_token!(token)
 948       refute invite.used
 949       assert invite.expires_at == Date.utc_today()
 950       assert invite.max_use == 150
 951       assert invite.invite_type == "reusable_date_limited"
 952     end
 953   end
 954
 955   describe "GET /api/pleroma/admin/users/invites" do
 956     setup do
 957       admin = insert(:user, info: %{is_admin: true})
 958
 959       conn =
 960         build_conn()
 961         |> assign(:user, admin)
 962
 963       {:ok, conn: conn}
 964     end
 965
 966     test "no invites", %{conn: conn} do
 967       conn = get(conn, "/api/pleroma/admin/users/invites")
 968
 969       assert json_response(conn, 200) == %{"invites" => []}
 970     end
 971
 972     test "with invite", %{conn: conn} do
 973       {:ok, invite} = UserInviteToken.create_invite()
 974
 975       conn = get(conn, "/api/pleroma/admin/users/invites")
 976
 977       assert json_response(conn, 200) == %{
 978                "invites" => [
 979                  %{
 980                    "expires_at" => nil,
 981                    "id" => invite.id,
 982                    "invite_type" => "one_time",
 983                    "max_use" => nil,
 984                    "token" => invite.token,
 985                    "used" => false,
 986                    "uses" => 0
 987                  }
 988                ]
 989              }
 990     end
 991   end
 992
 993   describe "POST /api/pleroma/admin/users/revoke_invite" do
 994     test "with token" do
 995       admin = insert(:user, info: %{is_admin: true})
 996       {:ok, invite} = UserInviteToken.create_invite()
 997
 998       conn =
 999         build_conn()
1000         |> assign(:user, admin)
1001         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
1002
1003       assert json_response(conn, 200) == %{
1004                "expires_at" => nil,
1005                "id" => invite.id,
1006                "invite_type" => "one_time",
1007                "max_use" => nil,
1008                "token" => invite.token,
1009                "used" => true,
1010                "uses" => 0
1011              }
1012     end
1013   end
1014
1015   describe "GET /api/pleroma/admin/reports/:id" do
1016     setup %{conn: conn} do
1017       admin = insert(:user, info: %{is_admin: true})
1018
1019       %{conn: assign(conn, :user, admin)}
1020     end
1021
1022     test "returns report by its id", %{conn: conn} do
1023       [reporter, target_user] = insert_pair(:user)
1024       activity = insert(:note_activity, user: target_user)
1025
1026       {:ok, %{id: report_id}} =
1027         CommonAPI.report(reporter, %{
1028           "account_id" => target_user.id,
1029           "comment" => "I feel offended",
1030           "status_ids" => [activity.id]
1031         })
1032
1033       response =
1034         conn
1035         |> get("/api/pleroma/admin/reports/#{report_id}")
1036         |> json_response(:ok)
1037
1038       assert response["id"] == report_id
1039     end
1040
1041     test "returns 404 when report id is invalid", %{conn: conn} do
1042       conn = get(conn, "/api/pleroma/admin/reports/test")
1043
1044       assert json_response(conn, :not_found) == "Not found"
1045     end
1046   end
1047
1048   describe "PUT /api/pleroma/admin/reports/:id" do
1049     setup %{conn: conn} do
1050       admin = insert(:user, info: %{is_admin: true})
1051       [reporter, target_user] = insert_pair(:user)
1052       activity = insert(:note_activity, user: target_user)
1053
1054       {:ok, %{id: report_id}} =
1055         CommonAPI.report(reporter, %{
1056           "account_id" => target_user.id,
1057           "comment" => "I feel offended",
1058           "status_ids" => [activity.id]
1059         })
1060
1061       %{conn: assign(conn, :user, admin), id: report_id}
1062     end
1063
1064     test "mark report as resolved", %{conn: conn, id: id} do
1065       response =
1066         conn
1067         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1068         |> json_response(:ok)
1069
1070       assert response["state"] == "resolved"
1071     end
1072
1073     test "closes report", %{conn: conn, id: id} do
1074       response =
1075         conn
1076         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1077         |> json_response(:ok)
1078
1079       assert response["state"] == "closed"
1080     end
1081
1082     test "returns 400 when state is unknown", %{conn: conn, id: id} do
1083       conn =
1084         conn
1085         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1086
1087       assert json_response(conn, :bad_request) == "Unsupported state"
1088     end
1089
1090     test "returns 404 when report is not exist", %{conn: conn} do
1091       conn =
1092         conn
1093         |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1094
1095       assert json_response(conn, :not_found) == "Not found"
1096     end
1097   end
1098
1099   describe "GET /api/pleroma/admin/reports" do
1100     setup %{conn: conn} do
1101       admin = insert(:user, info: %{is_admin: true})
1102
1103       %{conn: assign(conn, :user, admin)}
1104     end
1105
1106     test "returns empty response when no reports created", %{conn: conn} do
1107       response =
1108         conn
1109         |> get("/api/pleroma/admin/reports")
1110         |> json_response(:ok)
1111
1112       assert Enum.empty?(response["reports"])
1113     end
1114
1115     test "returns reports", %{conn: conn} do
1116       [reporter, target_user] = insert_pair(:user)
1117       activity = insert(:note_activity, user: target_user)
1118
1119       {:ok, %{id: report_id}} =
1120         CommonAPI.report(reporter, %{
1121           "account_id" => target_user.id,
1122           "comment" => "I feel offended",
1123           "status_ids" => [activity.id]
1124         })
1125
1126       response =
1127         conn
1128         |> get("/api/pleroma/admin/reports")
1129         |> json_response(:ok)
1130
1131       [report] = response["reports"]
1132
1133       assert length(response["reports"]) == 1
1134       assert report["id"] == report_id
1135     end
1136
1137     test "returns reports with specified state", %{conn: conn} do
1138       [reporter, target_user] = insert_pair(:user)
1139       activity = insert(:note_activity, user: target_user)
1140
1141       {:ok, %{id: first_report_id}} =
1142         CommonAPI.report(reporter, %{
1143           "account_id" => target_user.id,
1144           "comment" => "I feel offended",
1145           "status_ids" => [activity.id]
1146         })
1147
1148       {:ok, %{id: second_report_id}} =
1149         CommonAPI.report(reporter, %{
1150           "account_id" => target_user.id,
1151           "comment" => "I don't like this user"
1152         })
1153
1154       CommonAPI.update_report_state(second_report_id, "closed")
1155
1156       response =
1157         conn
1158         |> get("/api/pleroma/admin/reports", %{
1159           "state" => "open"
1160         })
1161         |> json_response(:ok)
1162
1163       [open_report] = response["reports"]
1164
1165       assert length(response["reports"]) == 1
1166       assert open_report["id"] == first_report_id
1167
1168       response =
1169         conn
1170         |> get("/api/pleroma/admin/reports", %{
1171           "state" => "closed"
1172         })
1173         |> json_response(:ok)
1174
1175       [closed_report] = response["reports"]
1176
1177       assert length(response["reports"]) == 1
1178       assert closed_report["id"] == second_report_id
1179
1180       response =
1181         conn
1182         |> get("/api/pleroma/admin/reports", %{
1183           "state" => "resolved"
1184         })
1185         |> json_response(:ok)
1186
1187       assert Enum.empty?(response["reports"])
1188     end
1189
1190     test "returns 403 when requested by a non-admin" do
1191       user = insert(:user)
1192
1193       conn =
1194         build_conn()
1195         |> assign(:user, user)
1196         |> get("/api/pleroma/admin/reports")
1197
1198       assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1199     end
1200
1201     test "returns 403 when requested by anonymous" do
1202       conn =
1203         build_conn()
1204         |> get("/api/pleroma/admin/reports")
1205
1206       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1207     end
1208   end
1209
1210   describe "POST /api/pleroma/admin/reports/:id/respond" do
1211     setup %{conn: conn} do
1212       admin = insert(:user, info: %{is_admin: true})
1213
1214       %{conn: assign(conn, :user, admin)}
1215     end
1216
1217     test "returns created dm", %{conn: conn} do
1218       [reporter, target_user] = insert_pair(:user)
1219       activity = insert(:note_activity, user: target_user)
1220
1221       {:ok, %{id: report_id}} =
1222         CommonAPI.report(reporter, %{
1223           "account_id" => target_user.id,
1224           "comment" => "I feel offended",
1225           "status_ids" => [activity.id]
1226         })
1227
1228       response =
1229         conn
1230         |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1231           "status" => "I will check it out"
1232         })
1233         |> json_response(:ok)
1234
1235       recipients = Enum.map(response["mentions"], & &1["username"])
1236
1237       assert conn.assigns[:user].nickname in recipients
1238       assert reporter.nickname in recipients
1239       assert response["content"] == "I will check it out"
1240       assert response["visibility"] == "direct"
1241     end
1242
1243     test "returns 400 when status is missing", %{conn: conn} do
1244       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1245
1246       assert json_response(conn, :bad_request) == "Invalid parameters"
1247     end
1248
1249     test "returns 404 when report id is invalid", %{conn: conn} do
1250       conn =
1251         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1252           "status" => "foo"
1253         })
1254
1255       assert json_response(conn, :not_found) == "Not found"
1256     end
1257   end
1258
1259   describe "PUT /api/pleroma/admin/statuses/:id" do
1260     setup %{conn: conn} do
1261       admin = insert(:user, info: %{is_admin: true})
1262       activity = insert(:note_activity)
1263
1264       %{conn: assign(conn, :user, admin), id: activity.id}
1265     end
1266
1267     test "toggle sensitive flag", %{conn: conn, id: id} do
1268       response =
1269         conn
1270         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1271         |> json_response(:ok)
1272
1273       assert response["sensitive"]
1274
1275       response =
1276         conn
1277         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1278         |> json_response(:ok)
1279
1280       refute response["sensitive"]
1281     end
1282
1283     test "change visibility flag", %{conn: conn, id: id} do
1284       response =
1285         conn
1286         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1287         |> json_response(:ok)
1288
1289       assert response["visibility"] == "public"
1290
1291       response =
1292         conn
1293         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1294         |> json_response(:ok)
1295
1296       assert response["visibility"] == "private"
1297
1298       response =
1299         conn
1300         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1301         |> json_response(:ok)
1302
1303       assert response["visibility"] == "unlisted"
1304     end
1305
1306     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1307       conn =
1308         conn
1309         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1310
1311       assert json_response(conn, :bad_request) == "Unsupported visibility"
1312     end
1313   end
1314
1315   describe "DELETE /api/pleroma/admin/statuses/:id" do
1316     setup %{conn: conn} do
1317       admin = insert(:user, info: %{is_admin: true})
1318       activity = insert(:note_activity)
1319
1320       %{conn: assign(conn, :user, admin), id: activity.id}
1321     end
1322
1323     test "deletes status", %{conn: conn, id: id} do
1324       conn
1325       |> delete("/api/pleroma/admin/statuses/#{id}")
1326       |> json_response(:ok)
1327
1328       refute Activity.get_by_id(id)
1329     end
1330
1331     test "returns error when status is not exist", %{conn: conn} do
1332       conn =
1333         conn
1334         |> delete("/api/pleroma/admin/statuses/test")
1335
1336       assert json_response(conn, :bad_request) == "Could not delete"
1337     end
1338   end
1339
1340   describe "GET /api/pleroma/admin/config" do
1341     setup %{conn: conn} do
1342       admin = insert(:user, info: %{is_admin: true})
1343
1344       %{conn: assign(conn, :user, admin)}
1345     end
1346
1347     test "without any settings in db", %{conn: conn} do
1348       conn = get(conn, "/api/pleroma/admin/config")
1349
1350       assert json_response(conn, 200) == %{"configs" => []}
1351     end
1352
1353     test "with settings in db", %{conn: conn} do
1354       config1 = insert(:config)
1355       config2 = insert(:config)
1356
1357       conn = get(conn, "/api/pleroma/admin/config")
1358
1359       %{
1360         "configs" => [
1361           %{
1362             "key" => key1,
1363             "value" => _
1364           },
1365           %{
1366             "key" => key2,
1367             "value" => _
1368           }
1369         ]
1370       } = json_response(conn, 200)
1371
1372       assert key1 == config1.key
1373       assert key2 == config2.key
1374     end
1375   end
1376
1377   describe "POST /api/pleroma/admin/config" do
1378     setup %{conn: conn} do
1379       admin = insert(:user, info: %{is_admin: true})
1380
1381       temp_file = "config/test.exported_from_db.secret.exs"
1382
1383       on_exit(fn ->
1384         Application.delete_env(:pleroma, :key1)
1385         Application.delete_env(:pleroma, :key2)
1386         Application.delete_env(:pleroma, :key3)
1387         Application.delete_env(:pleroma, :key4)
1388         Application.delete_env(:pleroma, :keyaa1)
1389         Application.delete_env(:pleroma, :keyaa2)
1390         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1391         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1392         :ok = File.rm(temp_file)
1393       end)
1394
1395       dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
1396
1397       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1398
1399       on_exit(fn ->
1400         Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
1401       end)
1402
1403       %{conn: assign(conn, :user, admin)}
1404     end
1405
1406     test "create new config setting in db", %{conn: conn} do
1407       conn =
1408         post(conn, "/api/pleroma/admin/config", %{
1409           configs: [
1410             %{group: "pleroma", key: "key1", value: "value1"},
1411             %{
1412               group: "pleroma",
1413               key: "key2",
1414               value: %{
1415                 "nested_1" => "nested_value1",
1416                 "nested_2" => [
1417                   %{"nested_22" => "nested_value222"},
1418                   %{"nested_33" => %{"nested_44" => "nested_444"}}
1419                 ]
1420               }
1421             },
1422             %{
1423               group: "pleroma",
1424               key: "key3",
1425               value: [
1426                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1427                 %{"nested_4" => ":true"}
1428               ]
1429             },
1430             %{
1431               group: "pleroma",
1432               key: "key4",
1433               value: %{"nested_5" => ":upload", "endpoint" => "https://example.com"}
1434             },
1435             %{
1436               group: "idna",
1437               key: "key5",
1438               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1439             }
1440           ]
1441         })
1442
1443       assert json_response(conn, 200) == %{
1444                "configs" => [
1445                  %{
1446                    "group" => "pleroma",
1447                    "key" => "key1",
1448                    "value" => "value1"
1449                  },
1450                  %{
1451                    "group" => "pleroma",
1452                    "key" => "key2",
1453                    "value" => [
1454                      %{"nested_1" => "nested_value1"},
1455                      %{
1456                        "nested_2" => [
1457                          %{"nested_22" => "nested_value222"},
1458                          %{"nested_33" => %{"nested_44" => "nested_444"}}
1459                        ]
1460                      }
1461                    ]
1462                  },
1463                  %{
1464                    "group" => "pleroma",
1465                    "key" => "key3",
1466                    "value" => [
1467                      [%{"nested_3" => "nested_3"}, %{"nested_33" => "nested_33"}],
1468                      %{"nested_4" => true}
1469                    ]
1470                  },
1471                  %{
1472                    "group" => "pleroma",
1473                    "key" => "key4",
1474                    "value" => [%{"endpoint" => "https://example.com"}, %{"nested_5" => "upload"}]
1475                  },
1476                  %{
1477                    "group" => "idna",
1478                    "key" => "key5",
1479                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1480                  }
1481                ]
1482              }
1483
1484       assert Application.get_env(:pleroma, :key1) == "value1"
1485
1486       assert Application.get_env(:pleroma, :key2) == [
1487                nested_1: "nested_value1",
1488                nested_2: [
1489                  [nested_22: "nested_value222"],
1490                  [nested_33: [nested_44: "nested_444"]]
1491                ]
1492              ]
1493
1494       assert Application.get_env(:pleroma, :key3) == [
1495                [nested_3: :nested_3, nested_33: "nested_33"],
1496                [nested_4: true]
1497              ]
1498
1499       assert Application.get_env(:pleroma, :key4) == [
1500                endpoint: "https://example.com",
1501                nested_5: :upload
1502              ]
1503
1504       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1505     end
1506
1507     test "update config setting & delete", %{conn: conn} do
1508       config1 = insert(:config, key: "keyaa1")
1509       config2 = insert(:config, key: "keyaa2")
1510
1511       conn =
1512         post(conn, "/api/pleroma/admin/config", %{
1513           configs: [
1514             %{group: config1.group, key: config1.key, value: "another_value"},
1515             %{group: config2.group, key: config2.key, delete: "true"}
1516           ]
1517         })
1518
1519       assert json_response(conn, 200) == %{
1520                "configs" => [
1521                  %{
1522                    "group" => "pleroma",
1523                    "key" => config1.key,
1524                    "value" => "another_value"
1525                  }
1526                ]
1527              }
1528
1529       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1530       refute Application.get_env(:pleroma, :keyaa2)
1531     end
1532
1533     test "common config example", %{conn: conn} do
1534       conn =
1535         post(conn, "/api/pleroma/admin/config", %{
1536           configs: [
1537             %{
1538               "group" => "pleroma",
1539               "key" => "Pleroma.Captcha.NotReal",
1540               "value" => %{
1541                 "enabled" => ":false",
1542                 "method" => "Pleroma.Captcha.Kocaptcha",
1543                 "seconds_valid" => "i:60"
1544               }
1545             }
1546           ]
1547         })
1548
1549       assert json_response(conn, 200) == %{
1550                "configs" => [
1551                  %{
1552                    "group" => "pleroma",
1553                    "key" => "Pleroma.Captcha.NotReal",
1554                    "value" => [
1555                      %{"enabled" => false},
1556                      %{"method" => "Pleroma.Captcha.Kocaptcha"},
1557                      %{"seconds_valid" => 60}
1558                    ]
1559                  }
1560                ]
1561              }
1562     end
1563
1564     test "tuples with more than two values", %{conn: conn} do
1565       conn =
1566         post(conn, "/api/pleroma/admin/config", %{
1567           configs: [
1568             %{
1569               "group" => "pleroma",
1570               "key" => "Pleroma.Web.Endpoint.NotReal",
1571               "value" => [
1572                 %{
1573                   "http" => %{
1574                     "dispatch" => [
1575                       %{
1576                         "tuple" => [
1577                           ":_",
1578                           [
1579                             %{
1580                               "tuple" => [
1581                                 "/api/v1/streaming",
1582                                 "Pleroma.Web.MastodonAPI.WebsocketHandler",
1583                                 []
1584                               ]
1585                             },
1586                             %{
1587                               "tuple" => [
1588                                 "/websocket",
1589                                 "Phoenix.Endpoint.CowboyWebSocket",
1590                                 %{
1591                                   "tuple" => [
1592                                     "Phoenix.Transports.WebSocket",
1593                                     %{
1594                                       "tuple" => [
1595                                         "Pleroma.Web.Endpoint",
1596                                         "Pleroma.Web.UserSocket",
1597                                         []
1598                                       ]
1599                                     }
1600                                   ]
1601                                 }
1602                               ]
1603                             },
1604                             %{
1605                               "tuple" => [
1606                                 ":_",
1607                                 "Phoenix.Endpoint.Cowboy2Handler",
1608                                 %{
1609                                   "tuple" => ["Pleroma.Web.Endpoint", []]
1610                                 }
1611                               ]
1612                             }
1613                           ]
1614                         ]
1615                       }
1616                     ]
1617                   }
1618                 }
1619               ]
1620             }
1621           ]
1622         })
1623
1624       assert json_response(conn, 200) == %{
1625                "configs" => [
1626                  %{
1627                    "group" => "pleroma",
1628                    "key" => "Pleroma.Web.Endpoint.NotReal",
1629                    "value" => [
1630                      %{
1631                        "http" => %{
1632                          "dispatch" => %{
1633                            "_" => [
1634                              %{
1635                                "tuple" => [
1636                                  "/api/v1/streaming",
1637                                  "Pleroma.Web.MastodonAPI.WebsocketHandler",
1638                                  []
1639                                ]
1640                              },
1641                              %{
1642                                "tuple" => [
1643                                  "/websocket",
1644                                  "Phoenix.Endpoint.CowboyWebSocket",
1645                                  %{
1646                                    "Elixir.Phoenix.Transports.WebSocket" => %{
1647                                      "tuple" => [
1648                                        "Pleroma.Web.Endpoint",
1649                                        "Pleroma.Web.UserSocket",
1650                                        []
1651                                      ]
1652                                    }
1653                                  }
1654                                ]
1655                              },
1656                              %{
1657                                "tuple" => [
1658                                  "_",
1659                                  "Phoenix.Endpoint.Cowboy2Handler",
1660                                  %{"Elixir.Pleroma.Web.Endpoint" => []}
1661                                ]
1662                              }
1663                            ]
1664                          }
1665                        }
1666                      }
1667                    ]
1668                  }
1669                ]
1670              }
1671     end
1672   end
1673 end
1674
1675 # Needed for testing
1676 defmodule Pleroma.Web.Endpoint.NotReal do
1677 end
1678
1679 defmodule Pleroma.Captcha.NotReal do
1680 end