Git of dcc - anni/blob - test/pleroma/web/admin_api/controllers/status_controller_test.exs

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