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.User
  10   alias Pleroma.UserInviteToken
  11   alias Pleroma.Web.CommonAPI
  12   import Pleroma.Factory
  13
  14   describe "/api/pleroma/admin/users" do
  15     test "Delete" do
  16       admin = insert(:user, info: %{is_admin: true})
  17       user = insert(:user)
  18
  19       conn =
  20         build_conn()
  21         |> assign(:user, admin)
  22         |> put_req_header("accept", "application/json")
  23         |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
  24
  25       assert json_response(conn, 200) == user.nickname
  26     end
  27
  28     test "Create" do
  29       admin = insert(:user, info: %{is_admin: true})
  30
  31       conn =
  32         build_conn()
  33         |> assign(:user, admin)
  34         |> put_req_header("accept", "application/json")
  35         |> post("/api/pleroma/admin/users", %{
  36           "nickname" => "lain",
  37           "email" => "lain@example.org",
  38           "password" => "test"
  39         })
  40
  41       assert json_response(conn, 200) == "lain"
  42     end
  43   end
  44
  45   describe "/api/pleroma/admin/users/:nickname" do
  46     test "Show", %{conn: conn} do
  47       admin = insert(:user, info: %{is_admin: true})
  48       user = insert(:user)
  49
  50       conn =
  51         conn
  52         |> assign(:user, admin)
  53         |> get("/api/pleroma/admin/users/#{user.nickname}")
  54
  55       expected = %{
  56         "deactivated" => false,
  57         "id" => to_string(user.id),
  58         "local" => true,
  59         "nickname" => user.nickname,
  60         "roles" => %{"admin" => false, "moderator" => false},
  61         "tags" => []
  62       }
  63
  64       assert expected == json_response(conn, 200)
  65     end
  66
  67     test "when the user doesn't exist", %{conn: conn} do
  68       admin = insert(:user, info: %{is_admin: true})
  69       user = build(:user)
  70
  71       conn =
  72         conn
  73         |> assign(:user, admin)
  74         |> get("/api/pleroma/admin/users/#{user.nickname}")
  75
  76       assert "Not found" == json_response(conn, 404)
  77     end
  78   end
  79
  80   describe "/api/pleroma/admin/users/follow" do
  81     test "allows to force-follow another user" do
  82       admin = insert(:user, info: %{is_admin: true})
  83       user = insert(:user)
  84       follower = insert(:user)
  85
  86       build_conn()
  87       |> assign(:user, admin)
  88       |> put_req_header("accept", "application/json")
  89       |> post("/api/pleroma/admin/users/follow", %{
  90         "follower" => follower.nickname,
  91         "followed" => user.nickname
  92       })
  93
  94       user = User.get_cached_by_id(user.id)
  95       follower = User.get_cached_by_id(follower.id)
  96
  97       assert User.following?(follower, user)
  98     end
  99   end
 100
 101   describe "/api/pleroma/admin/users/unfollow" do
 102     test "allows to force-unfollow another user" do
 103       admin = insert(:user, info: %{is_admin: true})
 104       user = insert(:user)
 105       follower = insert(:user)
 106
 107       User.follow(follower, user)
 108
 109       build_conn()
 110       |> assign(:user, admin)
 111       |> put_req_header("accept", "application/json")
 112       |> post("/api/pleroma/admin/users/unfollow", %{
 113         "follower" => follower.nickname,
 114         "followed" => user.nickname
 115       })
 116
 117       user = User.get_cached_by_id(user.id)
 118       follower = User.get_cached_by_id(follower.id)
 119
 120       refute User.following?(follower, user)
 121     end
 122   end
 123
 124   describe "PUT /api/pleroma/admin/users/tag" do
 125     setup do
 126       admin = insert(:user, info: %{is_admin: true})
 127       user1 = insert(:user, %{tags: ["x"]})
 128       user2 = insert(:user, %{tags: ["y"]})
 129       user3 = insert(:user, %{tags: ["unchanged"]})
 130
 131       conn =
 132         build_conn()
 133         |> assign(:user, admin)
 134         |> put_req_header("accept", "application/json")
 135         |> put(
 136           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 137             user2.nickname
 138           }&tags[]=foo&tags[]=bar"
 139         )
 140
 141       %{conn: conn, user1: user1, user2: user2, user3: user3}
 142     end
 143
 144     test "it appends specified tags to users with specified nicknames", %{
 145       conn: conn,
 146       user1: user1,
 147       user2: user2
 148     } do
 149       assert json_response(conn, :no_content)
 150       assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
 151       assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
 152     end
 153
 154     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 155       assert json_response(conn, :no_content)
 156       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 157     end
 158   end
 159
 160   describe "DELETE /api/pleroma/admin/users/tag" do
 161     setup do
 162       admin = insert(:user, info: %{is_admin: true})
 163       user1 = insert(:user, %{tags: ["x"]})
 164       user2 = insert(:user, %{tags: ["y", "z"]})
 165       user3 = insert(:user, %{tags: ["unchanged"]})
 166
 167       conn =
 168         build_conn()
 169         |> assign(:user, admin)
 170         |> put_req_header("accept", "application/json")
 171         |> delete(
 172           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 173             user2.nickname
 174           }&tags[]=x&tags[]=z"
 175         )
 176
 177       %{conn: conn, user1: user1, user2: user2, user3: user3}
 178     end
 179
 180     test "it removes specified tags from users with specified nicknames", %{
 181       conn: conn,
 182       user1: user1,
 183       user2: user2
 184     } do
 185       assert json_response(conn, :no_content)
 186       assert User.get_cached_by_id(user1.id).tags == []
 187       assert User.get_cached_by_id(user2.id).tags == ["y"]
 188     end
 189
 190     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 191       assert json_response(conn, :no_content)
 192       assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
 193     end
 194   end
 195
 196   describe "/api/pleroma/admin/users/:nickname/permission_group" do
 197     test "GET is giving user_info" do
 198       admin = insert(:user, info: %{is_admin: true})
 199
 200       conn =
 201         build_conn()
 202         |> assign(:user, admin)
 203         |> put_req_header("accept", "application/json")
 204         |> get("/api/pleroma/admin/users/#{admin.nickname}/permission_group/")
 205
 206       assert json_response(conn, 200) == %{
 207                "is_admin" => true,
 208                "is_moderator" => false
 209              }
 210     end
 211
 212     test "/:right POST, can add to a permission group" do
 213       admin = insert(:user, info: %{is_admin: true})
 214       user = insert(:user)
 215
 216       conn =
 217         build_conn()
 218         |> assign(:user, admin)
 219         |> put_req_header("accept", "application/json")
 220         |> post("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 221
 222       assert json_response(conn, 200) == %{
 223                "is_admin" => true
 224              }
 225     end
 226
 227     test "/:right DELETE, can remove from a permission group" do
 228       admin = insert(:user, info: %{is_admin: true})
 229       user = insert(:user, info: %{is_admin: true})
 230
 231       conn =
 232         build_conn()
 233         |> assign(:user, admin)
 234         |> put_req_header("accept", "application/json")
 235         |> delete("/api/pleroma/admin/users/#{user.nickname}/permission_group/admin")
 236
 237       assert json_response(conn, 200) == %{
 238                "is_admin" => false
 239              }
 240     end
 241   end
 242
 243   describe "PUT /api/pleroma/admin/users/:nickname/activation_status" do
 244     setup %{conn: conn} do
 245       admin = insert(:user, info: %{is_admin: true})
 246
 247       conn =
 248         conn
 249         |> assign(:user, admin)
 250         |> put_req_header("accept", "application/json")
 251
 252       %{conn: conn}
 253     end
 254
 255     test "deactivates the user", %{conn: conn} do
 256       user = insert(:user)
 257
 258       conn =
 259         conn
 260         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 261
 262       user = User.get_cached_by_id(user.id)
 263       assert user.info.deactivated == true
 264       assert json_response(conn, :no_content)
 265     end
 266
 267     test "activates the user", %{conn: conn} do
 268       user = insert(:user, info: %{deactivated: true})
 269
 270       conn =
 271         conn
 272         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: true})
 273
 274       user = User.get_cached_by_id(user.id)
 275       assert user.info.deactivated == false
 276       assert json_response(conn, :no_content)
 277     end
 278
 279     test "returns 403 when requested by a non-admin", %{conn: conn} do
 280       user = insert(:user)
 281
 282       conn =
 283         conn
 284         |> assign(:user, user)
 285         |> put("/api/pleroma/admin/users/#{user.nickname}/activation_status", %{status: false})
 286
 287       assert json_response(conn, :forbidden)
 288     end
 289   end
 290
 291   describe "POST /api/pleroma/admin/email_invite, with valid config" do
 292     setup do
 293       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 294       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 295       Pleroma.Config.put([:instance, :registrations_open], false)
 296       Pleroma.Config.put([:instance, :invites_enabled], true)
 297
 298       on_exit(fn ->
 299         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 300         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 301         :ok
 302       end)
 303
 304       [user: insert(:user, info: %{is_admin: true})]
 305     end
 306
 307     test "sends invitation and returns 204", %{conn: conn, user: user} do
 308       recipient_email = "foo@bar.com"
 309       recipient_name = "J. D."
 310
 311       conn =
 312         conn
 313         |> assign(:user, user)
 314         |> post(
 315           "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
 316         )
 317
 318       assert json_response(conn, :no_content)
 319
 320       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 321       assert token_record
 322       refute token_record.used
 323
 324       notify_email = Pleroma.Config.get([:instance, :notify_email])
 325       instance_name = Pleroma.Config.get([:instance, :name])
 326
 327       email =
 328         Pleroma.Emails.UserEmail.user_invitation_email(
 329           user,
 330           token_record,
 331           recipient_email,
 332           recipient_name
 333         )
 334
 335       Swoosh.TestAssertions.assert_email_sent(
 336         from: {instance_name, notify_email},
 337         to: {recipient_name, recipient_email},
 338         html_body: email.html_body
 339       )
 340     end
 341
 342     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 343       non_admin_user = insert(:user)
 344
 345       conn =
 346         conn
 347         |> assign(:user, non_admin_user)
 348         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 349
 350       assert json_response(conn, :forbidden)
 351     end
 352   end
 353
 354   describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
 355     setup do
 356       [user: insert(:user, info: %{is_admin: true})]
 357     end
 358
 359     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 360       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 361       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 362       Pleroma.Config.put([:instance, :registrations_open], false)
 363       Pleroma.Config.put([:instance, :invites_enabled], false)
 364
 365       on_exit(fn ->
 366         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 367         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 368         :ok
 369       end)
 370
 371       conn =
 372         conn
 373         |> assign(:user, user)
 374         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 375
 376       assert json_response(conn, :internal_server_error)
 377     end
 378
 379     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 380       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 381       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 382       Pleroma.Config.put([:instance, :registrations_open], true)
 383       Pleroma.Config.put([:instance, :invites_enabled], true)
 384
 385       on_exit(fn ->
 386         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 387         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 388         :ok
 389       end)
 390
 391       conn =
 392         conn
 393         |> assign(:user, user)
 394         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 395
 396       assert json_response(conn, :internal_server_error)
 397     end
 398   end
 399
 400   test "/api/pleroma/admin/users/invite_token" do
 401     admin = insert(:user, info: %{is_admin: true})
 402
 403     conn =
 404       build_conn()
 405       |> assign(:user, admin)
 406       |> put_req_header("accept", "application/json")
 407       |> get("/api/pleroma/admin/users/invite_token")
 408
 409     assert conn.status == 200
 410   end
 411
 412   test "/api/pleroma/admin/users/:nickname/password_reset" do
 413     admin = insert(:user, info: %{is_admin: true})
 414     user = insert(:user)
 415
 416     conn =
 417       build_conn()
 418       |> assign(:user, admin)
 419       |> put_req_header("accept", "application/json")
 420       |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
 421
 422     assert conn.status == 200
 423   end
 424
 425   describe "GET /api/pleroma/admin/users" do
 426     setup do
 427       admin = insert(:user, info: %{is_admin: true})
 428
 429       conn =
 430         build_conn()
 431         |> assign(:user, admin)
 432
 433       {:ok, conn: conn, admin: admin}
 434     end
 435
 436     test "renders users array for the first page", %{conn: conn, admin: admin} do
 437       user = insert(:user, local: false, tags: ["foo", "bar"])
 438       conn = get(conn, "/api/pleroma/admin/users?page=1")
 439
 440       users =
 441         [
 442           %{
 443             "deactivated" => admin.info.deactivated,
 444             "id" => admin.id,
 445             "nickname" => admin.nickname,
 446             "roles" => %{"admin" => true, "moderator" => false},
 447             "local" => true,
 448             "tags" => []
 449           },
 450           %{
 451             "deactivated" => user.info.deactivated,
 452             "id" => user.id,
 453             "nickname" => user.nickname,
 454             "roles" => %{"admin" => false, "moderator" => false},
 455             "local" => false,
 456             "tags" => ["foo", "bar"]
 457           }
 458         ]
 459         |> Enum.sort_by(& &1["nickname"])
 460
 461       assert json_response(conn, 200) == %{
 462                "count" => 2,
 463                "page_size" => 50,
 464                "users" => users
 465              }
 466     end
 467
 468     test "renders empty array for the second page", %{conn: conn} do
 469       insert(:user)
 470
 471       conn = get(conn, "/api/pleroma/admin/users?page=2")
 472
 473       assert json_response(conn, 200) == %{
 474                "count" => 2,
 475                "page_size" => 50,
 476                "users" => []
 477              }
 478     end
 479
 480     test "regular search", %{conn: conn} do
 481       user = insert(:user, nickname: "bob")
 482
 483       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 484
 485       assert json_response(conn, 200) == %{
 486                "count" => 1,
 487                "page_size" => 50,
 488                "users" => [
 489                  %{
 490                    "deactivated" => user.info.deactivated,
 491                    "id" => user.id,
 492                    "nickname" => user.nickname,
 493                    "roles" => %{"admin" => false, "moderator" => false},
 494                    "local" => true,
 495                    "tags" => []
 496                  }
 497                ]
 498              }
 499     end
 500
 501     test "search by domain", %{conn: conn} do
 502       user = insert(:user, nickname: "nickname@domain.com")
 503       insert(:user)
 504
 505       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 506
 507       assert json_response(conn, 200) == %{
 508                "count" => 1,
 509                "page_size" => 50,
 510                "users" => [
 511                  %{
 512                    "deactivated" => user.info.deactivated,
 513                    "id" => user.id,
 514                    "nickname" => user.nickname,
 515                    "roles" => %{"admin" => false, "moderator" => false},
 516                    "local" => true,
 517                    "tags" => []
 518                  }
 519                ]
 520              }
 521     end
 522
 523     test "search by full nickname", %{conn: conn} do
 524       user = insert(:user, nickname: "nickname@domain.com")
 525       insert(:user)
 526
 527       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 528
 529       assert json_response(conn, 200) == %{
 530                "count" => 1,
 531                "page_size" => 50,
 532                "users" => [
 533                  %{
 534                    "deactivated" => user.info.deactivated,
 535                    "id" => user.id,
 536                    "nickname" => user.nickname,
 537                    "roles" => %{"admin" => false, "moderator" => false},
 538                    "local" => true,
 539                    "tags" => []
 540                  }
 541                ]
 542              }
 543     end
 544
 545     test "search by display name", %{conn: conn} do
 546       user = insert(:user, name: "Display name")
 547       insert(:user)
 548
 549       conn = get(conn, "/api/pleroma/admin/users?name=display")
 550
 551       assert json_response(conn, 200) == %{
 552                "count" => 1,
 553                "page_size" => 50,
 554                "users" => [
 555                  %{
 556                    "deactivated" => user.info.deactivated,
 557                    "id" => user.id,
 558                    "nickname" => user.nickname,
 559                    "roles" => %{"admin" => false, "moderator" => false},
 560                    "local" => true,
 561                    "tags" => []
 562                  }
 563                ]
 564              }
 565     end
 566
 567     test "search by email", %{conn: conn} do
 568       user = insert(:user, email: "email@example.com")
 569       insert(:user)
 570
 571       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 572
 573       assert json_response(conn, 200) == %{
 574                "count" => 1,
 575                "page_size" => 50,
 576                "users" => [
 577                  %{
 578                    "deactivated" => user.info.deactivated,
 579                    "id" => user.id,
 580                    "nickname" => user.nickname,
 581                    "roles" => %{"admin" => false, "moderator" => false},
 582                    "local" => true,
 583                    "tags" => []
 584                  }
 585                ]
 586              }
 587     end
 588
 589     test "regular search with page size", %{conn: conn} do
 590       user = insert(:user, nickname: "aalice")
 591       user2 = insert(:user, nickname: "alice")
 592
 593       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 594
 595       assert json_response(conn1, 200) == %{
 596                "count" => 2,
 597                "page_size" => 1,
 598                "users" => [
 599                  %{
 600                    "deactivated" => user.info.deactivated,
 601                    "id" => user.id,
 602                    "nickname" => user.nickname,
 603                    "roles" => %{"admin" => false, "moderator" => false},
 604                    "local" => true,
 605                    "tags" => []
 606                  }
 607                ]
 608              }
 609
 610       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 611
 612       assert json_response(conn2, 200) == %{
 613                "count" => 2,
 614                "page_size" => 1,
 615                "users" => [
 616                  %{
 617                    "deactivated" => user2.info.deactivated,
 618                    "id" => user2.id,
 619                    "nickname" => user2.nickname,
 620                    "roles" => %{"admin" => false, "moderator" => false},
 621                    "local" => true,
 622                    "tags" => []
 623                  }
 624                ]
 625              }
 626     end
 627
 628     test "only local users" do
 629       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 630       user = insert(:user, nickname: "bob")
 631
 632       insert(:user, nickname: "bobb", local: false)
 633
 634       conn =
 635         build_conn()
 636         |> assign(:user, admin)
 637         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 638
 639       assert json_response(conn, 200) == %{
 640                "count" => 1,
 641                "page_size" => 50,
 642                "users" => [
 643                  %{
 644                    "deactivated" => user.info.deactivated,
 645                    "id" => user.id,
 646                    "nickname" => user.nickname,
 647                    "roles" => %{"admin" => false, "moderator" => false},
 648                    "local" => true,
 649                    "tags" => []
 650                  }
 651                ]
 652              }
 653     end
 654
 655     test "only local users with no query", %{admin: old_admin} do
 656       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 657       user = insert(:user, nickname: "bob")
 658
 659       insert(:user, nickname: "bobb", local: false)
 660
 661       conn =
 662         build_conn()
 663         |> assign(:user, admin)
 664         |> get("/api/pleroma/admin/users?filters=local")
 665
 666       users =
 667         [
 668           %{
 669             "deactivated" => user.info.deactivated,
 670             "id" => user.id,
 671             "nickname" => user.nickname,
 672             "roles" => %{"admin" => false, "moderator" => false},
 673             "local" => true,
 674             "tags" => []
 675           },
 676           %{
 677             "deactivated" => admin.info.deactivated,
 678             "id" => admin.id,
 679             "nickname" => admin.nickname,
 680             "roles" => %{"admin" => true, "moderator" => false},
 681             "local" => true,
 682             "tags" => []
 683           },
 684           %{
 685             "deactivated" => false,
 686             "id" => old_admin.id,
 687             "local" => true,
 688             "nickname" => old_admin.nickname,
 689             "roles" => %{"admin" => true, "moderator" => false},
 690             "tags" => []
 691           }
 692         ]
 693         |> Enum.sort_by(& &1["nickname"])
 694
 695       assert json_response(conn, 200) == %{
 696                "count" => 3,
 697                "page_size" => 50,
 698                "users" => users
 699              }
 700     end
 701
 702     test "load only admins", %{conn: conn, admin: admin} do
 703       second_admin = insert(:user, info: %{is_admin: true})
 704       insert(:user)
 705       insert(:user)
 706
 707       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 708
 709       users =
 710         [
 711           %{
 712             "deactivated" => false,
 713             "id" => admin.id,
 714             "nickname" => admin.nickname,
 715             "roles" => %{"admin" => true, "moderator" => false},
 716             "local" => admin.local,
 717             "tags" => []
 718           },
 719           %{
 720             "deactivated" => false,
 721             "id" => second_admin.id,
 722             "nickname" => second_admin.nickname,
 723             "roles" => %{"admin" => true, "moderator" => false},
 724             "local" => second_admin.local,
 725             "tags" => []
 726           }
 727         ]
 728         |> Enum.sort_by(& &1["nickname"])
 729
 730       assert json_response(conn, 200) == %{
 731                "count" => 2,
 732                "page_size" => 50,
 733                "users" => users
 734              }
 735     end
 736
 737     test "load only moderators", %{conn: conn} do
 738       moderator = insert(:user, info: %{is_moderator: true})
 739       insert(:user)
 740       insert(:user)
 741
 742       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
 743
 744       assert json_response(conn, 200) == %{
 745                "count" => 1,
 746                "page_size" => 50,
 747                "users" => [
 748                  %{
 749                    "deactivated" => false,
 750                    "id" => moderator.id,
 751                    "nickname" => moderator.nickname,
 752                    "roles" => %{"admin" => false, "moderator" => true},
 753                    "local" => moderator.local,
 754                    "tags" => []
 755                  }
 756                ]
 757              }
 758     end
 759
 760     test "load users with tags list", %{conn: conn} do
 761       user1 = insert(:user, tags: ["first"])
 762       user2 = insert(:user, tags: ["second"])
 763       insert(:user)
 764       insert(:user)
 765
 766       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
 767
 768       users =
 769         [
 770           %{
 771             "deactivated" => false,
 772             "id" => user1.id,
 773             "nickname" => user1.nickname,
 774             "roles" => %{"admin" => false, "moderator" => false},
 775             "local" => user1.local,
 776             "tags" => ["first"]
 777           },
 778           %{
 779             "deactivated" => false,
 780             "id" => user2.id,
 781             "nickname" => user2.nickname,
 782             "roles" => %{"admin" => false, "moderator" => false},
 783             "local" => user2.local,
 784             "tags" => ["second"]
 785           }
 786         ]
 787         |> Enum.sort_by(& &1["nickname"])
 788
 789       assert json_response(conn, 200) == %{
 790                "count" => 2,
 791                "page_size" => 50,
 792                "users" => users
 793              }
 794     end
 795
 796     test "it works with multiple filters" do
 797       admin = insert(:user, nickname: "john", info: %{is_admin: true})
 798       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
 799
 800       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
 801       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
 802
 803       conn =
 804         build_conn()
 805         |> assign(:user, admin)
 806         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 807
 808       assert json_response(conn, 200) == %{
 809                "count" => 1,
 810                "page_size" => 50,
 811                "users" => [
 812                  %{
 813                    "deactivated" => user.info.deactivated,
 814                    "id" => user.id,
 815                    "nickname" => user.nickname,
 816                    "roles" => %{"admin" => false, "moderator" => false},
 817                    "local" => user.local,
 818                    "tags" => []
 819                  }
 820                ]
 821              }
 822     end
 823   end
 824
 825   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
 826     admin = insert(:user, info: %{is_admin: true})
 827     user = insert(:user)
 828
 829     conn =
 830       build_conn()
 831       |> assign(:user, admin)
 832       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 833
 834     assert json_response(conn, 200) ==
 835              %{
 836                "deactivated" => !user.info.deactivated,
 837                "id" => user.id,
 838                "nickname" => user.nickname,
 839                "roles" => %{"admin" => false, "moderator" => false},
 840                "local" => true,
 841                "tags" => []
 842              }
 843   end
 844
 845   describe "GET /api/pleroma/admin/users/invite_token" do
 846     setup do
 847       admin = insert(:user, info: %{is_admin: true})
 848
 849       conn =
 850         build_conn()
 851         |> assign(:user, admin)
 852
 853       {:ok, conn: conn}
 854     end
 855
 856     test "without options", %{conn: conn} do
 857       conn = get(conn, "/api/pleroma/admin/users/invite_token")
 858
 859       token = json_response(conn, 200)
 860       invite = UserInviteToken.find_by_token!(token)
 861       refute invite.used
 862       refute invite.expires_at
 863       refute invite.max_use
 864       assert invite.invite_type == "one_time"
 865     end
 866
 867     test "with expires_at", %{conn: conn} do
 868       conn =
 869         get(conn, "/api/pleroma/admin/users/invite_token", %{
 870           "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
 871         })
 872
 873       token = json_response(conn, 200)
 874       invite = UserInviteToken.find_by_token!(token)
 875
 876       refute invite.used
 877       assert invite.expires_at == Date.utc_today()
 878       refute invite.max_use
 879       assert invite.invite_type == "date_limited"
 880     end
 881
 882     test "with max_use", %{conn: conn} do
 883       conn =
 884         get(conn, "/api/pleroma/admin/users/invite_token", %{
 885           "invite" => %{"max_use" => 150}
 886         })
 887
 888       token = json_response(conn, 200)
 889       invite = UserInviteToken.find_by_token!(token)
 890       refute invite.used
 891       refute invite.expires_at
 892       assert invite.max_use == 150
 893       assert invite.invite_type == "reusable"
 894     end
 895
 896     test "with max use and expires_at", %{conn: conn} do
 897       conn =
 898         get(conn, "/api/pleroma/admin/users/invite_token", %{
 899           "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
 900         })
 901
 902       token = json_response(conn, 200)
 903       invite = UserInviteToken.find_by_token!(token)
 904       refute invite.used
 905       assert invite.expires_at == Date.utc_today()
 906       assert invite.max_use == 150
 907       assert invite.invite_type == "reusable_date_limited"
 908     end
 909   end
 910
 911   describe "GET /api/pleroma/admin/users/invites" do
 912     setup do
 913       admin = insert(:user, info: %{is_admin: true})
 914
 915       conn =
 916         build_conn()
 917         |> assign(:user, admin)
 918
 919       {:ok, conn: conn}
 920     end
 921
 922     test "no invites", %{conn: conn} do
 923       conn = get(conn, "/api/pleroma/admin/users/invites")
 924
 925       assert json_response(conn, 200) == %{"invites" => []}
 926     end
 927
 928     test "with invite", %{conn: conn} do
 929       {:ok, invite} = UserInviteToken.create_invite()
 930
 931       conn = get(conn, "/api/pleroma/admin/users/invites")
 932
 933       assert json_response(conn, 200) == %{
 934                "invites" => [
 935                  %{
 936                    "expires_at" => nil,
 937                    "id" => invite.id,
 938                    "invite_type" => "one_time",
 939                    "max_use" => nil,
 940                    "token" => invite.token,
 941                    "used" => false,
 942                    "uses" => 0
 943                  }
 944                ]
 945              }
 946     end
 947   end
 948
 949   describe "POST /api/pleroma/admin/users/revoke_invite" do
 950     test "with token" do
 951       admin = insert(:user, info: %{is_admin: true})
 952       {:ok, invite} = UserInviteToken.create_invite()
 953
 954       conn =
 955         build_conn()
 956         |> assign(:user, admin)
 957         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
 958
 959       assert json_response(conn, 200) == %{
 960                "expires_at" => nil,
 961                "id" => invite.id,
 962                "invite_type" => "one_time",
 963                "max_use" => nil,
 964                "token" => invite.token,
 965                "used" => true,
 966                "uses" => 0
 967              }
 968     end
 969   end
 970
 971   describe "GET /api/pleroma/admin/reports/:id" do
 972     setup %{conn: conn} do
 973       admin = insert(:user, info: %{is_admin: true})
 974
 975       %{conn: assign(conn, :user, admin)}
 976     end
 977
 978     test "returns report by its id", %{conn: conn} do
 979       [reporter, target_user] = insert_pair(:user)
 980       activity = insert(:note_activity, user: target_user)
 981
 982       {:ok, %{id: report_id}} =
 983         CommonAPI.report(reporter, %{
 984           "account_id" => target_user.id,
 985           "comment" => "I feel offended",
 986           "status_ids" => [activity.id]
 987         })
 988
 989       response =
 990         conn
 991         |> get("/api/pleroma/admin/reports/#{report_id}")
 992         |> json_response(:ok)
 993
 994       assert response["id"] == report_id
 995     end
 996
 997     test "returns 404 when report id is invalid", %{conn: conn} do
 998       conn = get(conn, "/api/pleroma/admin/reports/test")
 999
1000       assert json_response(conn, :not_found) == "Not found"
1001     end
1002   end
1003
1004   describe "PUT /api/pleroma/admin/reports/:id" do
1005     setup %{conn: conn} do
1006       admin = insert(:user, info: %{is_admin: true})
1007       [reporter, target_user] = insert_pair(:user)
1008       activity = insert(:note_activity, user: target_user)
1009
1010       {:ok, %{id: report_id}} =
1011         CommonAPI.report(reporter, %{
1012           "account_id" => target_user.id,
1013           "comment" => "I feel offended",
1014           "status_ids" => [activity.id]
1015         })
1016
1017       %{conn: assign(conn, :user, admin), id: report_id}
1018     end
1019
1020     test "mark report as resolved", %{conn: conn, id: id} do
1021       response =
1022         conn
1023         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1024         |> json_response(:ok)
1025
1026       assert response["state"] == "resolved"
1027     end
1028
1029     test "closes report", %{conn: conn, id: id} do
1030       response =
1031         conn
1032         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1033         |> json_response(:ok)
1034
1035       assert response["state"] == "closed"
1036     end
1037
1038     test "returns 400 when state is unknown", %{conn: conn, id: id} do
1039       conn =
1040         conn
1041         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1042
1043       assert json_response(conn, :bad_request) == "Unsupported state"
1044     end
1045
1046     test "returns 404 when report is not exist", %{conn: conn} do
1047       conn =
1048         conn
1049         |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1050
1051       assert json_response(conn, :not_found) == "Not found"
1052     end
1053   end
1054
1055   describe "GET /api/pleroma/admin/reports" do
1056     setup %{conn: conn} do
1057       admin = insert(:user, info: %{is_admin: true})
1058
1059       %{conn: assign(conn, :user, admin)}
1060     end
1061
1062     test "returns empty response when no reports created", %{conn: conn} do
1063       response =
1064         conn
1065         |> get("/api/pleroma/admin/reports")
1066         |> json_response(:ok)
1067
1068       assert Enum.empty?(response["reports"])
1069     end
1070
1071     test "returns reports", %{conn: conn} do
1072       [reporter, target_user] = insert_pair(:user)
1073       activity = insert(:note_activity, user: target_user)
1074
1075       {:ok, %{id: report_id}} =
1076         CommonAPI.report(reporter, %{
1077           "account_id" => target_user.id,
1078           "comment" => "I feel offended",
1079           "status_ids" => [activity.id]
1080         })
1081
1082       response =
1083         conn
1084         |> get("/api/pleroma/admin/reports")
1085         |> json_response(:ok)
1086
1087       [report] = response["reports"]
1088
1089       assert length(response["reports"]) == 1
1090       assert report["id"] == report_id
1091     end
1092
1093     test "returns reports with specified state", %{conn: conn} do
1094       [reporter, target_user] = insert_pair(:user)
1095       activity = insert(:note_activity, user: target_user)
1096
1097       {:ok, %{id: first_report_id}} =
1098         CommonAPI.report(reporter, %{
1099           "account_id" => target_user.id,
1100           "comment" => "I feel offended",
1101           "status_ids" => [activity.id]
1102         })
1103
1104       {:ok, %{id: second_report_id}} =
1105         CommonAPI.report(reporter, %{
1106           "account_id" => target_user.id,
1107           "comment" => "I don't like this user"
1108         })
1109
1110       CommonAPI.update_report_state(second_report_id, "closed")
1111
1112       response =
1113         conn
1114         |> get("/api/pleroma/admin/reports", %{
1115           "state" => "open"
1116         })
1117         |> json_response(:ok)
1118
1119       [open_report] = response["reports"]
1120
1121       assert length(response["reports"]) == 1
1122       assert open_report["id"] == first_report_id
1123
1124       response =
1125         conn
1126         |> get("/api/pleroma/admin/reports", %{
1127           "state" => "closed"
1128         })
1129         |> json_response(:ok)
1130
1131       [closed_report] = response["reports"]
1132
1133       assert length(response["reports"]) == 1
1134       assert closed_report["id"] == second_report_id
1135
1136       response =
1137         conn
1138         |> get("/api/pleroma/admin/reports", %{
1139           "state" => "resolved"
1140         })
1141         |> json_response(:ok)
1142
1143       assert Enum.empty?(response["reports"])
1144     end
1145
1146     test "returns 403 when requested by a non-admin" do
1147       user = insert(:user)
1148
1149       conn =
1150         build_conn()
1151         |> assign(:user, user)
1152         |> get("/api/pleroma/admin/reports")
1153
1154       assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1155     end
1156
1157     test "returns 403 when requested by anonymous" do
1158       conn =
1159         build_conn()
1160         |> get("/api/pleroma/admin/reports")
1161
1162       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1163     end
1164   end
1165
1166   describe "POST /api/pleroma/admin/reports/:id/respond" do
1167     setup %{conn: conn} do
1168       admin = insert(:user, info: %{is_admin: true})
1169
1170       %{conn: assign(conn, :user, admin)}
1171     end
1172
1173     test "returns created dm", %{conn: conn} do
1174       [reporter, target_user] = insert_pair(:user)
1175       activity = insert(:note_activity, user: target_user)
1176
1177       {:ok, %{id: report_id}} =
1178         CommonAPI.report(reporter, %{
1179           "account_id" => target_user.id,
1180           "comment" => "I feel offended",
1181           "status_ids" => [activity.id]
1182         })
1183
1184       response =
1185         conn
1186         |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1187           "status" => "I will check it out"
1188         })
1189         |> json_response(:ok)
1190
1191       recipients = Enum.map(response["mentions"], & &1["username"])
1192
1193       assert conn.assigns[:user].nickname in recipients
1194       assert reporter.nickname in recipients
1195       assert response["content"] == "I will check it out"
1196       assert response["visibility"] == "direct"
1197     end
1198
1199     test "returns 400 when status is missing", %{conn: conn} do
1200       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1201
1202       assert json_response(conn, :bad_request) == "Invalid parameters"
1203     end
1204
1205     test "returns 404 when report id is invalid", %{conn: conn} do
1206       conn =
1207         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1208           "status" => "foo"
1209         })
1210
1211       assert json_response(conn, :not_found) == "Not found"
1212     end
1213   end
1214
1215   describe "PUT /api/pleroma/admin/statuses/:id" do
1216     setup %{conn: conn} do
1217       admin = insert(:user, info: %{is_admin: true})
1218       activity = insert(:note_activity)
1219
1220       %{conn: assign(conn, :user, admin), id: activity.id}
1221     end
1222
1223     test "toggle sensitive flag", %{conn: conn, id: id} do
1224       response =
1225         conn
1226         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1227         |> json_response(:ok)
1228
1229       assert response["sensitive"]
1230
1231       response =
1232         conn
1233         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1234         |> json_response(:ok)
1235
1236       refute response["sensitive"]
1237     end
1238
1239     test "change visibility flag", %{conn: conn, id: id} do
1240       response =
1241         conn
1242         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1243         |> json_response(:ok)
1244
1245       assert response["visibility"] == "public"
1246
1247       response =
1248         conn
1249         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1250         |> json_response(:ok)
1251
1252       assert response["visibility"] == "private"
1253
1254       response =
1255         conn
1256         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1257         |> json_response(:ok)
1258
1259       assert response["visibility"] == "unlisted"
1260     end
1261
1262     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1263       conn =
1264         conn
1265         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1266
1267       assert json_response(conn, :bad_request) == "Unsupported visibility"
1268     end
1269   end
1270
1271   describe "DELETE /api/pleroma/admin/statuses/:id" do
1272     setup %{conn: conn} do
1273       admin = insert(:user, info: %{is_admin: true})
1274       activity = insert(:note_activity)
1275
1276       %{conn: assign(conn, :user, admin), id: activity.id}
1277     end
1278
1279     test "deletes status", %{conn: conn, id: id} do
1280       conn
1281       |> delete("/api/pleroma/admin/statuses/#{id}")
1282       |> json_response(:ok)
1283
1284       refute Activity.get_by_id(id)
1285     end
1286
1287     test "returns error when status is not exist", %{conn: conn} do
1288       conn =
1289         conn
1290         |> delete("/api/pleroma/admin/statuses/test")
1291
1292       assert json_response(conn, :bad_request) == "Could not delete"
1293     end
1294   end
1295 end