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 reporter.nickname in recipients
1238       assert response["content"] == "I will check it out"
1239       assert response["visibility"] == "direct"
1240     end
1241
1242     test "returns 400 when status is missing", %{conn: conn} do
1243       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1244
1245       assert json_response(conn, :bad_request) == "Invalid parameters"
1246     end
1247
1248     test "returns 404 when report id is invalid", %{conn: conn} do
1249       conn =
1250         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1251           "status" => "foo"
1252         })
1253
1254       assert json_response(conn, :not_found) == "Not found"
1255     end
1256   end
1257
1258   describe "PUT /api/pleroma/admin/statuses/:id" do
1259     setup %{conn: conn} do
1260       admin = insert(:user, info: %{is_admin: true})
1261       activity = insert(:note_activity)
1262
1263       %{conn: assign(conn, :user, admin), id: activity.id}
1264     end
1265
1266     test "toggle sensitive flag", %{conn: conn, id: id} do
1267       response =
1268         conn
1269         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1270         |> json_response(:ok)
1271
1272       assert response["sensitive"]
1273
1274       response =
1275         conn
1276         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1277         |> json_response(:ok)
1278
1279       refute response["sensitive"]
1280     end
1281
1282     test "change visibility flag", %{conn: conn, id: id} do
1283       response =
1284         conn
1285         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1286         |> json_response(:ok)
1287
1288       assert response["visibility"] == "public"
1289
1290       response =
1291         conn
1292         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1293         |> json_response(:ok)
1294
1295       assert response["visibility"] == "private"
1296
1297       response =
1298         conn
1299         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1300         |> json_response(:ok)
1301
1302       assert response["visibility"] == "unlisted"
1303     end
1304
1305     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1306       conn =
1307         conn
1308         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1309
1310       assert json_response(conn, :bad_request) == "Unsupported visibility"
1311     end
1312   end
1313
1314   describe "DELETE /api/pleroma/admin/statuses/:id" do
1315     setup %{conn: conn} do
1316       admin = insert(:user, info: %{is_admin: true})
1317       activity = insert(:note_activity)
1318
1319       %{conn: assign(conn, :user, admin), id: activity.id}
1320     end
1321
1322     test "deletes status", %{conn: conn, id: id} do
1323       conn
1324       |> delete("/api/pleroma/admin/statuses/#{id}")
1325       |> json_response(:ok)
1326
1327       refute Activity.get_by_id(id)
1328     end
1329
1330     test "returns error when status is not exist", %{conn: conn} do
1331       conn =
1332         conn
1333         |> delete("/api/pleroma/admin/statuses/test")
1334
1335       assert json_response(conn, :bad_request) == "Could not delete"
1336     end
1337   end
1338
1339   describe "GET /api/pleroma/admin/config" do
1340     setup %{conn: conn} do
1341       admin = insert(:user, info: %{is_admin: true})
1342
1343       %{conn: assign(conn, :user, admin)}
1344     end
1345
1346     test "without any settings in db", %{conn: conn} do
1347       conn = get(conn, "/api/pleroma/admin/config")
1348
1349       assert json_response(conn, 200) == %{"configs" => []}
1350     end
1351
1352     test "with settings in db", %{conn: conn} do
1353       config1 = insert(:config)
1354       config2 = insert(:config)
1355
1356       conn = get(conn, "/api/pleroma/admin/config")
1357
1358       %{
1359         "configs" => [
1360           %{
1361             "key" => key1,
1362             "value" => _
1363           },
1364           %{
1365             "key" => key2,
1366             "value" => _
1367           }
1368         ]
1369       } = json_response(conn, 200)
1370
1371       assert key1 == config1.key
1372       assert key2 == config2.key
1373     end
1374   end
1375
1376   describe "POST /api/pleroma/admin/config" do
1377     setup %{conn: conn} do
1378       admin = insert(:user, info: %{is_admin: true})
1379
1380       temp_file = "config/test.exported_from_db.secret.exs"
1381
1382       on_exit(fn ->
1383         Application.delete_env(:pleroma, :key1)
1384         Application.delete_env(:pleroma, :key2)
1385         Application.delete_env(:pleroma, :key3)
1386         Application.delete_env(:pleroma, :key4)
1387         Application.delete_env(:pleroma, :keyaa1)
1388         Application.delete_env(:pleroma, :keyaa2)
1389         Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
1390         Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
1391         :ok = File.rm(temp_file)
1392       end)
1393
1394       dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
1395
1396       Pleroma.Config.put([:instance, :dynamic_configuration], true)
1397
1398       on_exit(fn ->
1399         Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
1400       end)
1401
1402       %{conn: assign(conn, :user, admin)}
1403     end
1404
1405     test "create new config setting in db", %{conn: conn} do
1406       conn =
1407         post(conn, "/api/pleroma/admin/config", %{
1408           configs: [
1409             %{group: "pleroma", key: "key1", value: "value1"},
1410             %{
1411               group: "ueberauth",
1412               key: "Ueberauth.Strategy.Twitter.OAuth",
1413               value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
1414             },
1415             %{
1416               group: "pleroma",
1417               key: "key2",
1418               value: %{
1419                 ":nested_1" => "nested_value1",
1420                 ":nested_2" => [
1421                   %{":nested_22" => "nested_value222"},
1422                   %{":nested_33" => %{":nested_44" => "nested_444"}}
1423                 ]
1424               }
1425             },
1426             %{
1427               group: "pleroma",
1428               key: "key3",
1429               value: [
1430                 %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1431                 %{"nested_4" => true}
1432               ]
1433             },
1434             %{
1435               group: "pleroma",
1436               key: "key4",
1437               value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
1438             },
1439             %{
1440               group: "idna",
1441               key: "key5",
1442               value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1443             }
1444           ]
1445         })
1446
1447       assert json_response(conn, 200) == %{
1448                "configs" => [
1449                  %{
1450                    "group" => "pleroma",
1451                    "key" => "key1",
1452                    "value" => "value1"
1453                  },
1454                  %{
1455                    "group" => "ueberauth",
1456                    "key" => "Ueberauth.Strategy.Twitter.OAuth",
1457                    "value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
1458                  },
1459                  %{
1460                    "group" => "pleroma",
1461                    "key" => "key2",
1462                    "value" => %{
1463                      ":nested_1" => "nested_value1",
1464                      ":nested_2" => [
1465                        %{":nested_22" => "nested_value222"},
1466                        %{":nested_33" => %{":nested_44" => "nested_444"}}
1467                      ]
1468                    }
1469                  },
1470                  %{
1471                    "group" => "pleroma",
1472                    "key" => "key3",
1473                    "value" => [
1474                      %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
1475                      %{"nested_4" => true}
1476                    ]
1477                  },
1478                  %{
1479                    "group" => "pleroma",
1480                    "key" => "key4",
1481                    "value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
1482                  },
1483                  %{
1484                    "group" => "idna",
1485                    "key" => "key5",
1486                    "value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
1487                  }
1488                ]
1489              }
1490
1491       assert Application.get_env(:pleroma, :key1) == "value1"
1492
1493       assert Application.get_env(:pleroma, :key2) == %{
1494                nested_1: "nested_value1",
1495                nested_2: [
1496                  %{nested_22: "nested_value222"},
1497                  %{nested_33: %{nested_44: "nested_444"}}
1498                ]
1499              }
1500
1501       assert Application.get_env(:pleroma, :key3) == [
1502                %{"nested_3" => :nested_3, "nested_33" => "nested_33"},
1503                %{"nested_4" => true}
1504              ]
1505
1506       assert Application.get_env(:pleroma, :key4) == %{
1507                "endpoint" => "https://example.com",
1508                nested_5: :upload
1509              }
1510
1511       assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
1512     end
1513
1514     test "update config setting & delete", %{conn: conn} do
1515       config1 = insert(:config, key: "keyaa1")
1516       config2 = insert(:config, key: "keyaa2")
1517
1518       insert(:config,
1519         group: "ueberauth",
1520         key: "Ueberauth.Strategy.Microsoft.OAuth",
1521         value: :erlang.term_to_binary([])
1522       )
1523
1524       conn =
1525         post(conn, "/api/pleroma/admin/config", %{
1526           configs: [
1527             %{group: config1.group, key: config1.key, value: "another_value"},
1528             %{group: config2.group, key: config2.key, delete: "true"},
1529             %{
1530               group: "ueberauth",
1531               key: "Ueberauth.Strategy.Microsoft.OAuth",
1532               delete: "true"
1533             }
1534           ]
1535         })
1536
1537       assert json_response(conn, 200) == %{
1538                "configs" => [
1539                  %{
1540                    "group" => "pleroma",
1541                    "key" => config1.key,
1542                    "value" => "another_value"
1543                  }
1544                ]
1545              }
1546
1547       assert Application.get_env(:pleroma, :keyaa1) == "another_value"
1548       refute Application.get_env(:pleroma, :keyaa2)
1549     end
1550
1551     test "common config example", %{conn: conn} do
1552       conn =
1553         post(conn, "/api/pleroma/admin/config", %{
1554           configs: [
1555             %{
1556               "group" => "pleroma",
1557               "key" => "Pleroma.Captcha.NotReal",
1558               "value" => [
1559                 %{"tuple" => [":enabled", false]},
1560                 %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1561                 %{"tuple" => [":seconds_valid", 60]},
1562                 %{"tuple" => [":path", ""]},
1563                 %{"tuple" => [":key1", nil]}
1564               ]
1565             }
1566           ]
1567         })
1568
1569       assert json_response(conn, 200) == %{
1570                "configs" => [
1571                  %{
1572                    "group" => "pleroma",
1573                    "key" => "Pleroma.Captcha.NotReal",
1574                    "value" => [
1575                      %{"tuple" => [":enabled", false]},
1576                      %{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
1577                      %{"tuple" => [":seconds_valid", 60]},
1578                      %{"tuple" => [":path", ""]},
1579                      %{"tuple" => [":key1", nil]}
1580                    ]
1581                  }
1582                ]
1583              }
1584     end
1585
1586     test "tuples with more than two values", %{conn: conn} do
1587       conn =
1588         post(conn, "/api/pleroma/admin/config", %{
1589           configs: [
1590             %{
1591               "group" => "pleroma",
1592               "key" => "Pleroma.Web.Endpoint.NotReal",
1593               "value" => [
1594                 %{
1595                   "tuple" => [
1596                     ":http",
1597                     [
1598                       %{
1599                         "tuple" => [
1600                           ":key2",
1601                           [
1602                             %{
1603                               "tuple" => [
1604                                 ":_",
1605                                 [
1606                                   %{
1607                                     "tuple" => [
1608                                       "/api/v1/streaming",
1609                                       "Pleroma.Web.MastodonAPI.WebsocketHandler",
1610                                       []
1611                                     ]
1612                                   },
1613                                   %{
1614                                     "tuple" => [
1615                                       "/websocket",
1616                                       "Phoenix.Endpoint.CowboyWebSocket",
1617                                       %{
1618                                         "tuple" => [
1619                                           "Phoenix.Transports.WebSocket",
1620                                           %{
1621                                             "tuple" => [
1622                                               "Pleroma.Web.Endpoint",
1623                                               "Pleroma.Web.UserSocket",
1624                                               []
1625                                             ]
1626                                           }
1627                                         ]
1628                                       }
1629                                     ]
1630                                   },
1631                                   %{
1632                                     "tuple" => [
1633                                       ":_",
1634                                       "Phoenix.Endpoint.Cowboy2Handler",
1635                                       %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1636                                     ]
1637                                   }
1638                                 ]
1639                               ]
1640                             }
1641                           ]
1642                         ]
1643                       }
1644                     ]
1645                   ]
1646                 }
1647               ]
1648             }
1649           ]
1650         })
1651
1652       assert json_response(conn, 200) == %{
1653                "configs" => [
1654                  %{
1655                    "group" => "pleroma",
1656                    "key" => "Pleroma.Web.Endpoint.NotReal",
1657                    "value" => [
1658                      %{
1659                        "tuple" => [
1660                          ":http",
1661                          [
1662                            %{
1663                              "tuple" => [
1664                                ":key2",
1665                                [
1666                                  %{
1667                                    "tuple" => [
1668                                      ":_",
1669                                      [
1670                                        %{
1671                                          "tuple" => [
1672                                            "/api/v1/streaming",
1673                                            "Pleroma.Web.MastodonAPI.WebsocketHandler",
1674                                            []
1675                                          ]
1676                                        },
1677                                        %{
1678                                          "tuple" => [
1679                                            "/websocket",
1680                                            "Phoenix.Endpoint.CowboyWebSocket",
1681                                            %{
1682                                              "tuple" => [
1683                                                "Phoenix.Transports.WebSocket",
1684                                                %{
1685                                                  "tuple" => [
1686                                                    "Pleroma.Web.Endpoint",
1687                                                    "Pleroma.Web.UserSocket",
1688                                                    []
1689                                                  ]
1690                                                }
1691                                              ]
1692                                            }
1693                                          ]
1694                                        },
1695                                        %{
1696                                          "tuple" => [
1697                                            ":_",
1698                                            "Phoenix.Endpoint.Cowboy2Handler",
1699                                            %{"tuple" => ["Pleroma.Web.Endpoint", []]}
1700                                          ]
1701                                        }
1702                                      ]
1703                                    ]
1704                                  }
1705                                ]
1706                              ]
1707                            }
1708                          ]
1709                        ]
1710                      }
1711                    ]
1712                  }
1713                ]
1714              }
1715     end
1716
1717     test "settings with nesting map", %{conn: conn} do
1718       conn =
1719         post(conn, "/api/pleroma/admin/config", %{
1720           configs: [
1721             %{
1722               "group" => "pleroma",
1723               "key" => "key1",
1724               "value" => [
1725                 %{"tuple" => [":key2", "some_val"]},
1726                 %{
1727                   "tuple" => [
1728                     ":key3",
1729                     %{
1730                       ":max_options" => 20,
1731                       ":max_option_chars" => 200,
1732                       ":min_expiration" => 0,
1733                       ":max_expiration" => 31_536_000,
1734                       "nested" => %{
1735                         ":max_options" => 20,
1736                         ":max_option_chars" => 200,
1737                         ":min_expiration" => 0,
1738                         ":max_expiration" => 31_536_000
1739                       }
1740                     }
1741                   ]
1742                 }
1743               ]
1744             }
1745           ]
1746         })
1747
1748       assert json_response(conn, 200) ==
1749                %{
1750                  "configs" => [
1751                    %{
1752                      "group" => "pleroma",
1753                      "key" => "key1",
1754                      "value" => [
1755                        %{"tuple" => [":key2", "some_val"]},
1756                        %{
1757                          "tuple" => [
1758                            ":key3",
1759                            %{
1760                              ":max_expiration" => 31_536_000,
1761                              ":max_option_chars" => 200,
1762                              ":max_options" => 20,
1763                              ":min_expiration" => 0,
1764                              "nested" => %{
1765                                ":max_expiration" => 31_536_000,
1766                                ":max_option_chars" => 200,
1767                                ":max_options" => 20,
1768                                ":min_expiration" => 0
1769                              }
1770                            }
1771                          ]
1772                        }
1773                      ]
1774                    }
1775                  ]
1776                }
1777     end
1778
1779     test "value as map", %{conn: conn} do
1780       conn =
1781         post(conn, "/api/pleroma/admin/config", %{
1782           configs: [
1783             %{
1784               "group" => "pleroma",
1785               "key" => "key1",
1786               "value" => %{"key" => "some_val"}
1787             }
1788           ]
1789         })
1790
1791       assert json_response(conn, 200) ==
1792                %{
1793                  "configs" => [
1794                    %{
1795                      "group" => "pleroma",
1796                      "key" => "key1",
1797                      "value" => %{"key" => "some_val"}
1798                    }
1799                  ]
1800                }
1801     end
1802
1803     test "dispatch setting", %{conn: conn} do
1804       conn =
1805         post(conn, "/api/pleroma/admin/config", %{
1806           configs: [
1807             %{
1808               "group" => "pleroma",
1809               "key" => "Pleroma.Web.Endpoint.NotReal",
1810               "value" => [
1811                 %{
1812                   "tuple" => [
1813                     ":http",
1814                     [
1815                       %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
1816                       %{"tuple" => [":dispatch", ["{:_,
1817        [
1818          {\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
1819          {\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
1820           {Phoenix.Transports.WebSocket,
1821            {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
1822          {:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
1823        ]}"]]}
1824                     ]
1825                   ]
1826                 }
1827               ]
1828             }
1829           ]
1830         })
1831
1832       dispatch_string =
1833         "{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
1834           "{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
1835           "{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
1836           "{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"
1837
1838       assert json_response(conn, 200) == %{
1839                "configs" => [
1840                  %{
1841                    "group" => "pleroma",
1842                    "key" => "Pleroma.Web.Endpoint.NotReal",
1843                    "value" => [
1844                      %{
1845                        "tuple" => [
1846                          ":http",
1847                          [
1848                            %{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
1849                            %{
1850                              "tuple" => [
1851                                ":dispatch",
1852                                [
1853                                  dispatch_string
1854                                ]
1855                              ]
1856                            }
1857                          ]
1858                        ]
1859                      }
1860                    ]
1861                  }
1862                ]
1863              }
1864     end
1865   end
1866
1867   describe "GET /api/pleroma/admin/users/:nickname/statuses" do
1868     setup do
1869       admin = insert(:user, info: %{is_admin: true})
1870       user = insert(:user)
1871
1872       date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) |> DateTime.from_unix!()
1873       date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) |> DateTime.from_unix!()
1874       date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) |> DateTime.from_unix!()
1875
1876       insert(:note_activity, user: user, published: date1)
1877       insert(:note_activity, user: user, published: date2)
1878       insert(:note_activity, user: user, published: date3)
1879
1880       conn =
1881         build_conn()
1882         |> assign(:user, admin)
1883
1884       {:ok, conn: conn, user: user}
1885     end
1886
1887     test "renders user's statuses", %{conn: conn, user: user} do
1888       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")
1889
1890       assert json_response(conn, 200) |> length() == 3
1891     end
1892
1893     test "renders user's statuses with a limit", %{conn: conn, user: user} do
1894       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")
1895
1896       assert json_response(conn, 200) |> length() == 2
1897     end
1898   end
1899 end
1900
1901 # Needed for testing
1902 defmodule Pleroma.Web.Endpoint.NotReal do
1903 end
1904
1905 defmodule Pleroma.Captcha.NotReal do
1906 end