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   import Pleroma.Factory
  10
  11   describe "/api/pleroma/admin/user" do
  12     test "Delete" do
  13       admin = insert(:user, info: %{is_admin: true})
  14       user = insert(:user)
  15
  16       conn =
  17         build_conn()
  18         |> assign(:user, admin)
  19         |> put_req_header("accept", "application/json")
  20         |> delete("/api/pleroma/admin/user?nickname=#{user.nickname}")
  21
  22       assert json_response(conn, 200) == user.nickname
  23     end
  24
  25     test "Create" do
  26       admin = insert(:user, info: %{is_admin: true})
  27
  28       conn =
  29         build_conn()
  30         |> assign(:user, admin)
  31         |> put_req_header("accept", "application/json")
  32         |> post("/api/pleroma/admin/user", %{
  33           "nickname" => "lain",
  34           "email" => "lain@example.org",
  35           "password" => "test"
  36         })
  37
  38       assert json_response(conn, 200) == "lain"
  39     end
  40   end
  41
  42   describe "/api/pleroma/admin/users/:nickname" do
  43     test "Show", %{conn: conn} do
  44       admin = insert(:user, info: %{is_admin: true})
  45       user = insert(:user)
  46
  47       conn =
  48         conn
  49         |> assign(:user, admin)
  50         |> get("/api/pleroma/admin/users/#{user.nickname}")
  51
  52       expected = %{
  53         "deactivated" => false,
  54         "id" => to_string(user.id),
  55         "local" => true,
  56         "nickname" => user.nickname,
  57         "roles" => %{"admin" => false, "moderator" => false},
  58         "tags" => []
  59       }
  60
  61       assert expected == json_response(conn, 200)
  62     end
  63
  64     test "when the user doesn't exist", %{conn: conn} do
  65       admin = insert(:user, info: %{is_admin: true})
  66       user = build(:user)
  67
  68       conn =
  69         conn
  70         |> assign(:user, admin)
  71         |> get("/api/pleroma/admin/users/#{user.nickname}")
  72
  73       assert "Not found" == json_response(conn, 404)
  74     end
  75   end
  76
  77   describe "/api/pleroma/admin/user/follow" do
  78     test "allows to force-follow another user" do
  79       admin = insert(:user, info: %{is_admin: true})
  80       user = insert(:user)
  81       follower = insert(:user)
  82
  83       build_conn()
  84       |> assign(:user, admin)
  85       |> put_req_header("accept", "application/json")
  86       |> post("/api/pleroma/admin/user/follow", %{
  87         "follower" => follower.nickname,
  88         "followed" => user.nickname
  89       })
  90
  91       user = User.get_by_id(user.id)
  92       follower = User.get_by_id(follower.id)
  93
  94       assert User.following?(follower, user)
  95     end
  96   end
  97
  98   describe "/api/pleroma/admin/user/unfollow" do
  99     test "allows to force-unfollow another user" do
 100       admin = insert(:user, info: %{is_admin: true})
 101       user = insert(:user)
 102       follower = insert(:user)
 103
 104       User.follow(follower, user)
 105
 106       build_conn()
 107       |> assign(:user, admin)
 108       |> put_req_header("accept", "application/json")
 109       |> post("/api/pleroma/admin/user/unfollow", %{
 110         "follower" => follower.nickname,
 111         "followed" => user.nickname
 112       })
 113
 114       user = User.get_by_id(user.id)
 115       follower = User.get_by_id(follower.id)
 116
 117       refute User.following?(follower, user)
 118     end
 119   end
 120
 121   describe "PUT /api/pleroma/admin/users/tag" do
 122     setup do
 123       admin = insert(:user, info: %{is_admin: true})
 124       user1 = insert(:user, %{tags: ["x"]})
 125       user2 = insert(:user, %{tags: ["y"]})
 126       user3 = insert(:user, %{tags: ["unchanged"]})
 127
 128       conn =
 129         build_conn()
 130         |> assign(:user, admin)
 131         |> put_req_header("accept", "application/json")
 132         |> put(
 133           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 134             user2.nickname
 135           }&tags[]=foo&tags[]=bar"
 136         )
 137
 138       %{conn: conn, user1: user1, user2: user2, user3: user3}
 139     end
 140
 141     test "it appends specified tags to users with specified nicknames", %{
 142       conn: conn,
 143       user1: user1,
 144       user2: user2
 145     } do
 146       assert json_response(conn, :no_content)
 147       assert User.get_by_id(user1.id).tags == ["x", "foo", "bar"]
 148       assert User.get_by_id(user2.id).tags == ["y", "foo", "bar"]
 149     end
 150
 151     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 152       assert json_response(conn, :no_content)
 153       assert User.get_by_id(user3.id).tags == ["unchanged"]
 154     end
 155   end
 156
 157   describe "DELETE /api/pleroma/admin/users/tag" do
 158     setup do
 159       admin = insert(:user, info: %{is_admin: true})
 160       user1 = insert(:user, %{tags: ["x"]})
 161       user2 = insert(:user, %{tags: ["y", "z"]})
 162       user3 = insert(:user, %{tags: ["unchanged"]})
 163
 164       conn =
 165         build_conn()
 166         |> assign(:user, admin)
 167         |> put_req_header("accept", "application/json")
 168         |> delete(
 169           "/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
 170             user2.nickname
 171           }&tags[]=x&tags[]=z"
 172         )
 173
 174       %{conn: conn, user1: user1, user2: user2, user3: user3}
 175     end
 176
 177     test "it removes specified tags from users with specified nicknames", %{
 178       conn: conn,
 179       user1: user1,
 180       user2: user2
 181     } do
 182       assert json_response(conn, :no_content)
 183       assert User.get_by_id(user1.id).tags == []
 184       assert User.get_by_id(user2.id).tags == ["y"]
 185     end
 186
 187     test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
 188       assert json_response(conn, :no_content)
 189       assert User.get_by_id(user3.id).tags == ["unchanged"]
 190     end
 191   end
 192
 193   describe "/api/pleroma/admin/permission_group" do
 194     test "GET is giving user_info" do
 195       admin = insert(:user, info: %{is_admin: true})
 196
 197       conn =
 198         build_conn()
 199         |> assign(:user, admin)
 200         |> put_req_header("accept", "application/json")
 201         |> get("/api/pleroma/admin/permission_group/#{admin.nickname}")
 202
 203       assert json_response(conn, 200) == %{
 204                "is_admin" => true,
 205                "is_moderator" => false
 206              }
 207     end
 208
 209     test "/:right POST, can add to a permission group" do
 210       admin = insert(:user, info: %{is_admin: true})
 211       user = insert(:user)
 212
 213       conn =
 214         build_conn()
 215         |> assign(:user, admin)
 216         |> put_req_header("accept", "application/json")
 217         |> post("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
 218
 219       assert json_response(conn, 200) == %{
 220                "is_admin" => true
 221              }
 222     end
 223
 224     test "/:right DELETE, can remove from a permission group" do
 225       admin = insert(:user, info: %{is_admin: true})
 226       user = insert(:user, info: %{is_admin: true})
 227
 228       conn =
 229         build_conn()
 230         |> assign(:user, admin)
 231         |> put_req_header("accept", "application/json")
 232         |> delete("/api/pleroma/admin/permission_group/#{user.nickname}/admin")
 233
 234       assert json_response(conn, 200) == %{
 235                "is_admin" => false
 236              }
 237     end
 238   end
 239
 240   describe "PUT /api/pleroma/admin/activation_status" do
 241     setup %{conn: conn} do
 242       admin = insert(:user, info: %{is_admin: true})
 243
 244       conn =
 245         conn
 246         |> assign(:user, admin)
 247         |> put_req_header("accept", "application/json")
 248
 249       %{conn: conn}
 250     end
 251
 252     test "deactivates the user", %{conn: conn} do
 253       user = insert(:user)
 254
 255       conn =
 256         conn
 257         |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})
 258
 259       user = User.get_by_id(user.id)
 260       assert user.info.deactivated == true
 261       assert json_response(conn, :no_content)
 262     end
 263
 264     test "activates the user", %{conn: conn} do
 265       user = insert(:user, info: %{deactivated: true})
 266
 267       conn =
 268         conn
 269         |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: true})
 270
 271       user = User.get_by_id(user.id)
 272       assert user.info.deactivated == false
 273       assert json_response(conn, :no_content)
 274     end
 275
 276     test "returns 403 when requested by a non-admin", %{conn: conn} do
 277       user = insert(:user)
 278
 279       conn =
 280         conn
 281         |> assign(:user, user)
 282         |> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})
 283
 284       assert json_response(conn, :forbidden)
 285     end
 286   end
 287
 288   describe "POST /api/pleroma/admin/email_invite, with valid config" do
 289     setup do
 290       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 291       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 292       Pleroma.Config.put([:instance, :registrations_open], false)
 293       Pleroma.Config.put([:instance, :invites_enabled], true)
 294
 295       on_exit(fn ->
 296         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 297         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 298         :ok
 299       end)
 300
 301       [user: insert(:user, info: %{is_admin: true})]
 302     end
 303
 304     test "sends invitation and returns 204", %{conn: conn, user: user} do
 305       recipient_email = "foo@bar.com"
 306       recipient_name = "J. D."
 307
 308       conn =
 309         conn
 310         |> assign(:user, user)
 311         |> post("/api/pleroma/admin/email_invite?email=#{recipient_email}&name=#{recipient_name}")
 312
 313       assert json_response(conn, :no_content)
 314
 315       token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
 316       assert token_record
 317       refute token_record.used
 318
 319       Swoosh.TestAssertions.assert_email_sent(
 320         Pleroma.UserEmail.user_invitation_email(
 321           user,
 322           token_record,
 323           recipient_email,
 324           recipient_name
 325         )
 326       )
 327     end
 328
 329     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 330       non_admin_user = insert(:user)
 331
 332       conn =
 333         conn
 334         |> assign(:user, non_admin_user)
 335         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 336
 337       assert json_response(conn, :forbidden)
 338     end
 339   end
 340
 341   describe "POST /api/pleroma/admin/email_invite, with invalid config" do
 342     setup do
 343       [user: insert(:user, info: %{is_admin: true})]
 344     end
 345
 346     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 347       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 348       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 349       Pleroma.Config.put([:instance, :registrations_open], false)
 350       Pleroma.Config.put([:instance, :invites_enabled], false)
 351
 352       on_exit(fn ->
 353         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 354         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 355         :ok
 356       end)
 357
 358       conn =
 359         conn
 360         |> assign(:user, user)
 361         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 362
 363       assert json_response(conn, :internal_server_error)
 364     end
 365
 366     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 367       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 368       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 369       Pleroma.Config.put([:instance, :registrations_open], true)
 370       Pleroma.Config.put([:instance, :invites_enabled], true)
 371
 372       on_exit(fn ->
 373         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 374         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 375         :ok
 376       end)
 377
 378       conn =
 379         conn
 380         |> assign(:user, user)
 381         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 382
 383       assert json_response(conn, :internal_server_error)
 384     end
 385   end
 386
 387   test "/api/pleroma/admin/invite_token" do
 388     admin = insert(:user, info: %{is_admin: true})
 389
 390     conn =
 391       build_conn()
 392       |> assign(:user, admin)
 393       |> put_req_header("accept", "application/json")
 394       |> get("/api/pleroma/admin/invite_token")
 395
 396     assert conn.status == 200
 397   end
 398
 399   test "/api/pleroma/admin/password_reset" do
 400     admin = insert(:user, info: %{is_admin: true})
 401     user = insert(:user)
 402
 403     conn =
 404       build_conn()
 405       |> assign(:user, admin)
 406       |> put_req_header("accept", "application/json")
 407       |> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")
 408
 409     assert conn.status == 200
 410   end
 411
 412   describe "GET /api/pleroma/admin/users" do
 413     test "renders users array for the first page" do
 414       admin = insert(:user, info: %{is_admin: true})
 415       user = insert(:user, local: false, tags: ["foo", "bar"])
 416
 417       conn =
 418         build_conn()
 419         |> assign(:user, admin)
 420         |> get("/api/pleroma/admin/users?page=1")
 421
 422       assert json_response(conn, 200) == %{
 423                "count" => 2,
 424                "page_size" => 50,
 425                "users" => [
 426                  %{
 427                    "deactivated" => admin.info.deactivated,
 428                    "id" => admin.id,
 429                    "nickname" => admin.nickname,
 430                    "roles" => %{"admin" => true, "moderator" => false},
 431                    "local" => true,
 432                    "tags" => []
 433                  },
 434                  %{
 435                    "deactivated" => user.info.deactivated,
 436                    "id" => user.id,
 437                    "nickname" => user.nickname,
 438                    "roles" => %{"admin" => false, "moderator" => false},
 439                    "local" => false,
 440                    "tags" => ["foo", "bar"]
 441                  }
 442                ]
 443              }
 444     end
 445
 446     test "renders empty array for the second page" do
 447       admin = insert(:user, info: %{is_admin: true})
 448       insert(:user)
 449
 450       conn =
 451         build_conn()
 452         |> assign(:user, admin)
 453         |> get("/api/pleroma/admin/users?page=2")
 454
 455       assert json_response(conn, 200) == %{
 456                "count" => 2,
 457                "page_size" => 50,
 458                "users" => []
 459              }
 460     end
 461
 462     test "regular search" do
 463       admin = insert(:user, info: %{is_admin: true})
 464       user = insert(:user, nickname: "bob")
 465
 466       conn =
 467         build_conn()
 468         |> assign(:user, admin)
 469         |> get("/api/pleroma/admin/users?query=bo")
 470
 471       assert json_response(conn, 200) == %{
 472                "count" => 1,
 473                "page_size" => 50,
 474                "users" => [
 475                  %{
 476                    "deactivated" => user.info.deactivated,
 477                    "id" => user.id,
 478                    "nickname" => user.nickname,
 479                    "roles" => %{"admin" => false, "moderator" => false},
 480                    "local" => true,
 481                    "tags" => []
 482                  }
 483                ]
 484              }
 485     end
 486
 487     test "regular search with page size" do
 488       admin = insert(:user, info: %{is_admin: true})
 489       user = insert(:user, nickname: "aalice")
 490       user2 = insert(:user, nickname: "alice")
 491
 492       conn =
 493         build_conn()
 494         |> assign(:user, admin)
 495         |> get("/api/pleroma/admin/users?query=a&page_size=1&page=1")
 496
 497       assert json_response(conn, 200) == %{
 498                "count" => 2,
 499                "page_size" => 1,
 500                "users" => [
 501                  %{
 502                    "deactivated" => user.info.deactivated,
 503                    "id" => user.id,
 504                    "nickname" => user.nickname,
 505                    "roles" => %{"admin" => false, "moderator" => false},
 506                    "local" => true,
 507                    "tags" => []
 508                  }
 509                ]
 510              }
 511
 512       conn =
 513         build_conn()
 514         |> assign(:user, admin)
 515         |> get("/api/pleroma/admin/users?query=a&page_size=1&page=2")
 516
 517       assert json_response(conn, 200) == %{
 518                "count" => 2,
 519                "page_size" => 1,
 520                "users" => [
 521                  %{
 522                    "deactivated" => user2.info.deactivated,
 523                    "id" => user2.id,
 524                    "nickname" => user2.nickname,
 525                    "roles" => %{"admin" => false, "moderator" => false},
 526                    "local" => true,
 527                    "tags" => []
 528                  }
 529                ]
 530              }
 531     end
 532
 533     test "only local users" do
 534       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 535       user = insert(:user, nickname: "bob")
 536
 537       insert(:user, nickname: "bobb", local: false)
 538
 539       conn =
 540         build_conn()
 541         |> assign(:user, admin)
 542         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 543
 544       assert json_response(conn, 200) == %{
 545                "count" => 1,
 546                "page_size" => 50,
 547                "users" => [
 548                  %{
 549                    "deactivated" => user.info.deactivated,
 550                    "id" => user.id,
 551                    "nickname" => user.nickname,
 552                    "roles" => %{"admin" => false, "moderator" => false},
 553                    "local" => true,
 554                    "tags" => []
 555                  }
 556                ]
 557              }
 558     end
 559
 560     test "only local users with no query" do
 561       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 562       user = insert(:user, nickname: "bob")
 563
 564       insert(:user, nickname: "bobb", local: false)
 565
 566       conn =
 567         build_conn()
 568         |> assign(:user, admin)
 569         |> get("/api/pleroma/admin/users?filters=local")
 570
 571       assert json_response(conn, 200) == %{
 572                "count" => 2,
 573                "page_size" => 50,
 574                "users" => [
 575                  %{
 576                    "deactivated" => user.info.deactivated,
 577                    "id" => user.id,
 578                    "nickname" => user.nickname,
 579                    "roles" => %{"admin" => false, "moderator" => false},
 580                    "local" => true,
 581                    "tags" => []
 582                  },
 583                  %{
 584                    "deactivated" => admin.info.deactivated,
 585                    "id" => admin.id,
 586                    "nickname" => admin.nickname,
 587                    "roles" => %{"admin" => true, "moderator" => false},
 588                    "local" => true,
 589                    "tags" => []
 590                  }
 591                ]
 592              }
 593     end
 594
 595     test "it works with multiple filters" do
 596       admin = insert(:user, nickname: "john", info: %{is_admin: true})
 597       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
 598
 599       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
 600       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
 601
 602       conn =
 603         build_conn()
 604         |> assign(:user, admin)
 605         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 606
 607       assert json_response(conn, 200) == %{
 608                "count" => 1,
 609                "page_size" => 50,
 610                "users" => [
 611                  %{
 612                    "deactivated" => user.info.deactivated,
 613                    "id" => user.id,
 614                    "nickname" => user.nickname,
 615                    "roles" => %{"admin" => false, "moderator" => false},
 616                    "local" => user.local,
 617                    "tags" => []
 618                  }
 619                ]
 620              }
 621     end
 622   end
 623
 624   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
 625     admin = insert(:user, info: %{is_admin: true})
 626     user = insert(:user)
 627
 628     conn =
 629       build_conn()
 630       |> assign(:user, admin)
 631       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 632
 633     assert json_response(conn, 200) ==
 634              %{
 635                "deactivated" => !user.info.deactivated,
 636                "id" => user.id,
 637                "nickname" => user.nickname,
 638                "roles" => %{"admin" => false, "moderator" => false},
 639                "local" => true,
 640                "tags" => []
 641              }
 642   end
 643 end