git.squeep.com Git - akkoma/blob - test/pleroma/web/admin_api/controllers/status_controller_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.AdminAPI.StatusControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   import Pleroma.Factory
   9
  10   alias Pleroma.Activity
  11   alias Pleroma.Config
  12   alias Pleroma.ModerationLog
  13   alias Pleroma.Repo
  14   alias Pleroma.User
  15   alias Pleroma.Web.CommonAPI
  16
  17   setup do
  18     admin = insert(:user, is_admin: true)
  19     token = insert(:oauth_admin_token, user: admin)
  20
  21     conn =
  22       build_conn()
  23       |> assign(:user, admin)
  24       |> assign(:token, token)
  25
  26     {:ok, %{admin: admin, token: token, conn: conn}}
  27   end
  28
  29   describe "GET /api/pleroma/admin/statuses/:id" do
  30     test "not found", %{conn: conn} do
  31       assert conn
  32              |> get("/api/pleroma/admin/statuses/not_found")
  33              |> json_response_and_validate_schema(:not_found)
  34     end
  35
  36     test "shows activity", %{conn: conn} do
  37       activity = insert(:note_activity)
  38
  39       response =
  40         conn
  41         |> get("/api/pleroma/admin/statuses/#{activity.id}")
  42         |> json_response_and_validate_schema(200)
  43
  44       assert response["id"] == activity.id
  45
  46       account = response["account"]
  47       actor = User.get_by_ap_id(activity.actor)
  48
  49       assert account["id"] == actor.id
  50       assert account["nickname"] == actor.nickname
  51       assert account["deactivated"] == actor.deactivated
  52       assert account["confirmation_pending"] == actor.confirmation_pending
  53     end
  54   end
  55
  56   describe "PUT /api/pleroma/admin/statuses/:id" do
  57     setup do
  58       activity = insert(:note_activity)
  59
  60       %{id: activity.id}
  61     end
  62
  63     test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
  64       response =
  65         conn
  66         |> put_req_header("content-type", "application/json")
  67         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
  68         |> json_response_and_validate_schema(:ok)
  69
  70       assert response["sensitive"]
  71
  72       log_entry = Repo.one(ModerationLog)
  73
  74       assert ModerationLog.get_log_entry_message(log_entry) ==
  75                "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
  76
  77       response =
  78         conn
  79         |> put_req_header("content-type", "application/json")
  80         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
  81         |> json_response_and_validate_schema(:ok)
  82
  83       refute response["sensitive"]
  84     end
  85
  86     test "change visibility flag", %{conn: conn, id: id, admin: admin} do
  87       response =
  88         conn
  89         |> put_req_header("content-type", "application/json")
  90         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
  91         |> json_response_and_validate_schema(:ok)
  92
  93       assert response["visibility"] == "public"
  94
  95       log_entry = Repo.one(ModerationLog)
  96
  97       assert ModerationLog.get_log_entry_message(log_entry) ==
  98                "@#{admin.nickname} updated status ##{id}, set visibility: 'public'"
  99
 100       response =
 101         conn
 102         |> put_req_header("content-type", "application/json")
 103         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "private"})
 104         |> json_response_and_validate_schema(:ok)
 105
 106       assert response["visibility"] == "private"
 107
 108       response =
 109         conn
 110         |> put_req_header("content-type", "application/json")
 111         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
 112         |> json_response_and_validate_schema(:ok)
 113
 114       assert response["visibility"] == "unlisted"
 115     end
 116
 117     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
 118       conn =
 119         conn
 120         |> put_req_header("content-type", "application/json")
 121         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "test"})
 122
 123       assert %{"error" => "test - Invalid value for enum."} =
 124                json_response_and_validate_schema(conn, :bad_request)
 125     end
 126   end
 127
 128   describe "DELETE /api/pleroma/admin/statuses/:id" do
 129     setup do
 130       activity = insert(:note_activity)
 131
 132       %{id: activity.id}
 133     end
 134
 135     test "deletes status", %{conn: conn, id: id, admin: admin} do
 136       conn
 137       |> delete("/api/pleroma/admin/statuses/#{id}")
 138       |> json_response_and_validate_schema(:ok)
 139
 140       refute Activity.get_by_id(id)
 141
 142       log_entry = Repo.one(ModerationLog)
 143
 144       assert ModerationLog.get_log_entry_message(log_entry) ==
 145                "@#{admin.nickname} deleted status ##{id}"
 146     end
 147
 148     test "returns 404 when the status does not exist", %{conn: conn} do
 149       conn = delete(conn, "/api/pleroma/admin/statuses/test")
 150
 151       assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
 152     end
 153   end
 154
 155   describe "GET /api/pleroma/admin/statuses" do
 156     test "returns all public and unlisted statuses", %{conn: conn, admin: admin} do
 157       blocked = insert(:user)
 158       user = insert(:user)
 159       User.block(admin, blocked)
 160
 161       {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
 162
 163       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
 164       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
 165       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 166       {:ok, _} = CommonAPI.post(blocked, %{status: ".", visibility: "public"})
 167
 168       response =
 169         conn
 170         |> get("/api/pleroma/admin/statuses")
 171         |> json_response_and_validate_schema(200)
 172
 173       refute "private" in Enum.map(response, & &1["visibility"])
 174       assert length(response) == 3
 175     end
 176
 177     test "returns only local statuses with local_only on", %{conn: conn} do
 178       user = insert(:user)
 179       remote_user = insert(:user, local: false, nickname: "archaeme@archae.me")
 180       insert(:note_activity, user: user, local: true)
 181       insert(:note_activity, user: remote_user, local: false)
 182
 183       response =
 184         conn
 185         |> get("/api/pleroma/admin/statuses?local_only=true")
 186         |> json_response_and_validate_schema(200)
 187
 188       assert length(response) == 1
 189     end
 190
 191     test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do
 192       user = insert(:user)
 193
 194       {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
 195
 196       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
 197       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 198       conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
 199       assert json_response_and_validate_schema(conn, 200) |> length() == 3
 200     end
 201   end
 202 end