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