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