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           "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/users/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/users/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/users/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/users/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/users/:nickname/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/users/#{admin.nickname}/permission_group/")
 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/users/#{user.nickname}/permission_group/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/users/#{user.nickname}/permission_group/admin")
 234
 235       assert json_response(conn, 200) == %{
 236                "is_admin" => false
 237              }
 238     end
 239   end
 240
 241   describe "PUT /api/pleroma/admin/users/:nickname/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/users/#{user.nickname}/activation_status", %{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/users/#{user.nickname}/activation_status", %{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/users/#{user.nickname}/activation_status", %{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(
 313           "/api/pleroma/admin/users/email_invite?email=#{recipient_email}&name=#{recipient_name}"
 314         )
 315
 316       assert json_response(conn, :no_content)
 317
 318       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 319       assert token_record
 320       refute token_record.used
 321
 322       notify_email = Pleroma.Config.get([:instance, :notify_email])
 323       instance_name = Pleroma.Config.get([:instance, :name])
 324
 325       email =
 326         Pleroma.Emails.UserEmail.user_invitation_email(
 327           user,
 328           token_record,
 329           recipient_email,
 330           recipient_name
 331         )
 332
 333       Swoosh.TestAssertions.assert_email_sent(
 334         from: {instance_name, notify_email},
 335         to: {recipient_name, recipient_email},
 336         html_body: email.html_body
 337       )
 338     end
 339
 340     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 341       non_admin_user = insert(:user)
 342
 343       conn =
 344         conn
 345         |> assign(:user, non_admin_user)
 346         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 347
 348       assert json_response(conn, :forbidden)
 349     end
 350   end
 351
 352   describe "POST /api/pleroma/admin/users/email_invite, with invalid config" do
 353     setup do
 354       [user: insert(:user, info: %{is_admin: true})]
 355     end
 356
 357     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 358       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 359       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 360       Pleroma.Config.put([:instance, :registrations_open], false)
 361       Pleroma.Config.put([:instance, :invites_enabled], false)
 362
 363       on_exit(fn ->
 364         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 365         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 366         :ok
 367       end)
 368
 369       conn =
 370         conn
 371         |> assign(:user, user)
 372         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 373
 374       assert json_response(conn, :internal_server_error)
 375     end
 376
 377     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 378       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 379       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 380       Pleroma.Config.put([:instance, :registrations_open], true)
 381       Pleroma.Config.put([:instance, :invites_enabled], true)
 382
 383       on_exit(fn ->
 384         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 385         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 386         :ok
 387       end)
 388
 389       conn =
 390         conn
 391         |> assign(:user, user)
 392         |> post("/api/pleroma/admin/users/email_invite?email=foo@bar.com&name=JD")
 393
 394       assert json_response(conn, :internal_server_error)
 395     end
 396   end
 397
 398   test "/api/pleroma/admin/invite_token" do
 399     admin = insert(:user, info: %{is_admin: true})
 400
 401     conn =
 402       build_conn()
 403       |> assign(:user, admin)
 404       |> put_req_header("accept", "application/json")
 405       |> get("/api/pleroma/admin/invite_token")
 406
 407     assert conn.status == 200
 408   end
 409
 410   test "/api/pleroma/admin/users/:nickname/password_reset" do
 411     admin = insert(:user, info: %{is_admin: true})
 412     user = insert(:user)
 413
 414     conn =
 415       build_conn()
 416       |> assign(:user, admin)
 417       |> put_req_header("accept", "application/json")
 418       |> get("/api/pleroma/admin/users/#{user.nickname}/password_reset")
 419
 420     assert conn.status == 200
 421   end
 422
 423   describe "GET /api/pleroma/admin/users" do
 424     setup do
 425       admin = insert(:user, info: %{is_admin: true})
 426
 427       conn =
 428         build_conn()
 429         |> assign(:user, admin)
 430
 431       {:ok, conn: conn, admin: admin}
 432     end
 433
 434     test "renders users array for the first page", %{conn: conn, admin: admin} do
 435       user = insert(:user, local: false, tags: ["foo", "bar"])
 436       conn = get(conn, "/api/pleroma/admin/users?page=1")
 437
 438       assert json_response(conn, 200) == %{
 439                "count" => 2,
 440                "page_size" => 50,
 441                "users" => [
 442                  %{
 443                    "deactivated" => admin.info.deactivated,
 444                    "id" => admin.id,
 445                    "nickname" => admin.nickname,
 446                    "roles" => %{"admin" => true, "moderator" => false},
 447                    "local" => true,
 448                    "tags" => []
 449                  },
 450                  %{
 451                    "deactivated" => user.info.deactivated,
 452                    "id" => user.id,
 453                    "nickname" => user.nickname,
 454                    "roles" => %{"admin" => false, "moderator" => false},
 455                    "local" => false,
 456                    "tags" => ["foo", "bar"]
 457                  }
 458                ]
 459              }
 460     end
 461
 462     test "renders empty array for the second page", %{conn: conn} do
 463       insert(:user)
 464
 465       conn = get(conn, "/api/pleroma/admin/users?page=2")
 466
 467       assert json_response(conn, 200) == %{
 468                "count" => 2,
 469                "page_size" => 50,
 470                "users" => []
 471              }
 472     end
 473
 474     test "regular search", %{conn: conn} do
 475       user = insert(:user, nickname: "bob")
 476
 477       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 478
 479       assert json_response(conn, 200) == %{
 480                "count" => 1,
 481                "page_size" => 50,
 482                "users" => [
 483                  %{
 484                    "deactivated" => user.info.deactivated,
 485                    "id" => user.id,
 486                    "nickname" => user.nickname,
 487                    "roles" => %{"admin" => false, "moderator" => false},
 488                    "local" => true,
 489                    "tags" => []
 490                  }
 491                ]
 492              }
 493     end
 494
 495     test "search by domain", %{conn: conn} do
 496       user = insert(:user, nickname: "nickname@domain.com")
 497       insert(:user)
 498
 499       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 500
 501       assert json_response(conn, 200) == %{
 502                "count" => 1,
 503                "page_size" => 50,
 504                "users" => [
 505                  %{
 506                    "deactivated" => user.info.deactivated,
 507                    "id" => user.id,
 508                    "nickname" => user.nickname,
 509                    "roles" => %{"admin" => false, "moderator" => false},
 510                    "local" => true,
 511                    "tags" => []
 512                  }
 513                ]
 514              }
 515     end
 516
 517     test "search by full nickname", %{conn: conn} do
 518       user = insert(:user, nickname: "nickname@domain.com")
 519       insert(:user)
 520
 521       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 522
 523       assert json_response(conn, 200) == %{
 524                "count" => 1,
 525                "page_size" => 50,
 526                "users" => [
 527                  %{
 528                    "deactivated" => user.info.deactivated,
 529                    "id" => user.id,
 530                    "nickname" => user.nickname,
 531                    "roles" => %{"admin" => false, "moderator" => false},
 532                    "local" => true,
 533                    "tags" => []
 534                  }
 535                ]
 536              }
 537     end
 538
 539     test "search by display name", %{conn: conn} do
 540       user = insert(:user, name: "Display name")
 541       insert(:user)
 542
 543       conn = get(conn, "/api/pleroma/admin/users?name=display")
 544
 545       assert json_response(conn, 200) == %{
 546                "count" => 1,
 547                "page_size" => 50,
 548                "users" => [
 549                  %{
 550                    "deactivated" => user.info.deactivated,
 551                    "id" => user.id,
 552                    "nickname" => user.nickname,
 553                    "roles" => %{"admin" => false, "moderator" => false},
 554                    "local" => true,
 555                    "tags" => []
 556                  }
 557                ]
 558              }
 559     end
 560
 561     test "search by email", %{conn: conn} do
 562       user = insert(:user, email: "email@example.com")
 563       insert(:user)
 564
 565       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 566
 567       assert json_response(conn, 200) == %{
 568                "count" => 1,
 569                "page_size" => 50,
 570                "users" => [
 571                  %{
 572                    "deactivated" => user.info.deactivated,
 573                    "id" => user.id,
 574                    "nickname" => user.nickname,
 575                    "roles" => %{"admin" => false, "moderator" => false},
 576                    "local" => true,
 577                    "tags" => []
 578                  }
 579                ]
 580              }
 581     end
 582
 583     test "regular search with page size", %{conn: conn} do
 584       user = insert(:user, nickname: "aalice")
 585       user2 = insert(:user, nickname: "alice")
 586
 587       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 588
 589       assert json_response(conn1, 200) == %{
 590                "count" => 2,
 591                "page_size" => 1,
 592                "users" => [
 593                  %{
 594                    "deactivated" => user.info.deactivated,
 595                    "id" => user.id,
 596                    "nickname" => user.nickname,
 597                    "roles" => %{"admin" => false, "moderator" => false},
 598                    "local" => true,
 599                    "tags" => []
 600                  }
 601                ]
 602              }
 603
 604       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 605
 606       assert json_response(conn2, 200) == %{
 607                "count" => 2,
 608                "page_size" => 1,
 609                "users" => [
 610                  %{
 611                    "deactivated" => user2.info.deactivated,
 612                    "id" => user2.id,
 613                    "nickname" => user2.nickname,
 614                    "roles" => %{"admin" => false, "moderator" => false},
 615                    "local" => true,
 616                    "tags" => []
 617                  }
 618                ]
 619              }
 620     end
 621
 622     test "only local users" do
 623       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 624       user = insert(:user, nickname: "bob")
 625
 626       insert(:user, nickname: "bobb", local: false)
 627
 628       conn =
 629         build_conn()
 630         |> assign(:user, admin)
 631         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 632
 633       assert json_response(conn, 200) == %{
 634                "count" => 1,
 635                "page_size" => 50,
 636                "users" => [
 637                  %{
 638                    "deactivated" => user.info.deactivated,
 639                    "id" => user.id,
 640                    "nickname" => user.nickname,
 641                    "roles" => %{"admin" => false, "moderator" => false},
 642                    "local" => true,
 643                    "tags" => []
 644                  }
 645                ]
 646              }
 647     end
 648
 649     test "only local users with no query", %{admin: old_admin} do
 650       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 651       user = insert(:user, nickname: "bob")
 652
 653       insert(:user, nickname: "bobb", local: false)
 654
 655       conn =
 656         build_conn()
 657         |> assign(:user, admin)
 658         |> get("/api/pleroma/admin/users?filters=local")
 659
 660       assert json_response(conn, 200) == %{
 661                "count" => 3,
 662                "page_size" => 50,
 663                "users" => [
 664                  %{
 665                    "deactivated" => user.info.deactivated,
 666                    "id" => user.id,
 667                    "nickname" => user.nickname,
 668                    "roles" => %{"admin" => false, "moderator" => false},
 669                    "local" => true,
 670                    "tags" => []
 671                  },
 672                  %{
 673                    "deactivated" => admin.info.deactivated,
 674                    "id" => admin.id,
 675                    "nickname" => admin.nickname,
 676                    "roles" => %{"admin" => true, "moderator" => false},
 677                    "local" => true,
 678                    "tags" => []
 679                  },
 680                  %{
 681                    "deactivated" => false,
 682                    "id" => old_admin.id,
 683                    "local" => true,
 684                    "nickname" => old_admin.nickname,
 685                    "roles" => %{"admin" => true, "moderator" => false},
 686                    "tags" => []
 687                  }
 688                ]
 689              }
 690     end
 691
 692     test "load only admins", %{conn: conn, admin: admin} do
 693       second_admin = insert(:user, info: %{is_admin: true})
 694       insert(:user)
 695       insert(:user)
 696
 697       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 698
 699       assert json_response(conn, 200) == %{
 700                "count" => 2,
 701                "page_size" => 50,
 702                "users" => [
 703                  %{
 704                    "deactivated" => false,
 705                    "id" => admin.id,
 706                    "nickname" => admin.nickname,
 707                    "roles" => %{"admin" => true, "moderator" => false},
 708                    "local" => admin.local,
 709                    "tags" => []
 710                  },
 711                  %{
 712                    "deactivated" => false,
 713                    "id" => second_admin.id,
 714                    "nickname" => second_admin.nickname,
 715                    "roles" => %{"admin" => true, "moderator" => false},
 716                    "local" => second_admin.local,
 717                    "tags" => []
 718                  }
 719                ]
 720              }
 721     end
 722
 723     test "load only moderators", %{conn: conn} do
 724       moderator = insert(:user, info: %{is_moderator: true})
 725       insert(:user)
 726       insert(:user)
 727
 728       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
 729
 730       assert json_response(conn, 200) == %{
 731                "count" => 1,
 732                "page_size" => 50,
 733                "users" => [
 734                  %{
 735                    "deactivated" => false,
 736                    "id" => moderator.id,
 737                    "nickname" => moderator.nickname,
 738                    "roles" => %{"admin" => false, "moderator" => true},
 739                    "local" => moderator.local,
 740                    "tags" => []
 741                  }
 742                ]
 743              }
 744     end
 745
 746     test "load users with tags list", %{conn: conn} do
 747       user1 = insert(:user, tags: ["first"])
 748       user2 = insert(:user, tags: ["second"])
 749       insert(:user)
 750       insert(:user)
 751
 752       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
 753
 754       assert json_response(conn, 200) == %{
 755                "count" => 2,
 756                "page_size" => 50,
 757                "users" => [
 758                  %{
 759                    "deactivated" => false,
 760                    "id" => user1.id,
 761                    "nickname" => user1.nickname,
 762                    "roles" => %{"admin" => false, "moderator" => false},
 763                    "local" => user1.local,
 764                    "tags" => ["first"]
 765                  },
 766                  %{
 767                    "deactivated" => false,
 768                    "id" => user2.id,
 769                    "nickname" => user2.nickname,
 770                    "roles" => %{"admin" => false, "moderator" => false},
 771                    "local" => user2.local,
 772                    "tags" => ["second"]
 773                  }
 774                ]
 775              }
 776     end
 777
 778     test "it works with multiple filters" do
 779       admin = insert(:user, nickname: "john", info: %{is_admin: true})
 780       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
 781
 782       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
 783       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
 784
 785       conn =
 786         build_conn()
 787         |> assign(:user, admin)
 788         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 789
 790       assert json_response(conn, 200) == %{
 791                "count" => 1,
 792                "page_size" => 50,
 793                "users" => [
 794                  %{
 795                    "deactivated" => user.info.deactivated,
 796                    "id" => user.id,
 797                    "nickname" => user.nickname,
 798                    "roles" => %{"admin" => false, "moderator" => false},
 799                    "local" => user.local,
 800                    "tags" => []
 801                  }
 802                ]
 803              }
 804     end
 805   end
 806
 807   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
 808     admin = insert(:user, info: %{is_admin: true})
 809     user = insert(:user)
 810
 811     conn =
 812       build_conn()
 813       |> assign(:user, admin)
 814       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 815
 816     assert json_response(conn, 200) ==
 817              %{
 818                "deactivated" => !user.info.deactivated,
 819                "id" => user.id,
 820                "nickname" => user.nickname,
 821                "roles" => %{"admin" => false, "moderator" => false},
 822                "local" => true,
 823                "tags" => []
 824              }
 825   end
 826
 827   describe "GET /api/pleroma/admin/users/invite_token" do
 828     setup do
 829       admin = insert(:user, info: %{is_admin: true})
 830
 831       conn =
 832         build_conn()
 833         |> assign(:user, admin)
 834
 835       {:ok, conn: conn}
 836     end
 837
 838     test "without options", %{conn: conn} do
 839       conn = get(conn, "/api/pleroma/admin/users/invite_token")
 840
 841       token = json_response(conn, 200)
 842       invite = UserInviteToken.find_by_token!(token)
 843       refute invite.used
 844       refute invite.expires_at
 845       refute invite.max_use
 846       assert invite.invite_type == "one_time"
 847     end
 848
 849     test "with expires_at", %{conn: conn} do
 850       conn =
 851         get(conn, "/api/pleroma/admin/users/invite_token", %{
 852           "invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
 853         })
 854
 855       token = json_response(conn, 200)
 856       invite = UserInviteToken.find_by_token!(token)
 857
 858       refute invite.used
 859       assert invite.expires_at == Date.utc_today()
 860       refute invite.max_use
 861       assert invite.invite_type == "date_limited"
 862     end
 863
 864     test "with max_use", %{conn: conn} do
 865       conn =
 866         get(conn, "/api/pleroma/admin/users/invite_token", %{
 867           "invite" => %{"max_use" => 150}
 868         })
 869
 870       token = json_response(conn, 200)
 871       invite = UserInviteToken.find_by_token!(token)
 872       refute invite.used
 873       refute invite.expires_at
 874       assert invite.max_use == 150
 875       assert invite.invite_type == "reusable"
 876     end
 877
 878     test "with max use and expires_at", %{conn: conn} do
 879       conn =
 880         get(conn, "/api/pleroma/admin/users/invite_token", %{
 881           "invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
 882         })
 883
 884       token = json_response(conn, 200)
 885       invite = UserInviteToken.find_by_token!(token)
 886       refute invite.used
 887       assert invite.expires_at == Date.utc_today()
 888       assert invite.max_use == 150
 889       assert invite.invite_type == "reusable_date_limited"
 890     end
 891   end
 892
 893   describe "GET /api/pleroma/admin/users/invites" do
 894     setup do
 895       admin = insert(:user, info: %{is_admin: true})
 896
 897       conn =
 898         build_conn()
 899         |> assign(:user, admin)
 900
 901       {:ok, conn: conn}
 902     end
 903
 904     test "no invites", %{conn: conn} do
 905       conn = get(conn, "/api/pleroma/admin/users/invites")
 906
 907       assert json_response(conn, 200) == %{"invites" => []}
 908     end
 909
 910     test "with invite", %{conn: conn} do
 911       {:ok, invite} = UserInviteToken.create_invite()
 912
 913       conn = get(conn, "/api/pleroma/admin/users/invites")
 914
 915       assert json_response(conn, 200) == %{
 916                "invites" => [
 917                  %{
 918                    "expires_at" => nil,
 919                    "id" => invite.id,
 920                    "invite_type" => "one_time",
 921                    "max_use" => nil,
 922                    "token" => invite.token,
 923                    "used" => false,
 924                    "uses" => 0
 925                  }
 926                ]
 927              }
 928     end
 929   end
 930
 931   describe "POST /api/pleroma/admin/users/revoke_invite" do
 932     test "with token" do
 933       admin = insert(:user, info: %{is_admin: true})
 934       {:ok, invite} = UserInviteToken.create_invite()
 935
 936       conn =
 937         build_conn()
 938         |> assign(:user, admin)
 939         |> post("/api/pleroma/admin/users/revoke_invite", %{"token" => invite.token})
 940
 941       assert json_response(conn, 200) == %{
 942                "expires_at" => nil,
 943                "id" => invite.id,
 944                "invite_type" => "one_time",
 945                "max_use" => nil,
 946                "token" => invite.token,
 947                "used" => true,
 948                "uses" => 0
 949              }
 950     end
 951   end
 952 end