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       notify_email = Pleroma.Config.get([:instance, :notify_email])
 320       instance_name = Pleroma.Config.get([:instance, :name])
 321
 322       email =
 323         Pleroma.UserEmail.user_invitation_email(
 324           user,
 325           token_record,
 326           recipient_email,
 327           recipient_name
 328         )
 329
 330       Swoosh.TestAssertions.assert_email_sent(
 331         from: {instance_name, notify_email},
 332         to: {recipient_name, recipient_email},
 333         html_body: email.html_body
 334       )
 335     end
 336
 337     test "it returns 403 if requested by a non-admin", %{conn: conn} do
 338       non_admin_user = insert(:user)
 339
 340       conn =
 341         conn
 342         |> assign(:user, non_admin_user)
 343         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 344
 345       assert json_response(conn, :forbidden)
 346     end
 347   end
 348
 349   describe "POST /api/pleroma/admin/email_invite, with invalid config" do
 350     setup do
 351       [user: insert(:user, info: %{is_admin: true})]
 352     end
 353
 354     test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
 355       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 356       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 357       Pleroma.Config.put([:instance, :registrations_open], false)
 358       Pleroma.Config.put([:instance, :invites_enabled], false)
 359
 360       on_exit(fn ->
 361         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 362         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 363         :ok
 364       end)
 365
 366       conn =
 367         conn
 368         |> assign(:user, user)
 369         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 370
 371       assert json_response(conn, :internal_server_error)
 372     end
 373
 374     test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
 375       registrations_open = Pleroma.Config.get([:instance, :registrations_open])
 376       invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
 377       Pleroma.Config.put([:instance, :registrations_open], true)
 378       Pleroma.Config.put([:instance, :invites_enabled], true)
 379
 380       on_exit(fn ->
 381         Pleroma.Config.put([:instance, :registrations_open], registrations_open)
 382         Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
 383         :ok
 384       end)
 385
 386       conn =
 387         conn
 388         |> assign(:user, user)
 389         |> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")
 390
 391       assert json_response(conn, :internal_server_error)
 392     end
 393   end
 394
 395   test "/api/pleroma/admin/invite_token" do
 396     admin = insert(:user, info: %{is_admin: true})
 397
 398     conn =
 399       build_conn()
 400       |> assign(:user, admin)
 401       |> put_req_header("accept", "application/json")
 402       |> get("/api/pleroma/admin/invite_token")
 403
 404     assert conn.status == 200
 405   end
 406
 407   test "/api/pleroma/admin/password_reset" do
 408     admin = insert(:user, info: %{is_admin: true})
 409     user = insert(:user)
 410
 411     conn =
 412       build_conn()
 413       |> assign(:user, admin)
 414       |> put_req_header("accept", "application/json")
 415       |> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")
 416
 417     assert conn.status == 200
 418   end
 419
 420   describe "GET /api/pleroma/admin/users" do
 421     test "renders users array for the first page" do
 422       admin = insert(:user, info: %{is_admin: true})
 423       user = insert(:user, local: false, tags: ["foo", "bar"])
 424
 425       conn =
 426         build_conn()
 427         |> assign(:user, admin)
 428         |> get("/api/pleroma/admin/users?page=1")
 429
 430       assert json_response(conn, 200) == %{
 431                "count" => 2,
 432                "page_size" => 50,
 433                "users" => [
 434                  %{
 435                    "deactivated" => admin.info.deactivated,
 436                    "id" => admin.id,
 437                    "nickname" => admin.nickname,
 438                    "roles" => %{"admin" => true, "moderator" => false},
 439                    "local" => true,
 440                    "tags" => []
 441                  },
 442                  %{
 443                    "deactivated" => user.info.deactivated,
 444                    "id" => user.id,
 445                    "nickname" => user.nickname,
 446                    "roles" => %{"admin" => false, "moderator" => false},
 447                    "local" => false,
 448                    "tags" => ["foo", "bar"]
 449                  }
 450                ]
 451              }
 452     end
 453
 454     test "renders empty array for the second page" do
 455       admin = insert(:user, info: %{is_admin: true})
 456       insert(:user)
 457
 458       conn =
 459         build_conn()
 460         |> assign(:user, admin)
 461         |> get("/api/pleroma/admin/users?page=2")
 462
 463       assert json_response(conn, 200) == %{
 464                "count" => 2,
 465                "page_size" => 50,
 466                "users" => []
 467              }
 468     end
 469
 470     test "regular search" do
 471       admin = insert(:user, info: %{is_admin: true})
 472       user = insert(:user, nickname: "bob")
 473
 474       conn =
 475         build_conn()
 476         |> assign(:user, admin)
 477         |> get("/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 "regular search with page size" do
 496       admin = insert(:user, info: %{is_admin: true})
 497       user = insert(:user, nickname: "aalice")
 498       user2 = insert(:user, nickname: "alice")
 499
 500       conn =
 501         build_conn()
 502         |> assign(:user, admin)
 503         |> get("/api/pleroma/admin/users?query=a&page_size=1&page=1")
 504
 505       assert json_response(conn, 200) == %{
 506                "count" => 2,
 507                "page_size" => 1,
 508                "users" => [
 509                  %{
 510                    "deactivated" => user.info.deactivated,
 511                    "id" => user.id,
 512                    "nickname" => user.nickname,
 513                    "roles" => %{"admin" => false, "moderator" => false},
 514                    "local" => true,
 515                    "tags" => []
 516                  }
 517                ]
 518              }
 519
 520       conn =
 521         build_conn()
 522         |> assign(:user, admin)
 523         |> get("/api/pleroma/admin/users?query=a&page_size=1&page=2")
 524
 525       assert json_response(conn, 200) == %{
 526                "count" => 2,
 527                "page_size" => 1,
 528                "users" => [
 529                  %{
 530                    "deactivated" => user2.info.deactivated,
 531                    "id" => user2.id,
 532                    "nickname" => user2.nickname,
 533                    "roles" => %{"admin" => false, "moderator" => false},
 534                    "local" => true,
 535                    "tags" => []
 536                  }
 537                ]
 538              }
 539     end
 540
 541     test "only local users" do
 542       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 543       user = insert(:user, nickname: "bob")
 544
 545       insert(:user, nickname: "bobb", local: false)
 546
 547       conn =
 548         build_conn()
 549         |> assign(:user, admin)
 550         |> get("/api/pleroma/admin/users?query=bo&filters=local")
 551
 552       assert json_response(conn, 200) == %{
 553                "count" => 1,
 554                "page_size" => 50,
 555                "users" => [
 556                  %{
 557                    "deactivated" => user.info.deactivated,
 558                    "id" => user.id,
 559                    "nickname" => user.nickname,
 560                    "roles" => %{"admin" => false, "moderator" => false},
 561                    "local" => true,
 562                    "tags" => []
 563                  }
 564                ]
 565              }
 566     end
 567
 568     test "only local users with no query" do
 569       admin = insert(:user, info: %{is_admin: true}, nickname: "john")
 570       user = insert(:user, nickname: "bob")
 571
 572       insert(:user, nickname: "bobb", local: false)
 573
 574       conn =
 575         build_conn()
 576         |> assign(:user, admin)
 577         |> get("/api/pleroma/admin/users?filters=local")
 578
 579       assert json_response(conn, 200) == %{
 580                "count" => 2,
 581                "page_size" => 50,
 582                "users" => [
 583                  %{
 584                    "deactivated" => user.info.deactivated,
 585                    "id" => user.id,
 586                    "nickname" => user.nickname,
 587                    "roles" => %{"admin" => false, "moderator" => false},
 588                    "local" => true,
 589                    "tags" => []
 590                  },
 591                  %{
 592                    "deactivated" => admin.info.deactivated,
 593                    "id" => admin.id,
 594                    "nickname" => admin.nickname,
 595                    "roles" => %{"admin" => true, "moderator" => false},
 596                    "local" => true,
 597                    "tags" => []
 598                  }
 599                ]
 600              }
 601     end
 602
 603     test "it works with multiple filters" do
 604       admin = insert(:user, nickname: "john", info: %{is_admin: true})
 605       user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})
 606
 607       insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
 608       insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})
 609
 610       conn =
 611         build_conn()
 612         |> assign(:user, admin)
 613         |> get("/api/pleroma/admin/users?filters=deactivated,external")
 614
 615       assert json_response(conn, 200) == %{
 616                "count" => 1,
 617                "page_size" => 50,
 618                "users" => [
 619                  %{
 620                    "deactivated" => user.info.deactivated,
 621                    "id" => user.id,
 622                    "nickname" => user.nickname,
 623                    "roles" => %{"admin" => false, "moderator" => false},
 624                    "local" => user.local,
 625                    "tags" => []
 626                  }
 627                ]
 628              }
 629     end
 630   end
 631
 632   test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
 633     admin = insert(:user, info: %{is_admin: true})
 634     user = insert(:user)
 635
 636     conn =
 637       build_conn()
 638       |> assign(:user, admin)
 639       |> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")
 640
 641     assert json_response(conn, 200) ==
 642              %{
 643                "deactivated" => !user.info.deactivated,
 644                "id" => user.id,
 645                "nickname" => user.nickname,
 646                "roles" => %{"admin" => false, "moderator" => false},
 647                "local" => true,
 648                "tags" => []
 649              }
 650   end
 651 end