git.squeep.com Git - akkoma/blob - test/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     end
  46   end
  47
  48   describe "PUT /api/pleroma/admin/statuses/:id" do
  49     setup do
  50       activity = insert(:note_activity)
  51
  52       %{id: activity.id}
  53     end
  54
  55     test "toggle sensitive flag", %{conn: conn, id: id, admin: admin} do
  56       response =
  57         conn
  58         |> put_req_header("content-type", "application/json")
  59         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
  60         |> json_response_and_validate_schema(:ok)
  61
  62       assert response["sensitive"]
  63
  64       log_entry = Repo.one(ModerationLog)
  65
  66       assert ModerationLog.get_log_entry_message(log_entry) ==
  67                "@#{admin.nickname} updated status ##{id}, set sensitive: 'true'"
  68
  69       response =
  70         conn
  71         |> put_req_header("content-type", "application/json")
  72         |> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
  73         |> json_response_and_validate_schema(:ok)
  74
  75       refute response["sensitive"]
  76     end
  77
  78     test "change visibility flag", %{conn: conn, id: id, admin: admin} do
  79       response =
  80         conn
  81         |> put_req_header("content-type", "application/json")
  82         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "public"})
  83         |> json_response_and_validate_schema(:ok)
  84
  85       assert response["visibility"] == "public"
  86
  87       log_entry = Repo.one(ModerationLog)
  88
  89       assert ModerationLog.get_log_entry_message(log_entry) ==
  90                "@#{admin.nickname} updated status ##{id}, set visibility: 'public'"
  91
  92       response =
  93         conn
  94         |> put_req_header("content-type", "application/json")
  95         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "private"})
  96         |> json_response_and_validate_schema(:ok)
  97
  98       assert response["visibility"] == "private"
  99
 100       response =
 101         conn
 102         |> put_req_header("content-type", "application/json")
 103         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "unlisted"})
 104         |> json_response_and_validate_schema(:ok)
 105
 106       assert response["visibility"] == "unlisted"
 107     end
 108
 109     test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
 110       conn =
 111         conn
 112         |> put_req_header("content-type", "application/json")
 113         |> put("/api/pleroma/admin/statuses/#{id}", %{visibility: "test"})
 114
 115       assert %{"error" => "test - Invalid value for enum."} =
 116                json_response_and_validate_schema(conn, :bad_request)
 117     end
 118   end
 119
 120   describe "DELETE /api/pleroma/admin/statuses/:id" do
 121     setup do
 122       activity = insert(:note_activity)
 123
 124       %{id: activity.id}
 125     end
 126
 127     test "deletes status", %{conn: conn, id: id, admin: admin} do
 128       conn
 129       |> delete("/api/pleroma/admin/statuses/#{id}")
 130       |> json_response_and_validate_schema(:ok)
 131
 132       refute Activity.get_by_id(id)
 133
 134       log_entry = Repo.one(ModerationLog)
 135
 136       assert ModerationLog.get_log_entry_message(log_entry) ==
 137                "@#{admin.nickname} deleted status ##{id}"
 138     end
 139
 140     test "returns 404 when the status does not exist", %{conn: conn} do
 141       conn = delete(conn, "/api/pleroma/admin/statuses/test")
 142
 143       assert json_response_and_validate_schema(conn, :not_found) == %{"error" => "Not found"}
 144     end
 145   end
 146
 147   describe "GET /api/pleroma/admin/statuses" do
 148     test "returns all public and unlisted statuses", %{conn: conn, admin: admin} do
 149       blocked = insert(:user)
 150       user = insert(:user)
 151       User.block(admin, blocked)
 152
 153       {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
 154
 155       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "unlisted"})
 156       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
 157       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 158       {:ok, _} = CommonAPI.post(blocked, %{status: ".", visibility: "public"})
 159
 160       response =
 161         conn
 162         |> get("/api/pleroma/admin/statuses")
 163         |> json_response_and_validate_schema(200)
 164
 165       refute "private" in Enum.map(response, & &1["visibility"])
 166       assert length(response) == 3
 167     end
 168
 169     test "returns only local statuses with local_only on", %{conn: conn} do
 170       user = insert(:user)
 171       remote_user = insert(:user, local: false, nickname: "archaeme@archae.me")
 172       insert(:note_activity, user: user, local: true)
 173       insert(:note_activity, user: remote_user, local: false)
 174
 175       response =
 176         conn
 177         |> get("/api/pleroma/admin/statuses?local_only=true")
 178         |> json_response_and_validate_schema(200)
 179
 180       assert length(response) == 1
 181     end
 182
 183     test "returns private and direct statuses with godmode on", %{conn: conn, admin: admin} do
 184       user = insert(:user)
 185
 186       {:ok, _} = CommonAPI.post(user, %{status: "@#{admin.nickname}", visibility: "direct"})
 187
 188       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "private"})
 189       {:ok, _} = CommonAPI.post(user, %{status: ".", visibility: "public"})
 190       conn = get(conn, "/api/pleroma/admin/statuses?godmode=true")
 191       assert json_response_and_validate_schema(conn, 200) |> length() == 3
 192     end
 193   end
 194 end