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