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