1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.MastodonAPI.FilterControllerTest do
6 use Pleroma.Web.ConnCase, async: false
7 use Oban.Testing, repo: Pleroma.Repo
10 import Pleroma.Factory
14 alias Pleroma.Workers.PurgeExpiredFilter
16 test "non authenticated creation request", %{conn: conn} do
19 |> put_req_header("content-type", "application/json")
20 |> post("/api/v1/filters", %{"phrase" => "knights", context: ["home"]})
23 assert response["error"] == "Invalid credentials."
26 describe "creating" do
27 setup do: oauth_access(["write:filters"])
29 test "a common filter", %{conn: conn, user: user} do
38 |> put_req_header("content-type", "application/json")
39 |> post("/api/v1/filters", params)
40 |> json_response_and_validate_schema(200)
42 assert response["phrase"] == params.phrase
43 assert response["context"] == params.context
44 assert response["irreversible"] == true
45 assert response["id"] != nil
46 assert response["id"] != ""
47 assert response["expires_at"] == nil
49 filter = Filter.get(response["id"], user)
50 assert filter.hide == true
53 test "a filter with expires_in", %{conn: conn, user: user} do
57 with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
59 |> put_req_header("content-type", "application/json")
60 |> post("/api/v1/filters", %{
61 "phrase" => "knights",
63 expires_in: in_seconds
65 |> json_response_and_validate_schema(200)
68 assert response["irreversible"] == false
70 assert response["expires_at"] == "2017-03-17T17:19:58.000Z"
72 filter = Filter.get(response["id"], user)
77 worker: PurgeExpiredFilter,
78 args: %{filter_id: filter.id}
81 assert {:ok, %{id: ^id}} =
82 perform_job(PurgeExpiredFilter, %{
86 assert Repo.aggregate(Filter, :count, :id) == 0
90 test "fetching a list of filters" do
91 %{user: user, conn: conn} = oauth_access(["read:filters"])
93 %{filter_id: id1} = insert(:filter, user: user)
94 %{filter_id: id2} = insert(:filter, user: user)
99 assert [%{"id" => ^id2}, %{"id" => ^id1}] =
101 |> get("/api/v1/filters")
102 |> json_response_and_validate_schema(200)
105 test "fetching a list of filters without token", %{conn: conn} do
110 |> get("/api/v1/filters")
111 |> json_response(403)
113 assert response["error"] == "Invalid credentials."
116 test "get a filter" do
117 %{user: user, conn: conn} = oauth_access(["read:filters"])
119 # check whole_word false
120 filter = insert(:filter, user: user, whole_word: false)
123 conn |> get("/api/v1/filters/#{filter.filter_id}") |> json_response_and_validate_schema(200)
125 assert resp1["whole_word"] == false
127 # check whole_word true
128 filter = insert(:filter, user: user, whole_word: true)
131 conn |> get("/api/v1/filters/#{filter.filter_id}") |> json_response_and_validate_schema(200)
133 assert resp2["whole_word"] == true
136 test "get a filter not_found error" do
137 filter = insert(:filter)
138 %{conn: conn} = oauth_access(["read:filters"])
141 conn |> get("/api/v1/filters/#{filter.filter_id}") |> json_response_and_validate_schema(404)
143 assert response["error"] == "Record not found"
146 describe "updating a filter" do
147 setup do: oauth_access(["write:filters"])
150 %{conn: conn, user: user} = oauth_access(["write:filters"])
167 |> put_req_header("content-type", "application/json")
168 |> put("/api/v1/filters/#{filter.filter_id}", params)
169 |> json_response_and_validate_schema(200)
171 assert response["phrase"] == params.phrase
172 assert response["context"] == params.context
173 assert response["irreversible"] == false
174 assert response["whole_word"] == true
177 test "with adding expires_at", %{conn: conn, user: user} do
178 filter = insert(:filter, user: user)
182 with_mock NaiveDateTime, [:passthrough], utc_now: fn -> ~N[2017-03-17 17:09:58] end do
184 |> put_req_header("content-type", "application/json")
185 |> put("/api/v1/filters/#{filter.filter_id}", %{
188 expires_in: in_seconds,
191 |> json_response_and_validate_schema(200)
194 assert response["irreversible"] == true
196 assert response["expires_at"] == "2017-03-17T17:19:58.000Z"
198 filter = Filter.get(response["id"], user)
203 worker: PurgeExpiredFilter,
204 args: %{filter_id: id}
207 assert {:ok, %{id: ^id}} =
208 perform_job(PurgeExpiredFilter, %{
212 assert Repo.aggregate(Filter, :count, :id) == 0
215 test "with removing expires_at", %{conn: conn, user: user} do
218 |> put_req_header("content-type", "application/json")
219 |> post("/api/v1/filters", %{
224 |> json_response_and_validate_schema(200)
226 filter = Filter.get(response["id"], user)
229 worker: PurgeExpiredFilter,
230 args: %{filter_id: filter.id}
235 |> put_req_header("content-type", "application/json")
236 |> put("/api/v1/filters/#{filter.filter_id}", %{
242 |> json_response_and_validate_schema(200)
245 worker: PurgeExpiredFilter,
246 args: %{filter_id: filter.id}
249 assert response["irreversible"] == false
250 assert response["whole_word"] == true
251 assert response["expires_at"] == nil
254 test "expires_at is the same in create and update so job is in db", %{conn: conn, user: user} do
257 |> put_req_header("content-type", "application/json")
258 |> post("/api/v1/filters", %{
263 |> json_response_and_validate_schema(200)
265 filter = Filter.get(resp1["id"], user)
268 worker: PurgeExpiredFilter,
269 args: %{filter_id: filter.id}
272 job = PurgeExpiredFilter.get_expiration(filter.id)
276 |> put_req_header("content-type", "application/json")
277 |> put("/api/v1/filters/#{filter.filter_id}", %{
281 |> json_response_and_validate_schema(200)
283 updated_filter = Filter.get(resp2["id"], user)
286 worker: PurgeExpiredFilter,
287 args: %{filter_id: updated_filter.id}
290 after_update = PurgeExpiredFilter.get_expiration(updated_filter.id)
292 assert resp1["expires_at"] == resp2["expires_at"]
294 assert job.scheduled_at == after_update.scheduled_at
297 test "updating expires_at updates oban job too", %{conn: conn, user: user} do
300 |> put_req_header("content-type", "application/json")
301 |> post("/api/v1/filters", %{
306 |> json_response_and_validate_schema(200)
308 filter = Filter.get(resp1["id"], user)
311 worker: PurgeExpiredFilter,
312 args: %{filter_id: filter.id}
315 job = PurgeExpiredFilter.get_expiration(filter.id)
319 |> put_req_header("content-type", "application/json")
320 |> put("/api/v1/filters/#{filter.filter_id}", %{
325 |> json_response_and_validate_schema(200)
327 updated_filter = Filter.get(resp2["id"], user)
330 worker: PurgeExpiredFilter,
331 args: %{filter_id: updated_filter.id}
334 after_update = PurgeExpiredFilter.get_expiration(updated_filter.id)
336 refute resp1["expires_at"] == resp2["expires_at"]
338 refute job.scheduled_at == after_update.scheduled_at
342 test "update filter without token", %{conn: conn} do
343 filter = insert(:filter)
347 |> put_req_header("content-type", "application/json")
348 |> put("/api/v1/filters/#{filter.filter_id}", %{
352 |> json_response(403)
354 assert response["error"] == "Invalid credentials."
357 describe "delete a filter" do
358 setup do: oauth_access(["write:filters"])
360 test "common", %{conn: conn, user: user} do
361 filter = insert(:filter, user: user)
364 |> delete("/api/v1/filters/#{filter.filter_id}")
365 |> json_response_and_validate_schema(200) == %{}
367 assert Repo.all(Filter) == []
370 test "with expires_at", %{conn: conn, user: user} do
373 |> put_req_header("content-type", "application/json")
374 |> post("/api/v1/filters", %{
379 |> json_response_and_validate_schema(200)
381 filter = Filter.get(response["id"], user)
384 worker: PurgeExpiredFilter,
385 args: %{filter_id: filter.id}
389 |> delete("/api/v1/filters/#{filter.filter_id}")
390 |> json_response_and_validate_schema(200) == %{}
393 worker: PurgeExpiredFilter,
394 args: %{filter_id: filter.id}
397 assert Repo.all(Filter) == []
398 assert Repo.all(Oban.Job) == []
402 test "delete a filter without token", %{conn: conn} do
403 filter = insert(:filter)
407 |> delete("/api/v1/filters/#{filter.filter_id}")
408 |> json_response(403)
410 assert response["error"] == "Invalid credentials."