git.squeep.com Git - akkoma/blob - test/web/admin_api/controllers/report_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.ReportControllerTest 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.ReportNote
  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/reports/:id" do
  30     test "returns report by its id", %{conn: conn} do
  31       [reporter, target_user] = insert_pair(:user)
  32       activity = insert(:note_activity, user: target_user)
  33
  34       {:ok, %{id: report_id}} =
  35         CommonAPI.report(reporter, %{
  36           account_id: target_user.id,
  37           comment: "I feel offended",
  38           status_ids: [activity.id]
  39         })
  40
  41       response =
  42         conn
  43         |> get("/api/pleroma/admin/reports/#{report_id}")
  44         |> json_response(:ok)
  45
  46       assert response["id"] == report_id
  47     end
  48
  49     test "returns 404 when report id is invalid", %{conn: conn} do
  50       conn = get(conn, "/api/pleroma/admin/reports/test")
  51
  52       assert json_response(conn, :not_found) == %{"error" => "Not found"}
  53     end
  54   end
  55
  56   describe "PATCH /api/pleroma/admin/reports" do
  57     setup do
  58       [reporter, target_user] = insert_pair(:user)
  59       activity = insert(:note_activity, user: target_user)
  60
  61       {:ok, %{id: report_id}} =
  62         CommonAPI.report(reporter, %{
  63           account_id: target_user.id,
  64           comment: "I feel offended",
  65           status_ids: [activity.id]
  66         })
  67
  68       {:ok, %{id: second_report_id}} =
  69         CommonAPI.report(reporter, %{
  70           account_id: target_user.id,
  71           comment: "I feel very offended",
  72           status_ids: [activity.id]
  73         })
  74
  75       %{
  76         id: report_id,
  77         second_report_id: second_report_id
  78       }
  79     end
  80
  81     test "requires admin:write:reports scope", %{conn: conn, id: id, admin: admin} do
  82       read_token = insert(:oauth_token, user: admin, scopes: ["admin:read"])
  83       write_token = insert(:oauth_token, user: admin, scopes: ["admin:write:reports"])
  84
  85       response =
  86         conn
  87         |> assign(:token, read_token)
  88         |> patch("/api/pleroma/admin/reports", %{
  89           "reports" => [%{"state" => "resolved", "id" => id}]
  90         })
  91         |> json_response(403)
  92
  93       assert response == %{
  94                "error" => "Insufficient permissions: admin:write:reports."
  95              }
  96
  97       conn
  98       |> assign(:token, write_token)
  99       |> patch("/api/pleroma/admin/reports", %{
 100         "reports" => [%{"state" => "resolved", "id" => id}]
 101       })
 102       |> json_response(:no_content)
 103     end
 104
 105     test "mark report as resolved", %{conn: conn, id: id, admin: admin} do
 106       conn
 107       |> patch("/api/pleroma/admin/reports", %{
 108         "reports" => [
 109           %{"state" => "resolved", "id" => id}
 110         ]
 111       })
 112       |> json_response(:no_content)
 113
 114       activity = Activity.get_by_id(id)
 115       assert activity.data["state"] == "resolved"
 116
 117       log_entry = Repo.one(ModerationLog)
 118
 119       assert ModerationLog.get_log_entry_message(log_entry) ==
 120                "@#{admin.nickname} updated report ##{id} with 'resolved' state"
 121     end
 122
 123     test "closes report", %{conn: conn, id: id, admin: admin} do
 124       conn
 125       |> patch("/api/pleroma/admin/reports", %{
 126         "reports" => [
 127           %{"state" => "closed", "id" => id}
 128         ]
 129       })
 130       |> json_response(:no_content)
 131
 132       activity = Activity.get_by_id(id)
 133       assert activity.data["state"] == "closed"
 134
 135       log_entry = Repo.one(ModerationLog)
 136
 137       assert ModerationLog.get_log_entry_message(log_entry) ==
 138                "@#{admin.nickname} updated report ##{id} with 'closed' state"
 139     end
 140
 141     test "returns 400 when state is unknown", %{conn: conn, id: id} do
 142       conn =
 143         conn
 144         |> patch("/api/pleroma/admin/reports", %{
 145           "reports" => [
 146             %{"state" => "test", "id" => id}
 147           ]
 148         })
 149
 150       assert hd(json_response(conn, :bad_request))["error"] == "Unsupported state"
 151     end
 152
 153     test "returns 404 when report is not exist", %{conn: conn} do
 154       conn =
 155         conn
 156         |> patch("/api/pleroma/admin/reports", %{
 157           "reports" => [
 158             %{"state" => "closed", "id" => "test"}
 159           ]
 160         })
 161
 162       assert hd(json_response(conn, :bad_request))["error"] == "not_found"
 163     end
 164
 165     test "updates state of multiple reports", %{
 166       conn: conn,
 167       id: id,
 168       admin: admin,
 169       second_report_id: second_report_id
 170     } do
 171       conn
 172       |> patch("/api/pleroma/admin/reports", %{
 173         "reports" => [
 174           %{"state" => "resolved", "id" => id},
 175           %{"state" => "closed", "id" => second_report_id}
 176         ]
 177       })
 178       |> json_response(:no_content)
 179
 180       activity = Activity.get_by_id(id)
 181       second_activity = Activity.get_by_id(second_report_id)
 182       assert activity.data["state"] == "resolved"
 183       assert second_activity.data["state"] == "closed"
 184
 185       [first_log_entry, second_log_entry] = Repo.all(ModerationLog)
 186
 187       assert ModerationLog.get_log_entry_message(first_log_entry) ==
 188                "@#{admin.nickname} updated report ##{id} with 'resolved' state"
 189
 190       assert ModerationLog.get_log_entry_message(second_log_entry) ==
 191                "@#{admin.nickname} updated report ##{second_report_id} with 'closed' state"
 192     end
 193   end
 194
 195   describe "GET /api/pleroma/admin/reports" do
 196     test "returns empty response when no reports created", %{conn: conn} do
 197       response =
 198         conn
 199         |> get("/api/pleroma/admin/reports")
 200         |> json_response(:ok)
 201
 202       assert Enum.empty?(response["reports"])
 203       assert response["total"] == 0
 204     end
 205
 206     test "returns reports", %{conn: conn} do
 207       [reporter, target_user] = insert_pair(:user)
 208       activity = insert(:note_activity, user: target_user)
 209
 210       {:ok, %{id: report_id}} =
 211         CommonAPI.report(reporter, %{
 212           account_id: target_user.id,
 213           comment: "I feel offended",
 214           status_ids: [activity.id]
 215         })
 216
 217       response =
 218         conn
 219         |> get("/api/pleroma/admin/reports")
 220         |> json_response(:ok)
 221
 222       [report] = response["reports"]
 223
 224       assert length(response["reports"]) == 1
 225       assert report["id"] == report_id
 226
 227       assert response["total"] == 1
 228     end
 229
 230     test "returns reports with specified state", %{conn: conn} do
 231       [reporter, target_user] = insert_pair(:user)
 232       activity = insert(:note_activity, user: target_user)
 233
 234       {:ok, %{id: first_report_id}} =
 235         CommonAPI.report(reporter, %{
 236           account_id: target_user.id,
 237           comment: "I feel offended",
 238           status_ids: [activity.id]
 239         })
 240
 241       {:ok, %{id: second_report_id}} =
 242         CommonAPI.report(reporter, %{
 243           account_id: target_user.id,
 244           comment: "I don't like this user"
 245         })
 246
 247       CommonAPI.update_report_state(second_report_id, "closed")
 248
 249       response =
 250         conn
 251         |> get("/api/pleroma/admin/reports", %{
 252           "state" => "open"
 253         })
 254         |> json_response(:ok)
 255
 256       [open_report] = response["reports"]
 257
 258       assert length(response["reports"]) == 1
 259       assert open_report["id"] == first_report_id
 260
 261       assert response["total"] == 1
 262
 263       response =
 264         conn
 265         |> get("/api/pleroma/admin/reports", %{
 266           "state" => "closed"
 267         })
 268         |> json_response(:ok)
 269
 270       [closed_report] = response["reports"]
 271
 272       assert length(response["reports"]) == 1
 273       assert closed_report["id"] == second_report_id
 274
 275       assert response["total"] == 1
 276
 277       response =
 278         conn
 279         |> get("/api/pleroma/admin/reports", %{
 280           "state" => "resolved"
 281         })
 282         |> json_response(:ok)
 283
 284       assert Enum.empty?(response["reports"])
 285       assert response["total"] == 0
 286     end
 287
 288     test "returns 403 when requested by a non-admin" do
 289       user = insert(:user)
 290       token = insert(:oauth_token, user: user)
 291
 292       conn =
 293         build_conn()
 294         |> assign(:user, user)
 295         |> assign(:token, token)
 296         |> get("/api/pleroma/admin/reports")
 297
 298       assert json_response(conn, :forbidden) ==
 299                %{"error" => "User is not an admin or OAuth admin scope is not granted."}
 300     end
 301
 302     test "returns 403 when requested by anonymous" do
 303       conn = get(build_conn(), "/api/pleroma/admin/reports")
 304
 305       assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
 306     end
 307   end
 308
 309   describe "POST /api/pleroma/admin/reports/:id/notes" do
 310     setup %{conn: conn, admin: admin} do
 311       [reporter, target_user] = insert_pair(:user)
 312       activity = insert(:note_activity, user: target_user)
 313
 314       {:ok, %{id: report_id}} =
 315         CommonAPI.report(reporter, %{
 316           account_id: target_user.id,
 317           comment: "I feel offended",
 318           status_ids: [activity.id]
 319         })
 320
 321       post(conn, "/api/pleroma/admin/reports/#{report_id}/notes", %{
 322         content: "this is disgusting!"
 323       })
 324
 325       post(conn, "/api/pleroma/admin/reports/#{report_id}/notes", %{
 326         content: "this is disgusting2!"
 327       })
 328
 329       %{
 330         admin_id: admin.id,
 331         report_id: report_id
 332       }
 333     end
 334
 335     test "it creates report note", %{admin_id: admin_id, report_id: report_id} do
 336       [note, _] = Repo.all(ReportNote)
 337
 338       assert %{
 339                activity_id: ^report_id,
 340                content: "this is disgusting!",
 341                user_id: ^admin_id
 342              } = note
 343     end
 344
 345     test "it returns reports with notes", %{conn: conn, admin: admin} do
 346       conn = get(conn, "/api/pleroma/admin/reports")
 347
 348       response = json_response(conn, 200)
 349       notes = hd(response["reports"])["notes"]
 350       [note, _] = notes
 351
 352       assert note["user"]["nickname"] == admin.nickname
 353       assert note["content"] == "this is disgusting!"
 354       assert note["created_at"]
 355       assert response["total"] == 1
 356     end
 357
 358     test "it deletes the note", %{conn: conn, report_id: report_id} do
 359       assert ReportNote |> Repo.all() |> length() == 2
 360
 361       [note, _] = Repo.all(ReportNote)
 362
 363       delete(conn, "/api/pleroma/admin/reports/#{report_id}/notes/#{note.id}")
 364
 365       assert ReportNote |> Repo.all() |> length() == 1
 366     end
 367   end
 368 end