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