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