First
[anni] / 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