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