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