git.squeep.com Git - akkoma/blob - test/pleroma/web/admin_api/controllers/user_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.UserControllerTest do
   6   use Pleroma.Web.ConnCase
   7   use Oban.Testing, repo: Pleroma.Repo
   8
   9   import Mock
  10   import Pleroma.Factory
  11
  12   alias Pleroma.Config
  13   alias Pleroma.HTML
  14   alias Pleroma.ModerationLog
  15   alias Pleroma.Repo
  16   alias Pleroma.Tests.ObanHelpers
  17   alias Pleroma.User
  18   alias Pleroma.Web
  19   alias Pleroma.Web.ActivityPub.Relay
  20   alias Pleroma.Web.CommonAPI
  21   alias Pleroma.Web.MediaProxy
  22
  23   setup_all do
  24     Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
  25
  26     :ok
  27   end
  28
  29   setup do
  30     admin = insert(:user, is_admin: true)
  31     token = insert(:oauth_admin_token, user: admin)
  32
  33     conn =
  34       build_conn()
  35       |> assign(:user, admin)
  36       |> assign(:token, token)
  37
  38     {:ok, %{admin: admin, token: token, conn: conn}}
  39   end
  40
  41   test "with valid `admin_token` query parameter, skips OAuth scopes check" do
  42     clear_config([:admin_token], "password123")
  43
  44     user = insert(:user)
  45
  46     conn = get(build_conn(), "/api/pleroma/admin/users/#{user.nickname}?admin_token=password123")
  47
  48     assert json_response(conn, 200)
  49   end
  50
  51   describe "with [:auth, :enforce_oauth_admin_scope_usage]," do
  52     setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], true)
  53
  54     test "GET /api/pleroma/admin/users/:nickname requires admin:read:accounts or broader scope",
  55          %{admin: admin} do
  56       user = insert(:user)
  57       url = "/api/pleroma/admin/users/#{user.nickname}"
  58
  59       good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
  60       good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
  61       good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
  62
  63       bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
  64       bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
  65       bad_token3 = nil
  66
  67       for good_token <- [good_token1, good_token2, good_token3] do
  68         conn =
  69           build_conn()
  70           |> assign(:user, admin)
  71           |> assign(:token, good_token)
  72           |> get(url)
  73
  74         assert json_response(conn, 200)
  75       end
  76
  77       for good_token <- [good_token1, good_token2, good_token3] do
  78         conn =
  79           build_conn()
  80           |> assign(:user, nil)
  81           |> assign(:token, good_token)
  82           |> get(url)
  83
  84         assert json_response(conn, :forbidden)
  85       end
  86
  87       for bad_token <- [bad_token1, bad_token2, bad_token3] do
  88         conn =
  89           build_conn()
  90           |> assign(:user, admin)
  91           |> assign(:token, bad_token)
  92           |> get(url)
  93
  94         assert json_response(conn, :forbidden)
  95       end
  96     end
  97   end
  98
  99   describe "unless [:auth, :enforce_oauth_admin_scope_usage]," do
 100     setup do: clear_config([:auth, :enforce_oauth_admin_scope_usage], false)
 101
 102     test "GET /api/pleroma/admin/users/:nickname requires " <>
 103            "read:accounts or admin:read:accounts or broader scope",
 104          %{admin: admin} do
 105       user = insert(:user)
 106       url = "/api/pleroma/admin/users/#{user.nickname}"
 107
 108       good_token1 = insert(:oauth_token, user: admin, scopes: ["admin"])
 109       good_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read"])
 110       good_token3 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts"])
 111       good_token4 = insert(:oauth_token, user: admin, scopes: ["read:accounts"])
 112       good_token5 = insert(:oauth_token, user: admin, scopes: ["read"])
 113
 114       good_tokens = [good_token1, good_token2, good_token3, good_token4, good_token5]
 115
 116       bad_token1 = insert(:oauth_token, user: admin, scopes: ["read:accounts:partial"])
 117       bad_token2 = insert(:oauth_token, user: admin, scopes: ["admin:read:accounts:partial"])
 118       bad_token3 = nil
 119
 120       for good_token <- good_tokens do
 121         conn =
 122           build_conn()
 123           |> assign(:user, admin)
 124           |> assign(:token, good_token)
 125           |> get(url)
 126
 127         assert json_response(conn, 200)
 128       end
 129
 130       for good_token <- good_tokens do
 131         conn =
 132           build_conn()
 133           |> assign(:user, nil)
 134           |> assign(:token, good_token)
 135           |> get(url)
 136
 137         assert json_response(conn, :forbidden)
 138       end
 139
 140       for bad_token <- [bad_token1, bad_token2, bad_token3] do
 141         conn =
 142           build_conn()
 143           |> assign(:user, admin)
 144           |> assign(:token, bad_token)
 145           |> get(url)
 146
 147         assert json_response(conn, :forbidden)
 148       end
 149     end
 150   end
 151
 152   describe "DELETE /api/pleroma/admin/users" do
 153     test "single user", %{admin: admin, conn: conn} do
 154       clear_config([:instance, :federating], true)
 155
 156       user =
 157         insert(:user,
 158           avatar: %{"url" => [%{"href" => "https://someurl"}]},
 159           banner: %{"url" => [%{"href" => "https://somebanner"}]},
 160           bio: "Hello world!",
 161           name: "A guy"
 162         )
 163
 164       # Create some activities to check they got deleted later
 165       follower = insert(:user)
 166       {:ok, _} = CommonAPI.post(user, %{status: "test"})
 167       {:ok, _, _, _} = CommonAPI.follow(user, follower)
 168       {:ok, _, _, _} = CommonAPI.follow(follower, user)
 169       user = Repo.get(User, user.id)
 170       assert user.note_count == 1
 171       assert user.follower_count == 1
 172       assert user.following_count == 1
 173       refute user.deactivated
 174
 175       with_mock Pleroma.Web.Federator,
 176         publish: fn _ -> nil end,
 177         perform: fn _, _ -> nil end do
 178         conn =
 179           conn
 180           |> put_req_header("accept", "application/json")
 181           |> delete("/api/pleroma/admin/users?nickname=#{user.nickname}")
 182
 183         ObanHelpers.perform_all()
 184
 185         assert User.get_by_nickname(user.nickname).deactivated
 186
 187         log_entry = Repo.one(ModerationLog)
 188
 189         assert ModerationLog.get_log_entry_message(log_entry) ==
 190                  "@#{admin.nickname} deleted users: @#{user.nickname}"
 191
 192         assert json_response(conn, 200) == [user.nickname]
 193
 194         user = Repo.get(User, user.id)
 195         assert user.deactivated
 196
 197         assert user.avatar == %{}
 198         assert user.banner == %{}
 199         assert user.note_count == 0
 200         assert user.follower_count == 0
 201         assert user.following_count == 0
 202         assert user.bio == ""
 203         assert user.name == nil
 204
 205         assert called(Pleroma.Web.Federator.publish(:_))
 206       end
 207     end
 208
 209     test "multiple users", %{admin: admin, conn: conn} do
 210       user_one = insert(:user)
 211       user_two = insert(:user)
 212
 213       conn =
 214         conn
 215         |> put_req_header("accept", "application/json")
 216         |> delete("/api/pleroma/admin/users", %{
 217           nicknames: [user_one.nickname, user_two.nickname]
 218         })
 219
 220       log_entry = Repo.one(ModerationLog)
 221
 222       assert ModerationLog.get_log_entry_message(log_entry) ==
 223                "@#{admin.nickname} deleted users: @#{user_one.nickname}, @#{user_two.nickname}"
 224
 225       response = json_response(conn, 200)
 226       assert response -- [user_one.nickname, user_two.nickname] == []
 227     end
 228   end
 229
 230   describe "/api/pleroma/admin/users" do
 231     test "Create", %{conn: conn} do
 232       conn =
 233         conn
 234         |> put_req_header("accept", "application/json")
 235         |> post("/api/pleroma/admin/users", %{
 236           "users" => [
 237             %{
 238               "nickname" => "lain",
 239               "email" => "lain@example.org",
 240               "password" => "test"
 241             },
 242             %{
 243               "nickname" => "lain2",
 244               "email" => "lain2@example.org",
 245               "password" => "test"
 246             }
 247           ]
 248         })
 249
 250       response = json_response(conn, 200) |> Enum.map(&Map.get(&1, "type"))
 251       assert response == ["success", "success"]
 252
 253       log_entry = Repo.one(ModerationLog)
 254
 255       assert ["lain", "lain2"] -- Enum.map(log_entry.data["subjects"], & &1["nickname"]) == []
 256     end
 257
 258     test "Cannot create user with existing email", %{conn: conn} do
 259       user = insert(:user)
 260
 261       conn =
 262         conn
 263         |> put_req_header("accept", "application/json")
 264         |> post("/api/pleroma/admin/users", %{
 265           "users" => [
 266             %{
 267               "nickname" => "lain",
 268               "email" => user.email,
 269               "password" => "test"
 270             }
 271           ]
 272         })
 273
 274       assert json_response(conn, 409) == [
 275                %{
 276                  "code" => 409,
 277                  "data" => %{
 278                    "email" => user.email,
 279                    "nickname" => "lain"
 280                  },
 281                  "error" => "email has already been taken",
 282                  "type" => "error"
 283                }
 284              ]
 285     end
 286
 287     test "Cannot create user with existing nickname", %{conn: conn} do
 288       user = insert(:user)
 289
 290       conn =
 291         conn
 292         |> put_req_header("accept", "application/json")
 293         |> post("/api/pleroma/admin/users", %{
 294           "users" => [
 295             %{
 296               "nickname" => user.nickname,
 297               "email" => "someuser@plerama.social",
 298               "password" => "test"
 299             }
 300           ]
 301         })
 302
 303       assert json_response(conn, 409) == [
 304                %{
 305                  "code" => 409,
 306                  "data" => %{
 307                    "email" => "someuser@plerama.social",
 308                    "nickname" => user.nickname
 309                  },
 310                  "error" => "nickname has already been taken",
 311                  "type" => "error"
 312                }
 313              ]
 314     end
 315
 316     test "Multiple user creation works in transaction", %{conn: conn} do
 317       user = insert(:user)
 318
 319       conn =
 320         conn
 321         |> put_req_header("accept", "application/json")
 322         |> post("/api/pleroma/admin/users", %{
 323           "users" => [
 324             %{
 325               "nickname" => "newuser",
 326               "email" => "newuser@pleroma.social",
 327               "password" => "test"
 328             },
 329             %{
 330               "nickname" => "lain",
 331               "email" => user.email,
 332               "password" => "test"
 333             }
 334           ]
 335         })
 336
 337       assert json_response(conn, 409) == [
 338                %{
 339                  "code" => 409,
 340                  "data" => %{
 341                    "email" => user.email,
 342                    "nickname" => "lain"
 343                  },
 344                  "error" => "email has already been taken",
 345                  "type" => "error"
 346                },
 347                %{
 348                  "code" => 409,
 349                  "data" => %{
 350                    "email" => "newuser@pleroma.social",
 351                    "nickname" => "newuser"
 352                  },
 353                  "error" => "",
 354                  "type" => "error"
 355                }
 356              ]
 357
 358       assert User.get_by_nickname("newuser") === nil
 359     end
 360   end
 361
 362   describe "/api/pleroma/admin/users/:nickname" do
 363     test "Show", %{conn: conn} do
 364       user = insert(:user)
 365
 366       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")
 367
 368       assert user_response(user) == json_response(conn, 200)
 369     end
 370
 371     test "when the user doesn't exist", %{conn: conn} do
 372       user = build(:user)
 373
 374       conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}")
 375
 376       assert %{"error" => "Not found"} == json_response(conn, 404)
 377     end
 378   end
 379
 380   describe "/api/pleroma/admin/users/follow" do
 381     test "allows to force-follow another user", %{admin: admin, conn: conn} do
 382       user = insert(:user)
 383       follower = insert(:user)
 384
 385       conn
 386       |> put_req_header("accept", "application/json")
 387       |> post("/api/pleroma/admin/users/follow", %{
 388         "follower" => follower.nickname,
 389         "followed" => user.nickname
 390       })
 391
 392       user = User.get_cached_by_id(user.id)
 393       follower = User.get_cached_by_id(follower.id)
 394
 395       assert User.following?(follower, user)
 396
 397       log_entry = Repo.one(ModerationLog)
 398
 399       assert ModerationLog.get_log_entry_message(log_entry) ==
 400                "@#{admin.nickname} made @#{follower.nickname} follow @#{user.nickname}"
 401     end
 402   end
 403
 404   describe "/api/pleroma/admin/users/unfollow" do
 405     test "allows to force-unfollow another user", %{admin: admin, conn: conn} do
 406       user = insert(:user)
 407       follower = insert(:user)
 408
 409       User.follow(follower, user)
 410
 411       conn
 412       |> put_req_header("accept", "application/json")
 413       |> post("/api/pleroma/admin/users/unfollow", %{
 414         "follower" => follower.nickname,
 415         "followed" => user.nickname
 416       })
 417
 418       user = User.get_cached_by_id(user.id)
 419       follower = User.get_cached_by_id(follower.id)
 420
 421       refute User.following?(follower, user)
 422
 423       log_entry = Repo.one(ModerationLog)
 424
 425       assert ModerationLog.get_log_entry_message(log_entry) ==
 426                "@#{admin.nickname} made @#{follower.nickname} unfollow @#{user.nickname}"
 427     end
 428   end
 429
 430   describe "GET /api/pleroma/admin/users" do
 431     test "renders users array for the first page", %{conn: conn, admin: admin} do
 432       user = insert(:user, local: false, tags: ["foo", "bar"])
 433       user2 = insert(:user, approval_pending: true, registration_reason: "I'm a chill dude")
 434
 435       conn = get(conn, "/api/pleroma/admin/users?page=1")
 436
 437       users =
 438         [
 439           user_response(
 440             admin,
 441             %{"roles" => %{"admin" => true, "moderator" => false}}
 442           ),
 443           user_response(user, %{"local" => false, "tags" => ["foo", "bar"]}),
 444           user_response(
 445             user2,
 446             %{
 447               "local" => true,
 448               "approval_pending" => true,
 449               "registration_reason" => "I'm a chill dude",
 450               "actor_type" => "Person"
 451             }
 452           )
 453         ]
 454         |> Enum.sort_by(& &1["nickname"])
 455
 456       assert json_response(conn, 200) == %{
 457                "count" => 3,
 458                "page_size" => 50,
 459                "users" => users
 460              }
 461     end
 462
 463     test "pagination works correctly with service users", %{conn: conn} do
 464       service1 = User.get_or_create_service_actor_by_ap_id(Web.base_url() <> "/meido", "meido")
 465
 466       insert_list(25, :user)
 467
 468       assert %{"count" => 26, "page_size" => 10, "users" => users1} =
 469                conn
 470                |> get("/api/pleroma/admin/users?page=1&filters=", %{page_size: "10"})
 471                |> json_response(200)
 472
 473       assert Enum.count(users1) == 10
 474       assert service1 not in users1
 475
 476       assert %{"count" => 26, "page_size" => 10, "users" => users2} =
 477                conn
 478                |> get("/api/pleroma/admin/users?page=2&filters=", %{page_size: "10"})
 479                |> json_response(200)
 480
 481       assert Enum.count(users2) == 10
 482       assert service1 not in users2
 483
 484       assert %{"count" => 26, "page_size" => 10, "users" => users3} =
 485                conn
 486                |> get("/api/pleroma/admin/users?page=3&filters=", %{page_size: "10"})
 487                |> json_response(200)
 488
 489       assert Enum.count(users3) == 6
 490       assert service1 not in users3
 491     end
 492
 493     test "renders empty array for the second page", %{conn: conn} do
 494       insert(:user)
 495
 496       conn = get(conn, "/api/pleroma/admin/users?page=2")
 497
 498       assert json_response(conn, 200) == %{
 499                "count" => 2,
 500                "page_size" => 50,
 501                "users" => []
 502              }
 503     end
 504
 505     test "regular search", %{conn: conn} do
 506       user = insert(:user, nickname: "bob")
 507
 508       conn = get(conn, "/api/pleroma/admin/users?query=bo")
 509
 510       assert json_response(conn, 200) == %{
 511                "count" => 1,
 512                "page_size" => 50,
 513                "users" => [user_response(user, %{"local" => true})]
 514              }
 515     end
 516
 517     test "search by domain", %{conn: conn} do
 518       user = insert(:user, nickname: "nickname@domain.com")
 519       insert(:user)
 520
 521       conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
 522
 523       assert json_response(conn, 200) == %{
 524                "count" => 1,
 525                "page_size" => 50,
 526                "users" => [user_response(user)]
 527              }
 528     end
 529
 530     test "search by full nickname", %{conn: conn} do
 531       user = insert(:user, nickname: "nickname@domain.com")
 532       insert(:user)
 533
 534       conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
 535
 536       assert json_response(conn, 200) == %{
 537                "count" => 1,
 538                "page_size" => 50,
 539                "users" => [user_response(user)]
 540              }
 541     end
 542
 543     test "search by display name", %{conn: conn} do
 544       user = insert(:user, name: "Display name")
 545       insert(:user)
 546
 547       conn = get(conn, "/api/pleroma/admin/users?name=display")
 548
 549       assert json_response(conn, 200) == %{
 550                "count" => 1,
 551                "page_size" => 50,
 552                "users" => [user_response(user)]
 553              }
 554     end
 555
 556     test "search by email", %{conn: conn} do
 557       user = insert(:user, email: "email@example.com")
 558       insert(:user)
 559
 560       conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
 561
 562       assert json_response(conn, 200) == %{
 563                "count" => 1,
 564                "page_size" => 50,
 565                "users" => [user_response(user)]
 566              }
 567     end
 568
 569     test "regular search with page size", %{conn: conn} do
 570       user = insert(:user, nickname: "aalice")
 571       user2 = insert(:user, nickname: "alice")
 572
 573       conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")
 574
 575       assert json_response(conn1, 200) == %{
 576                "count" => 2,
 577                "page_size" => 1,
 578                "users" => [user_response(user)]
 579              }
 580
 581       conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")
 582
 583       assert json_response(conn2, 200) == %{
 584                "count" => 2,
 585                "page_size" => 1,
 586                "users" => [user_response(user2)]
 587              }
 588     end
 589
 590     test "only local users" do
 591       admin = insert(:user, is_admin: true, nickname: "john")
 592       token = insert(:oauth_admin_token, user: admin)
 593       user = insert(:user, nickname: "bob")
 594
 595       insert(:user, nickname: "bobb", local: false)
 596
 597       conn =
 598         build_conn()
 599         |> assign(:user, admin)
 600         |> assign(:token, token)
 601         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 602
 603       assert json_response(conn, 200) == %{
 604                "count" => 1,
 605                "page_size" => 50,
 606                "users" => [user_response(user)]
 607              }
 608     end
 609
 610     test "only local users with no query", %{conn: conn, admin: old_admin} do
 611       admin = insert(:user, is_admin: true, nickname: "john")
 612       user = insert(:user, nickname: "bob")
 613
 614       insert(:user, nickname: "bobb", local: false)
 615
 616       conn = get(conn, "/api/pleroma/admin/users?filters=local")
 617
 618       users =
 619         [
 620           user_response(user),
 621           user_response(admin, %{
 622             "roles" => %{"admin" => true, "moderator" => false}
 623           }),
 624           user_response(old_admin, %{
 625             "deactivated" => false,
 626             "roles" => %{"admin" => true, "moderator" => false}
 627           })
 628         ]
 629         |> Enum.sort_by(& &1["nickname"])
 630
 631       assert json_response(conn, 200) == %{
 632                "count" => 3,
 633                "page_size" => 50,
 634                "users" => users
 635              }
 636     end
 637
 638     test "only unconfirmed users", %{conn: conn} do
 639       sad_user = insert(:user, nickname: "sadboy", confirmation_pending: true)
 640       old_user = insert(:user, nickname: "oldboy", confirmation_pending: true)
 641
 642       insert(:user, nickname: "happyboy", approval_pending: false)
 643       insert(:user, confirmation_pending: false)
 644
 645       result =
 646         conn
 647         |> get("/api/pleroma/admin/users?filters=unconfirmed")
 648         |> json_response(200)
 649
 650       users =
 651         Enum.map([old_user, sad_user], fn user ->
 652           user_response(user, %{
 653             "confirmation_pending" => true,
 654             "approval_pending" => false
 655           })
 656         end)
 657         |> Enum.sort_by(& &1["nickname"])
 658
 659       assert result == %{"count" => 2, "page_size" => 50, "users" => users}
 660     end
 661
 662     test "only unapproved users", %{conn: conn} do
 663       user =
 664         insert(:user,
 665           nickname: "sadboy",
 666           approval_pending: true,
 667           registration_reason: "Plz let me in!"
 668         )
 669
 670       insert(:user, nickname: "happyboy", approval_pending: false)
 671
 672       conn = get(conn, "/api/pleroma/admin/users?filters=need_approval")
 673
 674       users = [
 675         user_response(
 676           user,
 677           %{"approval_pending" => true, "registration_reason" => "Plz let me in!"}
 678         )
 679       ]
 680
 681       assert json_response(conn, 200) == %{
 682                "count" => 1,
 683                "page_size" => 50,
 684                "users" => users
 685              }
 686     end
 687
 688     test "load only admins", %{conn: conn, admin: admin} do
 689       second_admin = insert(:user, is_admin: true)
 690       insert(:user)
 691       insert(:user)
 692
 693       conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
 694
 695       users =
 696         [
 697           user_response(admin, %{
 698             "deactivated" => false,
 699             "roles" => %{"admin" => true, "moderator" => false}
 700           }),
 701           user_response(second_admin, %{
 702             "deactivated" => false,
 703             "roles" => %{"admin" => true, "moderator" => false}
 704           })
 705         ]
 706         |> Enum.sort_by(& &1["nickname"])
 707
 708       assert json_response(conn, 200) == %{
 709                "count" => 2,
 710                "page_size" => 50,
 711                "users" => users
 712              }
 713     end
 714
 715     test "load only moderators", %{conn: conn} do
 716       moderator = insert(:user, is_moderator: true)
 717       insert(:user)
 718       insert(:user)
 719
 720       conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
 721
 722       assert json_response(conn, 200) == %{
 723                "count" => 1,
 724                "page_size" => 50,
 725                "users" => [
 726                  user_response(moderator, %{
 727                    "deactivated" => false,
 728                    "roles" => %{"admin" => false, "moderator" => true}
 729                  })
 730                ]
 731              }
 732     end
 733
 734     test "load users with actor_type is Person", %{admin: admin, conn: conn} do
 735       insert(:user, actor_type: "Service")
 736       insert(:user, actor_type: "Application")
 737
 738       user1 = insert(:user)
 739       user2 = insert(:user)
 740
 741       response =
 742         conn
 743         |> get(user_path(conn, :list), %{actor_types: ["Person"]})
 744         |> json_response(200)
 745
 746       users =
 747         [
 748           user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}}),
 749           user_response(user1),
 750           user_response(user2)
 751         ]
 752         |> Enum.sort_by(& &1["nickname"])
 753
 754       assert response == %{"count" => 3, "page_size" => 50, "users" => users}
 755     end
 756
 757     test "load users with actor_type is Person and Service", %{admin: admin, conn: conn} do
 758       user_service = insert(:user, actor_type: "Service")
 759       insert(:user, actor_type: "Application")
 760
 761       user1 = insert(:user)
 762       user2 = insert(:user)
 763
 764       response =
 765         conn
 766         |> get(user_path(conn, :list), %{actor_types: ["Person", "Service"]})
 767         |> json_response(200)
 768
 769       users =
 770         [
 771           user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}}),
 772           user_response(user1),
 773           user_response(user2),
 774           user_response(user_service, %{"actor_type" => "Service"})
 775         ]
 776         |> Enum.sort_by(& &1["nickname"])
 777
 778       assert response == %{"count" => 4, "page_size" => 50, "users" => users}
 779     end
 780
 781     test "load users with actor_type is Service", %{conn: conn} do
 782       user_service = insert(:user, actor_type: "Service")
 783       insert(:user, actor_type: "Application")
 784       insert(:user)
 785       insert(:user)
 786
 787       response =
 788         conn
 789         |> get(user_path(conn, :list), %{actor_types: ["Service"]})
 790         |> json_response(200)
 791
 792       users = [user_response(user_service, %{"actor_type" => "Service"})]
 793
 794       assert response == %{"count" => 1, "page_size" => 50, "users" => users}
 795     end
 796
 797     test "load users with tags list", %{conn: conn} do
 798       user1 = insert(:user, tags: ["first"])
 799       user2 = insert(:user, tags: ["second"])
 800       insert(:user)
 801       insert(:user)
 802
 803       conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
 804
 805       users =
 806         [
 807           user_response(user1, %{"tags" => ["first"]}),
 808           user_response(user2, %{"tags" => ["second"]})
 809         ]
 810         |> Enum.sort_by(& &1["nickname"])
 811
 812       assert json_response(conn, 200) == %{
 813                "count" => 2,
 814                "page_size" => 50,
 815                "users" => users
 816              }
 817     end
 818
 819     test "`active` filters out users pending approval", %{token: token} do
 820       insert(:user, approval_pending: true)
 821       %{id: user_id} = insert(:user, approval_pending: false)
 822       %{id: admin_id} = token.user
 823
 824       conn =
 825         build_conn()
 826         |> assign(:user, token.user)
 827         |> assign(:token, token)
 828         |> get("/api/pleroma/admin/users?filters=active")
 829
 830       assert %{
 831                "count" => 2,
 832                "page_size" => 50,
 833                "users" => [
 834                  %{"id" => ^admin_id},
 835                  %{"id" => ^user_id}
 836                ]
 837              } = json_response(conn, 200)
 838     end
 839
 840     test "it works with multiple filters" do
 841       admin = insert(:user, nickname: "john", is_admin: true)
 842       token = insert(:oauth_admin_token, user: admin)
 843       user = insert(:user, nickname: "bob", local: false, deactivated: true)
 844
 845       insert(:user, nickname: "ken", local: true, deactivated: true)
 846       insert(:user, nickname: "bobb", local: false, deactivated: false)
 847
 848       conn =
 849         build_conn()
 850         |> assign(:user, admin)
 851         |> assign(:token, token)
 852         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 853
 854       assert json_response(conn, 200) == %{
 855                "count" => 1,
 856                "page_size" => 50,
 857                "users" => [user_response(user)]
 858              }
 859     end
 860
 861     test "it omits relay user", %{admin: admin, conn: conn} do
 862       assert %User{} = Relay.get_actor()
 863
 864       conn = get(conn, "/api/pleroma/admin/users")
 865
 866       assert json_response(conn, 200) == %{
 867                "count" => 1,
 868                "page_size" => 50,
 869                "users" => [
 870                  user_response(admin, %{"roles" => %{"admin" => true, "moderator" => false}})
 871                ]
 872              }
 873     end
 874   end
 875
 876   test "PATCH /api/pleroma/admin/users/activate", %{admin: admin, conn: conn} do
 877     user_one = insert(:user, deactivated: true)
 878     user_two = insert(:user, deactivated: true)
 879
 880     conn =
 881       patch(
 882         conn,
 883         "/api/pleroma/admin/users/activate",
 884         %{nicknames: [user_one.nickname, user_two.nickname]}
 885       )
 886
 887     response = json_response(conn, 200)
 888     assert Enum.map(response["users"], & &1["deactivated"]) == [false, false]
 889
 890     log_entry = Repo.one(ModerationLog)
 891
 892     assert ModerationLog.get_log_entry_message(log_entry) ==
 893              "@#{admin.nickname} activated users: @#{user_one.nickname}, @#{user_two.nickname}"
 894   end
 895
 896   test "PATCH /api/pleroma/admin/users/deactivate", %{admin: admin, conn: conn} do
 897     user_one = insert(:user, deactivated: false)
 898     user_two = insert(:user, deactivated: false)
 899
 900     conn =
 901       patch(
 902         conn,
 903         "/api/pleroma/admin/users/deactivate",
 904         %{nicknames: [user_one.nickname, user_two.nickname]}
 905       )
 906
 907     response = json_response(conn, 200)
 908     assert Enum.map(response["users"], & &1["deactivated"]) == [true, true]
 909
 910     log_entry = Repo.one(ModerationLog)
 911
 912     assert ModerationLog.get_log_entry_message(log_entry) ==
 913              "@#{admin.nickname} deactivated users: @#{user_one.nickname}, @#{user_two.nickname}"
 914   end
 915
 916   test "PATCH /api/pleroma/admin/users/approve", %{admin: admin, conn: conn} do
 917     user_one = insert(:user, approval_pending: true)
 918     user_two = insert(:user, approval_pending: true)
 919
 920     conn =
 921       patch(
 922         conn,
 923         "/api/pleroma/admin/users/approve",
 924         %{nicknames: [user_one.nickname, user_two.nickname]}
 925       )
 926
 927     response = json_response(conn, 200)
 928     assert Enum.map(response["users"], & &1["approval_pending"]) == [false, false]
 929
 930     log_entry = Repo.one(ModerationLog)
 931
 932     assert ModerationLog.get_log_entry_message(log_entry) ==
 933              "@#{admin.nickname} approved users: @#{user_one.nickname}, @#{user_two.nickname}"
 934   end
 935
 936   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation", %{admin: admin, conn: conn} do
 937     user = insert(:user)
 938
 939     conn = patch(conn, "/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 940
 941     assert json_response(conn, 200) ==
 942              user_response(
 943                user,
 944                %{"deactivated" => !user.deactivated}
 945              )
 946
 947     log_entry = Repo.one(ModerationLog)
 948
 949     assert ModerationLog.get_log_entry_message(log_entry) ==
 950              "@#{admin.nickname} deactivated users: @#{user.nickname}"
 951   end
 952
 953   defp user_response(user, attrs \\ %{}) do
 954     %{
 955       "deactivated" => user.deactivated,
 956       "id" => user.id,
 957       "nickname" => user.nickname,
 958       "roles" => %{"admin" => false, "moderator" => false},
 959       "local" => user.local,
 960       "tags" => [],
 961       "avatar" => User.avatar_url(user) |> MediaProxy.url(),
 962       "display_name" => HTML.strip_tags(user.name || user.nickname),
 963       "confirmation_pending" => false,
 964       "approval_pending" => false,
 965       "url" => user.ap_id,
 966       "registration_reason" => nil,
 967       "actor_type" => "Person"
 968     }
 969     |> Map.merge(attrs)
 970   end
 971 end