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       assert json_response(conn, 200) == %{
 441                "count" => 2,
 442                "page_size" => 50,
 443                "users" => [
 444                  %{
 445                    "deactivated" => admin.info.deactivated,
 446                    "id" => admin.id,
 447                    "nickname" => admin.nickname,
 448                    "roles" => %{"admin" => true, "moderator" => false},
 449                    "local" => true,
 450                    "tags" => []
 451                  },
 452                  %{
 453                    "deactivated" => user.info.deactivated,
 454                    "id" => user.id,
 455                    "nickname" => user.nickname,
 456                    "roles" => %{"admin" => false, "moderator" => false},
 457                    "local" => false,
 458                    "tags" => ["foo", "bar"]
 459                  }
 460                ]
 461              }
 462     end
 463
 464     test "renders empty array for the second page", %{conn: conn} do
 465       insert(:user)
 466
 467       conn = get(conn, "/api/pleroma/admin/users?page=2")
 468
 469       assert json_response(conn, 200) == %{
 470                "count" => 2,
 471                "page_size" => 50,
 472                "users" => []
 473              }
 474     end
 475
 476     test "regular search", %{conn: conn} do
 477       user = insert(:user, nickname: "bob")
 478
 479       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 480
 481       assert json_response(conn, 200) == %{
 482                "count" => 1,
 483                "page_size" => 50,
 484                "users" => [
 485                  %{
 486                    "deactivated" => user.info.deactivated,
 487                    "id" => user.id,
 488                    "nickname" => user.nickname,
 489                    "roles" => %{"admin" => false, "moderator" => false},
 490                    "local" => true,
 491                    "tags" => []
 492                  }
 493                ]
 494              }
 495     end
 496
 497     test "search by domain", %{conn: conn} do
 498       user = insert(:user, nickname: "nickname@domain.com")
 499       insert(:user)
 500
 501       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 502
 503       assert json_response(conn, 200) == %{
 504                "count" => 1,
 505                "page_size" => 50,
 506                "users" => [
 507                  %{
 508                    "deactivated" => user.info.deactivated,
 509                    "id" => user.id,
 510                    "nickname" => user.nickname,
 511                    "roles" => %{"admin" => false, "moderator" => false},
 512                    "local" => true,
 513                    "tags" => []
 514                  }
 515                ]
 516              }
 517     end
 518
 519     test "search by full nickname", %{conn: conn} do
 520       user = insert(:user, nickname: "nickname@domain.com")
 521       insert(:user)
 522
 523       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 524
 525       assert json_response(conn, 200) == %{
 526                "count" => 1,
 527                "page_size" => 50,
 528                "users" => [
 529                  %{
 530                    "deactivated" => user.info.deactivated,
 531                    "id" => user.id,
 532                    "nickname" => user.nickname,
 533                    "roles" => %{"admin" => false, "moderator" => false},
 534                    "local" => true,
 535                    "tags" => []
 536                  }
 537                ]
 538              }
 539     end
 540
 541     test "search by display name", %{conn: conn} do
 542       user = insert(:user, name: "Display name")
 543       insert(:user)
 544
 545       conn = get(conn, "/api/pleroma/admin/users?name=display")
 546
 547       assert json_response(conn, 200) == %{
 548                "count" => 1,
 549                "page_size" => 50,
 550                "users" => [
 551                  %{
 552                    "deactivated" => user.info.deactivated,
 553                    "id" => user.id,
 554                    "nickname" => user.nickname,
 555                    "roles" => %{"admin" => false, "moderator" => false},
 556                    "local" => true,
 557                    "tags" => []
 558                  }
 559                ]
 560              }
 561     end
 562
 563     test "search by email", %{conn: conn} do
 564       user = insert(:user, email: "email@example.com")
 565       insert(:user)
 566
 567       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 568
 569       assert json_response(conn, 200) == %{
 570                "count" => 1,
 571                "page_size" => 50,
 572                "users" => [
 573                  %{
 574                    "deactivated" => user.info.deactivated,
 575                    "id" => user.id,
 576                    "nickname" => user.nickname,
 577                    "roles" => %{"admin" => false, "moderator" => false},
 578                    "local" => true,
 579                    "tags" => []
 580                  }
 581                ]
 582              }
 583     end
 584
 585     test "regular search with page size", %{conn: conn} do
 586       user = insert(:user, nickname: "aalice")
 587       user2 = insert(:user, nickname: "alice")
 588
 589       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 590
 591       assert json_response(conn1, 200) == %{
 592                "count" => 2,
 593                "page_size" => 1,
 594                "users" => [
 595                  %{
 596                    "deactivated" => user.info.deactivated,
 597                    "id" => user.id,
 598                    "nickname" => user.nickname,
 599                    "roles" => %{"admin" => false, "moderator" => false},
 600                    "local" => true,
 601                    "tags" => []
 602                  }
 603                ]
 604              }
 605
 606       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 607
 608       assert json_response(conn2, 200) == %{
 609                "count" => 2,
 610                "page_size" => 1,
 611                "users" => [
 612                  %{
 613                    "deactivated" => user2.info.deactivated,
 614                    "id" => user2.id,
 615                    "nickname" => user2.nickname,
 616                    "roles" => %{"admin" => false, "moderator" => false},
 617                    "local" => true,
 618                    "tags" => []
 619                  }
 620                ]
 621              }
 622     end
 623
 624     test "only local users" do
 625       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 626       user = insert(:user, nickname: "bob")
 627
 628       insert(:user, nickname: "bobb", local: false)
 629
 630       conn =
 631         build_conn()
 632         |> assign(:user, admin)
 633         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 634
 635       assert json_response(conn, 200) == %{
 636                "count" => 1,
 637                "page_size" => 50,
 638                "users" => [
 639                  %{
 640                    "deactivated" => user.info.deactivated,
 641                    "id" => user.id,
 642                    "nickname" => user.nickname,
 643                    "roles" => %{"admin" => false, "moderator" => false},
 644                    "local" => true,
 645                    "tags" => []
 646                  }
 647                ]
 648              }
 649     end
 650
 651     test "only local users with no query", %{admin: old_admin} do
 652       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 653       user = insert(:user, nickname: "bob")
 654
 655       insert(:user, nickname: "bobb", local: false)
 656
 657       conn =
 658         build_conn()
 659         |> assign(:user, admin)
 660         |> get("/api/pleroma/admin/users?filters=local")
 661
 662       assert json_response(conn, 200) == %{
 663                "count" => 3,
 664                "page_size" => 50,
 665                "users" => [
 666                  %{
 667                    "deactivated" => user.info.deactivated,
 668                    "id" => user.id,
 669                    "nickname" => user.nickname,
 670                    "roles" => %{"admin" => false, "moderator" => false},
 671                    "local" => true,
 672                    "tags" => []
 673                  },
 674                  %{
 675                    "deactivated" => admin.info.deactivated,
 676                    "id" => admin.id,
 677                    "nickname" => admin.nickname,
 678                    "roles" => %{"admin" => true, "moderator" => false},
 679                    "local" => true,
 680                    "tags" => []
 681                  },
 682                  %{
 683                    "deactivated" => false,
 684                    "id" => old_admin.id,
 685                    "local" => true,
 686                    "nickname" => old_admin.nickname,
 687                    "roles" => %{"admin" => true, "moderator" => false},
 688                    "tags" => []
 689                  }
 690                ]
 691              }
 692     end
 693
 694     test "load only admins", %{conn: conn, admin: admin} do
 695       second_admin = insert(:user, info: %{is_admin: true})
 696       insert(:user)
 697       insert(:user)
 698
 699       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 700
 701       assert json_response(conn, 200) == %{
 702                "count" => 2,
 703                "page_size" => 50,
 704                "users" => [
 705                  %{
 706                    "deactivated" => false,
 707                    "id" => admin.id,
 708                    "nickname" => admin.nickname,
 709                    "roles" => %{"admin" => true, "moderator" => false},
 710                    "local" => admin.local,
 711                    "tags" => []
 712                  },
 713                  %{
 714                    "deactivated" => false,
 715                    "id" => second_admin.id,
 716                    "nickname" => second_admin.nickname,
 717                    "roles" => %{"admin" => true, "moderator" => false},
 718                    "local" => second_admin.local,
 719                    "tags" => []
 720                  }
 721                ]
 722              }
 723     end
 724
 725     test "load only moderators", %{conn: conn} do
 726       moderator = insert(:user, info: %{is_moderator: true})
 727       insert(:user)
 728       insert(:user)
 729
 730       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
 731
 732       assert json_response(conn, 200) == %{
 733                "count" => 1,
 734                "page_size" => 50,
 735                "users" => [
 736                  %{
 737                    "deactivated" => false,
 738                    "id" => moderator.id,
 739                    "nickname" => moderator.nickname,
 740                    "roles" => %{"admin" => false, "moderator" => true},
 741                    "local" => moderator.local,
 742                    "tags" => []
 743                  }
 744                ]
 745              }
 746     end
 747
 748     test "load users with tags list", %{conn: conn} do
 749       user1 = insert(:user, tags: ["first"])
 750       user2 = insert(:user, tags: ["second"])
 751       insert(:user)
 752       insert(:user)
 753
 754       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
 755
 756       assert json_response(conn, 200) == %{
 757                "count" => 2,
 758                "page_size" => 50,
 759                "users" => [
 760                  %{
 761                    "deactivated" => false,
 762                    "id" => user1.id,
 763                    "nickname" => user1.nickname,
 764                    "roles" => %{"admin" => false, "moderator" => false},
 765                    "local" => user1.local,
 766                    "tags" => ["first"]
 767                  },
 768                  %{
 769                    "deactivated" => false,
 770                    "id" => user2.id,
 771                    "nickname" => user2.nickname,
 772                    "roles" => %{"admin" => false, "moderator" => false},
 773                    "local" => user2.local,
 774                    "tags" => ["second"]
 775                  }
 776                ]
 777              }
 778     end
 779
 780     test "it works with multiple filters" do
 781       admin = insert(:user, nickname: "john", info: %{is_admin: true})
 782       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
 783
 784       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
 785       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
 786
 787       conn =
 788         build_conn()
 789         |> assign(:user, admin)
 790         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 791
 792       assert json_response(conn, 200) == %{
 793                "count" => 1,
 794                "page_size" => 50,
 795                "users" => [
 796                  %{
 797                    "deactivated" => user.info.deactivated,
 798                    "id" => user.id,
 799                    "nickname" => user.nickname,
 800                    "roles" => %{"admin" => false, "moderator" => false},
 801                    "local" => user.local,
 802                    "tags" => []
 803                  }
 804                ]
 805              }
 806     end
 807   end
 808
 809   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
 810     admin = insert(:user, info: %{is_admin: true})
 811     user = insert(:user)
 812
 813     conn =
 814       build_conn()
 815       |> assign(:user, admin)
 816       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 817
 818     assert json_response(conn, 200) ==
 819              %{
 820                "deactivated" => !user.info.deactivated,
 821                "id" => user.id,
 822                "nickname" => user.nickname,
 823                "roles" => %{"admin" => false, "moderator" => false},
 824                "local" => true,
 825                "tags" => []
 826              }
 827   end
 828
 829   describe "GET /api/pleroma/admin/users/invite_token" do
 830     setup do
 831       admin = insert(:user, info: %{is_admin: true})
 832
 833       conn =
 834         build_conn()
 835         |> assign(:user, admin)
 836
 837       {:ok, conn: conn}
 838     end
 839
 840     test "without options", %{conn: conn} do
 841       conn = get(conn, "/api/pleroma/admin/users/invite_token")
 842
 843       token = json_response(conn, 200)
 844       invite = UserInviteToken.find_by_token!(token)
 845       refute invite.used
 846       refute invite.expires_at
 847       refute invite.max_use
 848       assert invite.invite_type == "one_time"
 849     end
 850
 851     test "with expires_at", %{conn: conn} do
 852       conn =
 853         get(conn, "/api/pleroma/admin/users/invite_token", %{
 854           "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
 855         })
 856
 857       token = json_response(conn, 200)
 858       invite = UserInviteToken.find_by_token!(token)
 859
 860       refute invite.used
 861       assert invite.expires_at == Date.utc_today()
 862       refute invite.max_use
 863       assert invite.invite_type == "date_limited"
 864     end
 865
 866     test "with max_use", %{conn: conn} do
 867       conn =
 868         get(conn, "/api/pleroma/admin/users/invite_token", %{
 869           "invite" => %{"max_use" => 150}
 870         })
 871
 872       token = json_response(conn, 200)
 873       invite = UserInviteToken.find_by_token!(token)
 874       refute invite.used
 875       refute invite.expires_at
 876       assert invite.max_use == 150
 877       assert invite.invite_type == "reusable"
 878     end
 879
 880     test "with max use and expires_at", %{conn: conn} do
 881       conn =
 882         get(conn, "/api/pleroma/admin/users/invite_token", %{
 883           "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
 884         })
 885
 886       token = json_response(conn, 200)
 887       invite = UserInviteToken.find_by_token!(token)
 888       refute invite.used
 889       assert invite.expires_at == Date.utc_today()
 890       assert invite.max_use == 150
 891       assert invite.invite_type == "reusable_date_limited"
 892     end
 893   end
 894
 895   describe "GET /api/pleroma/admin/users/invites" do
 896     setup do
 897       admin = insert(:user, info: %{is_admin: true})
 898
 899       conn =
 900         build_conn()
 901         |> assign(:user, admin)
 902
 903       {:ok, conn: conn}
 904     end
 905
 906     test "no invites", %{conn: conn} do
 907       conn = get(conn, "/api/pleroma/admin/users/invites")
 908
 909       assert json_response(conn, 200) == %{"invites" => []}
 910     end
 911
 912     test "with invite", %{conn: conn} do
 913       {:ok, invite} = UserInviteToken.create_invite()
 914
 915       conn = get(conn, "/api/pleroma/admin/users/invites")
 916
 917       assert json_response(conn, 200) == %{
 918                "invites" => [
 919                  %{
 920                    "expires_at" => nil,
 921                    "id" => invite.id,
 922                    "invite_type" => "one_time",
 923                    "max_use" => nil,
 924                    "token" => invite.token,
 925                    "used" => false,
 926                    "uses" => 0
 927                  }
 928                ]
 929              }
 930     end
 931   end
 932
 933   describe "POST /api/pleroma/admin/users/revoke_invite" do
 934     test "with token" do
 935       admin = insert(:user, info: %{is_admin: true})
 936       {:ok, invite} = UserInviteToken.create_invite()
 937
 938       conn =
 939         build_conn()
 940         |> assign(:user, admin)
 941         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
 942
 943       assert json_response(conn, 200) == %{
 944                "expires_at" => nil,
 945                "id" => invite.id,
 946                "invite_type" => "one_time",
 947                "max_use" => nil,
 948                "token" => invite.token,
 949                "used" => true,
 950                "uses" => 0
 951              }
 952     end
 953   end
 954
 955   describe "GET /api/pleroma/admin/reports/:id" do
 956     setup %{conn: conn} do
 957       admin = insert(:user, info: %{is_admin: true})
 958
 959       %{conn: assign(conn, :user, admin)}
 960     end
 961
 962     test "returns report by its id", %{conn: conn} do
 963       [reporter, target_user] = insert_pair(:user)
 964       activity = insert(:note_activity, user: target_user)
 965
 966       {:ok, %{id: report_id}} =
 967         CommonAPI.report(reporter, %{
 968           "account_id" => target_user.id,
 969           "comment" => "I feel offended",
 970           "status_ids" => [activity.id]
 971         })
 972
 973       response =
 974         conn
 975         |> get("/api/pleroma/admin/reports/#{report_id}")
 976         |> json_response(:ok)
 977
 978       assert response["id"] == report_id
 979     end
 980
 981     test "returns 404 when report id is invalid", %{conn: conn} do
 982       conn = get(conn, "/api/pleroma/admin/reports/test")
 983
 984       assert json_response(conn, :not_found) == "Not found"
 985     end
 986   end
 987
 988   describe "PUT /api/pleroma/admin/reports/:id" do
 989     setup %{conn: conn} do
 990       admin = insert(:user, info: %{is_admin: true})
 991       [reporter, target_user] = insert_pair(:user)
 992       activity = insert(:note_activity, user: target_user)
 993
 994       {:ok, %{id: report_id}} =
 995         CommonAPI.report(reporter, %{
 996           "account_id" => target_user.id,
 997           "comment" => "I feel offended",
 998           "status_ids" => [activity.id]
 999         })
1000
1001       %{conn: assign(conn, :user, admin), id: report_id}
1002     end
1003
1004     test "mark report as resolved", %{conn: conn, id: id} do
1005       response =
1006         conn
1007         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
1008         |> json_response(:ok)
1009
1010       assert response["state"] == "resolved"
1011     end
1012
1013     test "closes report", %{conn: conn, id: id} do
1014       response =
1015         conn
1016         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
1017         |> json_response(:ok)
1018
1019       assert response["state"] == "closed"
1020     end
1021
1022     test "returns 400 when state is unknown", %{conn: conn, id: id} do
1023       conn =
1024         conn
1025         |> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})
1026
1027       assert json_response(conn, :bad_request) == "Unsupported state"
1028     end
1029
1030     test "returns 404 when report is not exist", %{conn: conn} do
1031       conn =
1032         conn
1033         |> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})
1034
1035       assert json_response(conn, :not_found) == "Not found"
1036     end
1037   end
1038
1039   describe "GET /api/pleroma/admin/reports" do
1040     setup %{conn: conn} do
1041       admin = insert(:user, info: %{is_admin: true})
1042
1043       %{conn: assign(conn, :user, admin)}
1044     end
1045
1046     test "returns empty response when no reports created", %{conn: conn} do
1047       response =
1048         conn
1049         |> get("/api/pleroma/admin/reports")
1050         |> json_response(:ok)
1051
1052       assert Enum.empty?(response["reports"])
1053     end
1054
1055     test "returns reports", %{conn: conn} do
1056       [reporter, target_user] = insert_pair(:user)
1057       activity = insert(:note_activity, user: target_user)
1058
1059       {:ok, %{id: report_id}} =
1060         CommonAPI.report(reporter, %{
1061           "account_id" => target_user.id,
1062           "comment" => "I feel offended",
1063           "status_ids" => [activity.id]
1064         })
1065
1066       response =
1067         conn
1068         |> get("/api/pleroma/admin/reports")
1069         |> json_response(:ok)
1070
1071       [report] = response["reports"]
1072
1073       assert length(response["reports"]) == 1
1074       assert report["id"] == report_id
1075     end
1076
1077     test "returns reports with specified state", %{conn: conn} do
1078       [reporter, target_user] = insert_pair(:user)
1079       activity = insert(:note_activity, user: target_user)
1080
1081       {:ok, %{id: first_report_id}} =
1082         CommonAPI.report(reporter, %{
1083           "account_id" => target_user.id,
1084           "comment" => "I feel offended",
1085           "status_ids" => [activity.id]
1086         })
1087
1088       {:ok, %{id: second_report_id}} =
1089         CommonAPI.report(reporter, %{
1090           "account_id" => target_user.id,
1091           "comment" => "I don't like this user"
1092         })
1093
1094       CommonAPI.update_report_state(second_report_id, "closed")
1095
1096       response =
1097         conn
1098         |> get("/api/pleroma/admin/reports", %{
1099           "state" => "open"
1100         })
1101         |> json_response(:ok)
1102
1103       [open_report] = response["reports"]
1104
1105       assert length(response["reports"]) == 1
1106       assert open_report["id"] == first_report_id
1107
1108       response =
1109         conn
1110         |> get("/api/pleroma/admin/reports", %{
1111           "state" => "closed"
1112         })
1113         |> json_response(:ok)
1114
1115       [closed_report] = response["reports"]
1116
1117       assert length(response["reports"]) == 1
1118       assert closed_report["id"] == second_report_id
1119
1120       response =
1121         conn
1122         |> get("/api/pleroma/admin/reports", %{
1123           "state" => "resolved"
1124         })
1125         |> json_response(:ok)
1126
1127       assert Enum.empty?(response["reports"])
1128     end
1129
1130     test "returns 403 when requested by a non-admin" do
1131       user = insert(:user)
1132
1133       conn =
1134         build_conn()
1135         |> assign(:user, user)
1136         |> get("/api/pleroma/admin/reports")
1137
1138       assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
1139     end
1140
1141     test "returns 403 when requested by anonymous" do
1142       conn =
1143         build_conn()
1144         |> get("/api/pleroma/admin/reports")
1145
1146       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
1147     end
1148   end
1149
1150   describe "POST /api/pleroma/admin/reports/:id/respond" do
1151     setup %{conn: conn} do
1152       admin = insert(:user, info: %{is_admin: true})
1153
1154       %{conn: assign(conn, :user, admin)}
1155     end
1156
1157     test "returns created dm", %{conn: conn} do
1158       [reporter, target_user] = insert_pair(:user)
1159       activity = insert(:note_activity, user: target_user)
1160
1161       {:ok, %{id: report_id}} =
1162         CommonAPI.report(reporter, %{
1163           "account_id" => target_user.id,
1164           "comment" => "I feel offended",
1165           "status_ids" => [activity.id]
1166         })
1167
1168       response =
1169         conn
1170         |> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
1171           "status" => "I will check it out"
1172         })
1173         |> json_response(:ok)
1174
1175       recipients = Enum.map(response["mentions"], & &1["username"])
1176
1177       assert conn.assigns[:user].nickname in recipients
1178       assert reporter.nickname in recipients
1179       assert response["content"] == "I will check it out"
1180       assert response["visibility"] == "direct"
1181     end
1182
1183     test "returns 400 when status is missing", %{conn: conn} do
1184       conn = post(conn, "/api/pleroma/admin/reports/test/respond")
1185
1186       assert json_response(conn, :bad_request) == "Invalid parameters"
1187     end
1188
1189     test "returns 404 when report id is invalid", %{conn: conn} do
1190       conn =
1191         post(conn, "/api/pleroma/admin/reports/test/respond", %{
1192           "status" => "foo"
1193         })
1194
1195       assert json_response(conn, :not_found) == "Not found"
1196     end
1197   end
1198
1199   describe "PUT /api/pleroma/admin/statuses/:id" do
1200     setup %{conn: conn} do
1201       admin = insert(:user, info: %{is_admin: true})
1202       activity = insert(:note_activity)
1203
1204       %{conn: assign(conn, :user, admin), id: activity.id}
1205     end
1206
1207     test "toggle sensitive flag", %{conn: conn, id: id} do
1208       response =
1209         conn
1210         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
1211         |> json_response(:ok)
1212
1213       assert response["sensitive"]
1214
1215       response =
1216         conn
1217         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
1218         |> json_response(:ok)
1219
1220       refute response["sensitive"]
1221     end
1222
1223     test "change visibility flag", %{conn: conn, id: id} do
1224       response =
1225         conn
1226         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
1227         |> json_response(:ok)
1228
1229       assert response["visibility"] == "public"
1230
1231       response =
1232         conn
1233         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
1234         |> json_response(:ok)
1235
1236       assert response["visibility"] == "private"
1237
1238       response =
1239         conn
1240         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
1241         |> json_response(:ok)
1242
1243       assert response["visibility"] == "unlisted"
1244     end
1245
1246     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
1247       conn =
1248         conn
1249         |> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})
1250
1251       assert json_response(conn, :bad_request) == "Unsupported visibility"
1252     end
1253   end
1254
1255   describe "DELETE /api/pleroma/admin/statuses/:id" do
1256     setup %{conn: conn} do
1257       admin = insert(:user, info: %{is_admin: true})
1258       activity = insert(:note_activity)
1259
1260       %{conn: assign(conn, :user, admin), id: activity.id}
1261     end
1262
1263     test "deletes status", %{conn: conn, id: id} do
1264       conn
1265       |> delete("/api/pleroma/admin/statuses/#{id}")
1266       |> json_response(:ok)
1267
1268       refute Activity.get_by_id(id)
1269     end
1270
1271     test "returns error when status is not exist", %{conn: conn} do
1272       conn =
1273         conn
1274         |> delete("/api/pleroma/admin/statuses/test")
1275
1276       assert json_response(conn, :bad_request) == "Could not delete"
1277     end
1278   end
1279 end