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
1014     test "with invalid token" do
1015       admin = insert(:user, info: %{is_admin: true})
1016
1017       conn =
1018         build_conn()
1019         |> assign(:user, admin)
1020         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => "foo"})
1021
1022       assert json_response(conn, :not_found) == "Not found"
1023     end
1024   end
1025
1026   describe "GET /api/pleroma/admin/reports/:id" do
1027     setup %{conn: conn} do
1028       admin = insert(:user, info: %{is_admin: true})
1029
1030       %{conn: assign(conn, :user, admin)}
1031     end
1032
1033     test "returns report by its id", %{conn: conn} do
1034       [reporter, target_user] = insert_pair(:user)
1035       activity = insert(:note_activity, user: target_user)
1036
1037       {:ok, %{id: report_id}} =
1038         CommonAPI.report(reporter, %{
1039           "account_id" => target_user.id,
1040           "comment" => "I feel offended",
1041           "status_ids" => [activity.id]
1042         })
1043
1044       response =
1045         conn
1046         |> get("/api/pleroma/admin/reports/#{report_id}")
1047         |> json_response(:ok)
1048
1049       assert response["id"] == report_id
1050     end
1051
1052     test "returns 404 when report id is invalid", %{conn: conn} do
1053       conn = get(conn, "/api/pleroma/admin/reports/test")
1054
1055       assert json_response(conn, :not_found) == "Not found"
1056     end
1057   end
1058
1059   describe "PUT /api/pleroma/admin/reports/:id" do
1060     setup %{conn: conn} do
1061       admin = insert(:user, info: %{is_admin: true})
1062       [reporter, target_user] = insert_pair(:user)
1063       activity = insert(:note_activity, user: target_user)
1064
1065       {:ok, %{id: report_id}} =
1066         CommonAPI.report(reporter, %{
1067           "account_id" => target_user.id,
1068           "comment" => "I feel offended",
1069           "status_ids" => [activity.id]
1070         })
1071
1072       %{conn: assign(conn, :user, admin), id: report_id}
1073     end
1074
1075     test "mark report as resolved", %{conn: conn, id: id} do
1076       response =
1077         conn
1078         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1079         |> json_response(:ok)
1080
1081       assert response["state"] == "resolved"
1082     end
1083
1084     test "closes report", %{conn: conn, id: id} do
1085       response =
1086         conn
1087         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1088         |> json_response(:ok)
1089
1090       assert response["state"] == "closed"
1091     end
1092
1093     test "returns 400 when state is unknown", %{conn: conn, id: id} do
1094       conn =
1095         conn
1096         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1097
1098       assert json_response(conn, :bad_request) == "Unsupported state"
1099     end
1100
1101     test "returns 404 when report is not exist", %{conn: conn} do
1102       conn =
1103         conn
1104         |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1105
1106       assert json_response(conn, :not_found) == "Not found"
1107     end
1108   end
1109
1110   describe "GET /api/pleroma/admin/reports" do
1111     setup %{conn: conn} do
1112       admin = insert(:user, info: %{is_admin: true})
1113
1114       %{conn: assign(conn, :user, admin)}
1115     end
1116
1117     test "returns empty response when no reports created", %{conn: conn} do
1118       response =
1119         conn
1120         |> get("/api/pleroma/admin/reports")
1121         |> json_response(:ok)
1122
1123       assert Enum.empty?(response["reports"])
1124     end
1125
1126     test "returns reports", %{conn: conn} do
1127       [reporter, target_user] = insert_pair(:user)
1128       activity = insert(:note_activity, user: target_user)
1129
1130       {:ok, %{id: report_id}} =
1131         CommonAPI.report(reporter, %{
1132           "account_id" => target_user.id,
1133           "comment" => "I feel offended",
1134           "status_ids" => [activity.id]
1135         })
1136
1137       response =
1138         conn
1139         |> get("/api/pleroma/admin/reports")
1140         |> json_response(:ok)
1141
1142       [report] = response["reports"]
1143
1144       assert length(response["reports"]) == 1
1145       assert report["id"] == report_id
1146     end
1147
1148     test "returns reports with specified state", %{conn: conn} do
1149       [reporter, target_user] = insert_pair(:user)
1150       activity = insert(:note_activity, user: target_user)
1151
1152       {:ok, %{id: first_report_id}} =
1153         CommonAPI.report(reporter, %{
1154           "account_id" => target_user.id,
1155           "comment" => "I feel offended",
1156           "status_ids" => [activity.id]
1157         })
1158
1159       {:ok, %{id: second_report_id}} =
1160         CommonAPI.report(reporter, %{
1161           "account_id" => target_user.id,
1162           "comment" => "I don't like this user"
1163         })
1164
1165       CommonAPI.update_report_state(second_report_id, "closed")
1166
1167       response =
1168         conn
1169         |> get("/api/pleroma/admin/reports", %{
1170           "state" => "open"
1171         })
1172         |> json_response(:ok)
1173
1174       [open_report] = response["reports"]
1175
1176       assert length(response["reports"]) == 1
1177       assert open_report["id"] == first_report_id
1178
1179       response =
1180         conn
1181         |> get("/api/pleroma/admin/reports", %{
1182           "state" => "closed"
1183         })
1184         |> json_response(:ok)
1185
1186       [closed_report] = response["reports"]
1187
1188       assert length(response["reports"]) == 1
1189       assert closed_report["id"] == second_report_id
1190
1191       response =
1192         conn
1193         |> get("/api/pleroma/admin/reports", %{
1194           "state" => "resolved"
1195         })
1196         |> json_response(:ok)
1197
1198       assert Enum.empty?(response["reports"])
1199     end
1200
1201     test "returns 403 when requested by a non-admin" do
1202       user = insert(:user)
1203
1204       conn =
1205         build_conn()
1206         |> assign(:user, user)
1207         |> get("/api/pleroma/admin/reports")
1208
1209       assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1210     end
1211
1212     test "returns 403 when requested by anonymous" do
1213       conn =
1214         build_conn()
1215         |> get("/api/pleroma/admin/reports")
1216
1217       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1218     end
1219   end
1220
1221   describe "POST /api/pleroma/admin/reports/:id/respond" do
1222     setup %{conn: conn} do
1223       admin = insert(:user, info: %{is_admin: true})
1224
1225       %{conn: assign(conn, :user, admin)}
1226     end
1227
1228     test "returns created dm", %{conn: conn} do
1229       [reporter, target_user] = insert_pair(:user)
1230       activity = insert(:note_activity, user: target_user)
1231
1232       {:ok, %{id: report_id}} =
1233         CommonAPI.report(reporter, %{
1234           "account_id" => target_user.id,
1235           "comment" => "I feel offended",
1236           "status_ids" => [activity.id]
1237         })
1238
1239       response =
1240         conn
1241         |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1242           "status" => "I will check it out"
1243         })
1244         |> json_response(:ok)
1245
1246       recipients = Enum.map(response["mentions"], & &1["username"])
1247
1248       assert reporter.nickname in recipients
1249       assert response["content"] == "I will check it out"
1250       assert response["visibility"] == "direct"
1251     end
1252
1253     test "returns 400 when status is missing", %{conn: conn} do
1254       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1255
1256       assert json_response(conn, :bad_request) == "Invalid parameters"
1257     end
1258
1259     test "returns 404 when report id is invalid", %{conn: conn} do
1260       conn =
1261         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1262           "status" => "foo"
1263         })
1264
1265       assert json_response(conn, :not_found) == "Not found"
1266     end
1267   end
1268
1269   describe "PUT /api/pleroma/admin/statuses/:id" do
1270     setup %{conn: conn} do
1271       admin = insert(:user, info: %{is_admin: true})
1272       activity = insert(:note_activity)
1273
1274       %{conn: assign(conn, :user, admin), id: activity.id}
1275     end
1276
1277     test "toggle sensitive flag", %{conn: conn, id: id} do
1278       response =
1279         conn
1280         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1281         |> json_response(:ok)
1282
1283       assert response["sensitive"]
1284
1285       response =
1286         conn
1287         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1288         |> json_response(:ok)
1289
1290       refute response["sensitive"]
1291     end
1292
1293     test "change visibility flag", %{conn: conn, id: id} do
1294       response =
1295         conn
1296         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1297         |> json_response(:ok)
1298
1299       assert response["visibility"] == "public"
1300
1301       response =
1302         conn
1303         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1304         |> json_response(:ok)
1305
1306       assert response["visibility"] == "private"
1307
1308       response =
1309         conn
1310         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1311         |> json_response(:ok)
1312
1313       assert response["visibility"] == "unlisted"
1314     end
1315
1316     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1317       conn =
1318         conn
1319         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1320
1321       assert json_response(conn, :bad_request) == "Unsupported visibility"
1322     end
1323   end
1324
1325   describe "DELETE /api/pleroma/admin/statuses/:id" do
1326     setup %{conn: conn} do
1327       admin = insert(:user, info: %{is_admin: true})
1328       activity = insert(:note_activity)
1329
1330       %{conn: assign(conn, :user, admin), id: activity.id}
1331     end
1332
1333     test "deletes status", %{conn: conn, id: id} do
1334       conn
1335       |> delete("/api/pleroma/admin/statuses/#{id}")
1336       |> json_response(:ok)
1337
1338       refute Activity.get_by_id(id)
1339     end
1340
1341     test "returns error when status is not exist", %{conn: conn} do
1342       conn =
1343         conn
1344         |> delete("/api/pleroma/admin/statuses/test")
1345
1346       assert json_response(conn, :bad_request) == "Could not delete"
1347     end
1348   end
1349
1350   describe "GET /api/pleroma/admin/config" do
1351     setup %{conn: conn} do
1352       admin = insert(:user, info: %{is_admin: true})
1353
1354       %{conn: assign(conn, :user, admin)}
1355     end
1356
1357     test "without any settings in db", %{conn: conn} do
1358       conn = get(conn, "/api/pleroma/admin/config")
1359
1360       assert json_response(conn, 200) == %{"configs" => []}
1361     end
1362
1363     test "with settings in db", %{conn: conn} do
1364       config1 = insert(:config)
1365       config2 = insert(:config)
1366
1367       conn = get(conn, "/api/pleroma/admin/config")
1368
1369       %{
1370         "configs" => [
1371           %{
1372             "key" => key1,
1373             "value" => _
1374           },
1375           %{
1376             "key" => key2,
1377             "value" => _
1378           }
1379         ]
1380       } = json_response(conn, 200)
1381
1382       assert key1 == config1.key
1383       assert key2 == config2.key
1384     end
1385   end
1386
1387   describe "POST /api/pleroma/admin/config" do
1388     setup %{conn: conn} do
1389       admin = insert(:user, info: %{is_admin: true})
1390
1391       temp_file = "config/test.exported_from_db.secret.exs"
1392
1393       on_exit(fn ->
1394         Application.delete_env(:pleroma, :key1)
1395         Application.delete_env(:pleroma, :key2)
1396         Application.delete_env(:pleroma, :key3)
1397         Application.delete_env(:pleroma, :key4)
1398         Application.delete_env(:pleroma, :keyaa1)
1399         Application.delete_env(:pleroma, :keyaa2)
1400         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1401         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1402         :ok = File.rm(temp_file)
1403       end)
1404
1405       dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
1406
1407       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1408
1409       on_exit(fn ->
1410         Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
1411       end)
1412
1413       %{conn: assign(conn, :user, admin)}
1414     end
1415
1416     test "create new config setting in db", %{conn: conn} do
1417       conn =
1418         post(conn, "/api/pleroma/admin/config", %{
1419           configs: [
1420             %{group: "pleroma", key: "key1", value: "value1"},
1421             %{
1422               group: "ueberauth",
1423               key: "Ueberauth.Strategy.Twitter.OAuth",
1424               value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
1425             },
1426             %{
1427               group: "pleroma",
1428               key: "key2",
1429               value: %{
1430                 ":nested_1" => "nested_value1",
1431                 ":nested_2" => [
1432                   %{":nested_22" => "nested_value222"},
1433                   %{":nested_33" => %{":nested_44" => "nested_444"}}
1434                 ]
1435               }
1436             },
1437             %{
1438               group: "pleroma",
1439               key: "key3",
1440               value: [
1441                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1442                 %{"nested_4" => true}
1443               ]
1444             },
1445             %{
1446               group: "pleroma",
1447               key: "key4",
1448               value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
1449             },
1450             %{
1451               group: "idna",
1452               key: "key5",
1453               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1454             }
1455           ]
1456         })
1457
1458       assert json_response(conn, 200) == %{
1459                "configs" => [
1460                  %{
1461                    "group" => "pleroma",
1462                    "key" => "key1",
1463                    "value" => "value1"
1464                  },
1465                  %{
1466                    "group" => "ueberauth",
1467                    "key" => "Ueberauth.Strategy.Twitter.OAuth",
1468                    "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
1469                  },
1470                  %{
1471                    "group" => "pleroma",
1472                    "key" => "key2",
1473                    "value" => %{
1474                      ":nested_1" => "nested_value1",
1475                      ":nested_2" => [
1476                        %{":nested_22" => "nested_value222"},
1477                        %{":nested_33" => %{":nested_44" => "nested_444"}}
1478                      ]
1479                    }
1480                  },
1481                  %{
1482                    "group" => "pleroma",
1483                    "key" => "key3",
1484                    "value" => [
1485                      %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1486                      %{"nested_4" => true}
1487                    ]
1488                  },
1489                  %{
1490                    "group" => "pleroma",
1491                    "key" => "key4",
1492                    "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
1493                  },
1494                  %{
1495                    "group" => "idna",
1496                    "key" => "key5",
1497                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1498                  }
1499                ]
1500              }
1501
1502       assert Application.get_env(:pleroma, :key1) == "value1"
1503
1504       assert Application.get_env(:pleroma, :key2) == %{
1505                nested_1: "nested_value1",
1506                nested_2: [
1507                  %{nested_22: "nested_value222"},
1508                  %{nested_33: %{nested_44: "nested_444"}}
1509                ]
1510              }
1511
1512       assert Application.get_env(:pleroma, :key3) == [
1513                %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
1514                %{"nested_4" => true}
1515              ]
1516
1517       assert Application.get_env(:pleroma, :key4) == %{
1518                "endpoint" => "https://example.com",
1519                nested_5: :upload
1520              }
1521
1522       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1523     end
1524
1525     test "update config setting & delete", %{conn: conn} do
1526       config1 = insert(:config, key: "keyaa1")
1527       config2 = insert(:config, key: "keyaa2")
1528
1529       insert(:config,
1530         group: "ueberauth",
1531         key: "Ueberauth.Strategy.Microsoft.OAuth",
1532         value: :erlang.term_to_binary([])
1533       )
1534
1535       conn =
1536         post(conn, "/api/pleroma/admin/config", %{
1537           configs: [
1538             %{group: config1.group, key: config1.key, value: "another_value"},
1539             %{group: config2.group, key: config2.key, delete: "true"},
1540             %{
1541               group: "ueberauth",
1542               key: "Ueberauth.Strategy.Microsoft.OAuth",
1543               delete: "true"
1544             }
1545           ]
1546         })
1547
1548       assert json_response(conn, 200) == %{
1549                "configs" => [
1550                  %{
1551                    "group" => "pleroma",
1552                    "key" => config1.key,
1553                    "value" => "another_value"
1554                  }
1555                ]
1556              }
1557
1558       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1559       refute Application.get_env(:pleroma, :keyaa2)
1560     end
1561
1562     test "common config example", %{conn: conn} do
1563       conn =
1564         post(conn, "/api/pleroma/admin/config", %{
1565           configs: [
1566             %{
1567               "group" => "pleroma",
1568               "key" => "Pleroma.Captcha.NotReal",
1569               "value" => [
1570                 %{"tuple" => [":enabled", false]},
1571                 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1572                 %{"tuple" => [":seconds_valid", 60]},
1573                 %{"tuple" => [":path", ""]},
1574                 %{"tuple" => [":key1", nil]},
1575                 %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
1576               ]
1577             }
1578           ]
1579         })
1580
1581       assert json_response(conn, 200) == %{
1582                "configs" => [
1583                  %{
1584                    "group" => "pleroma",
1585                    "key" => "Pleroma.Captcha.NotReal",
1586                    "value" => [
1587                      %{"tuple" => [":enabled", false]},
1588                      %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1589                      %{"tuple" => [":seconds_valid", 60]},
1590                      %{"tuple" => [":path", ""]},
1591                      %{"tuple" => [":key1", nil]},
1592                      %{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
1593                    ]
1594                  }
1595                ]
1596              }
1597     end
1598
1599     test "tuples with more than two values", %{conn: conn} do
1600       conn =
1601         post(conn, "/api/pleroma/admin/config", %{
1602           configs: [
1603             %{
1604               "group" => "pleroma",
1605               "key" => "Pleroma.Web.Endpoint.NotReal",
1606               "value" => [
1607                 %{
1608                   "tuple" => [
1609                     ":http",
1610                     [
1611                       %{
1612                         "tuple" => [
1613                           ":key2",
1614                           [
1615                             %{
1616                               "tuple" => [
1617                                 ":_",
1618                                 [
1619                                   %{
1620                                     "tuple" => [
1621                                       "/api/v1/streaming",
1622                                       "Pleroma.Web.MastodonAPI.WebsocketHandler",
1623                                       []
1624                                     ]
1625                                   },
1626                                   %{
1627                                     "tuple" => [
1628                                       "/websocket",
1629                                       "Phoenix.Endpoint.CowboyWebSocket",
1630                                       %{
1631                                         "tuple" => [
1632                                           "Phoenix.Transports.WebSocket",
1633                                           %{
1634                                             "tuple" => [
1635                                               "Pleroma.Web.Endpoint",
1636                                               "Pleroma.Web.UserSocket",
1637                                               []
1638                                             ]
1639                                           }
1640                                         ]
1641                                       }
1642                                     ]
1643                                   },
1644                                   %{
1645                                     "tuple" => [
1646                                       ":_",
1647                                       "Phoenix.Endpoint.Cowboy2Handler",
1648                                       %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1649                                     ]
1650                                   }
1651                                 ]
1652                               ]
1653                             }
1654                           ]
1655                         ]
1656                       }
1657                     ]
1658                   ]
1659                 }
1660               ]
1661             }
1662           ]
1663         })
1664
1665       assert json_response(conn, 200) == %{
1666                "configs" => [
1667                  %{
1668                    "group" => "pleroma",
1669                    "key" => "Pleroma.Web.Endpoint.NotReal",
1670                    "value" => [
1671                      %{
1672                        "tuple" => [
1673                          ":http",
1674                          [
1675                            %{
1676                              "tuple" => [
1677                                ":key2",
1678                                [
1679                                  %{
1680                                    "tuple" => [
1681                                      ":_",
1682                                      [
1683                                        %{
1684                                          "tuple" => [
1685                                            "/api/v1/streaming",
1686                                            "Pleroma.Web.MastodonAPI.WebsocketHandler",
1687                                            []
1688                                          ]
1689                                        },
1690                                        %{
1691                                          "tuple" => [
1692                                            "/websocket",
1693                                            "Phoenix.Endpoint.CowboyWebSocket",
1694                                            %{
1695                                              "tuple" => [
1696                                                "Phoenix.Transports.WebSocket",
1697                                                %{
1698                                                  "tuple" => [
1699                                                    "Pleroma.Web.Endpoint",
1700                                                    "Pleroma.Web.UserSocket",
1701                                                    []
1702                                                  ]
1703                                                }
1704                                              ]
1705                                            }
1706                                          ]
1707                                        },
1708                                        %{
1709                                          "tuple" => [
1710                                            ":_",
1711                                            "Phoenix.Endpoint.Cowboy2Handler",
1712                                            %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1713                                          ]
1714                                        }
1715                                      ]
1716                                    ]
1717                                  }
1718                                ]
1719                              ]
1720                            }
1721                          ]
1722                        ]
1723                      }
1724                    ]
1725                  }
1726                ]
1727              }
1728     end
1729
1730     test "settings with nesting map", %{conn: conn} do
1731       conn =
1732         post(conn, "/api/pleroma/admin/config", %{
1733           configs: [
1734             %{
1735               "group" => "pleroma",
1736               "key" => ":key1",
1737               "value" => [
1738                 %{"tuple" => [":key2", "some_val"]},
1739                 %{
1740                   "tuple" => [
1741                     ":key3",
1742                     %{
1743                       ":max_options" => 20,
1744                       ":max_option_chars" => 200,
1745                       ":min_expiration" => 0,
1746                       ":max_expiration" => 31_536_000,
1747                       "nested" => %{
1748                         ":max_options" => 20,
1749                         ":max_option_chars" => 200,
1750                         ":min_expiration" => 0,
1751                         ":max_expiration" => 31_536_000
1752                       }
1753                     }
1754                   ]
1755                 }
1756               ]
1757             }
1758           ]
1759         })
1760
1761       assert json_response(conn, 200) ==
1762                %{
1763                  "configs" => [
1764                    %{
1765                      "group" => "pleroma",
1766                      "key" => ":key1",
1767                      "value" => [
1768                        %{"tuple" => [":key2", "some_val"]},
1769                        %{
1770                          "tuple" => [
1771                            ":key3",
1772                            %{
1773                              ":max_expiration" => 31_536_000,
1774                              ":max_option_chars" => 200,
1775                              ":max_options" => 20,
1776                              ":min_expiration" => 0,
1777                              "nested" => %{
1778                                ":max_expiration" => 31_536_000,
1779                                ":max_option_chars" => 200,
1780                                ":max_options" => 20,
1781                                ":min_expiration" => 0
1782                              }
1783                            }
1784                          ]
1785                        }
1786                      ]
1787                    }
1788                  ]
1789                }
1790     end
1791
1792     test "value as map", %{conn: conn} do
1793       conn =
1794         post(conn, "/api/pleroma/admin/config", %{
1795           configs: [
1796             %{
1797               "group" => "pleroma",
1798               "key" => ":key1",
1799               "value" => %{"key" => "some_val"}
1800             }
1801           ]
1802         })
1803
1804       assert json_response(conn, 200) ==
1805                %{
1806                  "configs" => [
1807                    %{
1808                      "group" => "pleroma",
1809                      "key" => ":key1",
1810                      "value" => %{"key" => "some_val"}
1811                    }
1812                  ]
1813                }
1814     end
1815
1816     test "dispatch setting", %{conn: conn} do
1817       conn =
1818         post(conn, "/api/pleroma/admin/config", %{
1819           configs: [
1820             %{
1821               "group" => "pleroma",
1822               "key" => "Pleroma.Web.Endpoint.NotReal",
1823               "value" => [
1824                 %{
1825                   "tuple" => [
1826                     ":http",
1827                     [
1828                       %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
1829                       %{"tuple" => [":dispatch", ["{:_,
1830        [
1831          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
1832          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
1833           {Phoenix.Transports.WebSocket,
1834            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
1835          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
1836        ]}"]]}
1837                     ]
1838                   ]
1839                 }
1840               ]
1841             }
1842           ]
1843         })
1844
1845       dispatch_string =
1846         "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
1847           "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
1848           "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
1849           "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
1850
1851       assert json_response(conn, 200) == %{
1852                "configs" => [
1853                  %{
1854                    "group" => "pleroma",
1855                    "key" => "Pleroma.Web.Endpoint.NotReal",
1856                    "value" => [
1857                      %{
1858                        "tuple" => [
1859                          ":http",
1860                          [
1861                            %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
1862                            %{
1863                              "tuple" => [
1864                                ":dispatch",
1865                                [
1866                                  dispatch_string
1867                                ]
1868                              ]
1869                            }
1870                          ]
1871                        ]
1872                      }
1873                    ]
1874                  }
1875                ]
1876              }
1877     end
1878
1879     test "queues key as atom", %{conn: conn} do
1880       conn =
1881         post(conn, "/api/pleroma/admin/config", %{
1882           configs: [
1883             %{
1884               "group" => "pleroma_job_queue",
1885               "key" => ":queues",
1886               "value" => [
1887                 %{"tuple" => [":federator_incoming", 50]},
1888                 %{"tuple" => [":federator_outgoing", 50]},
1889                 %{"tuple" => [":web_push", 50]},
1890                 %{"tuple" => [":mailer", 10]},
1891                 %{"tuple" => [":transmogrifier", 20]},
1892                 %{"tuple" => [":scheduled_activities", 10]},
1893                 %{"tuple" => [":background", 5]}
1894               ]
1895             }
1896           ]
1897         })
1898
1899       assert json_response(conn, 200) == %{
1900                "configs" => [
1901                  %{
1902                    "group" => "pleroma_job_queue",
1903                    "key" => ":queues",
1904                    "value" => [
1905                      %{"tuple" => [":federator_incoming", 50]},
1906                      %{"tuple" => [":federator_outgoing", 50]},
1907                      %{"tuple" => [":web_push", 50]},
1908                      %{"tuple" => [":mailer", 10]},
1909                      %{"tuple" => [":transmogrifier", 20]},
1910                      %{"tuple" => [":scheduled_activities", 10]},
1911                      %{"tuple" => [":background", 5]}
1912                    ]
1913                  }
1914                ]
1915              }
1916     end
1917   end
1918
1919   describe "config mix tasks run" do
1920     setup %{conn: conn} do
1921       admin = insert(:user, info: %{is_admin: true})
1922
1923       temp_file = "config/test.exported_from_db.secret.exs"
1924
1925       on_exit(fn ->
1926         :ok = File.rm(temp_file)
1927       end)
1928
1929       dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
1930
1931       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1932
1933       on_exit(fn ->
1934         Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
1935       end)
1936
1937       %{conn: assign(conn, :user, admin), admin: admin}
1938     end
1939
1940     test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
1941       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
1942       conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
1943       assert json_response(conn, 200) == %{}
1944       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0
1945
1946       conn =
1947         build_conn()
1948         |> assign(:user, admin)
1949         |> get("/api/pleroma/admin/config/migrate_from_db")
1950
1951       assert json_response(conn, 200) == %{}
1952       assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
1953     end
1954   end
1955
1956   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
1957     setup do
1958       admin = insert(:user, info: %{is_admin: true})
1959       user = insert(:user)
1960
1961       date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
1962       date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
1963       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
1964
1965       insert(:note_activity, user: user, published: date1)
1966       insert(:note_activity, user: user, published: date2)
1967       insert(:note_activity, user: user, published: date3)
1968
1969       conn =
1970         build_conn()
1971         |> assign(:user, admin)
1972
1973       {:ok, conn: conn, user: user}
1974     end
1975
1976     test "renders user's statuses", %{conn: conn, user: user} do
1977       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
1978
1979       assert json_response(conn, 200) |> length() == 3
1980     end
1981
1982     test "renders user's statuses with a limit", %{conn: conn, user: user} do
1983       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
1984
1985       assert json_response(conn, 200) |> length() == 2
1986     end
1987
1988     test "doesn't return private statuses by default", %{conn: conn, user: user} do
1989       {:ok, _private_status} =
1990         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
1991
1992       {:ok, _public_status} =
1993         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
1994
1995       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
1996
1997       assert json_response(conn, 200) |> length() == 4
1998     end
1999
2000     test "returns private statuses with godmode on", %{conn: conn, user: user} do
2001       {:ok, _private_status} =
2002         CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})
2003
2004       {:ok, _public_status} =
2005         CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})
2006
2007       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")
2008
2009       assert json_response(conn, 200) |> length() == 5
2010     end
2011   end
2012 end
2013
2014 # Needed for testing
2015 defmodule Pleroma.Web.Endpoint.NotReal do
2016 end
2017
2018 defmodule Pleroma.Captcha.NotReal do
2019 end