git.squeep.com Git - akkoma/blob - test/web/admin_api/controllers/chat_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.ChatControllerTest do
   6   use Pleroma.Web.ConnCase
   7
   8   import Pleroma.Factory
   9
  10   alias Pleroma.Chat
  11   alias Pleroma.Chat.MessageReference
  12   alias Pleroma.Config
  13   alias Pleroma.ModerationLog
  14   alias Pleroma.Object
  15   alias Pleroma.Repo
  16   alias Pleroma.Web.CommonAPI
  17
  18   defp admin_setup do
  19     admin = insert(:user, is_admin: true)
  20     token = insert(:oauth_admin_token, user: admin)
  21
  22     conn =
  23       build_conn()
  24       |> assign(:user, admin)
  25       |> assign(:token, token)
  26
  27     {:ok, %{admin: admin, token: token, conn: conn}}
  28   end
  29
  30   describe "DELETE /api/pleroma/admin/chats/:id/messages/:message_id" do
  31     setup do: admin_setup()
  32
  33     test "it deletes a message from the chat", %{conn: conn, admin: admin} do
  34       user = insert(:user)
  35       recipient = insert(:user)
  36
  37       {:ok, message} =
  38         CommonAPI.post_chat_message(user, recipient, "Hello darkness my old friend")
  39
  40       object = Object.normalize(message, false)
  41
  42       chat = Chat.get(user.id, recipient.ap_id)
  43
  44       cm_ref = MessageReference.for_chat_and_object(chat, object)
  45
  46       result =
  47         conn
  48         |> put_req_header("content-type", "application/json")
  49         |> delete("/api/pleroma/admin/chats/#{chat.id}/messages/#{cm_ref.id}")
  50         |> json_response_and_validate_schema(200)
  51
  52       log_entry = Repo.one(ModerationLog)
  53
  54       assert ModerationLog.get_log_entry_message(log_entry) ==
  55                "@#{admin.nickname} deleted chat message ##{cm_ref.id}"
  56
  57       assert result["id"] == cm_ref.id
  58       refute MessageReference.get_by_id(cm_ref.id)
  59       assert %{data: %{"type" => "Tombstone"}} = Object.get_by_id(object.id)
  60     end
  61   end
  62
  63   describe "GET /api/pleroma/admin/chats/:id/messages" do
  64     setup do: admin_setup()
  65
  66     test "it paginates", %{conn: conn} do
  67       user = insert(:user)
  68       recipient = insert(:user)
  69
  70       Enum.each(1..30, fn _ ->
  71         {:ok, _} = CommonAPI.post_chat_message(user, recipient, "hey")
  72       end)
  73
  74       chat = Chat.get(user.id, recipient.ap_id)
  75
  76       result =
  77         conn
  78         |> get("/api/pleroma/admin/chats/#{chat.id}/messages")
  79         |> json_response_and_validate_schema(200)
  80
  81       assert length(result) == 20
  82
  83       result =
  84         conn
  85         |> get("/api/pleroma/admin/chats/#{chat.id}/messages?max_id=#{List.last(result)["id"]}")
  86         |> json_response_and_validate_schema(200)
  87
  88       assert length(result) == 10
  89     end
  90
  91     test "it returns the messages for a given chat", %{conn: conn} do
  92       user = insert(:user)
  93       other_user = insert(:user)
  94       third_user = insert(:user)
  95
  96       {:ok, _} = CommonAPI.post_chat_message(user, other_user, "hey")
  97       {:ok, _} = CommonAPI.post_chat_message(user, third_user, "hey")
  98       {:ok, _} = CommonAPI.post_chat_message(user, other_user, "how are you?")
  99       {:ok, _} = CommonAPI.post_chat_message(other_user, user, "fine, how about you?")
 100
 101       chat = Chat.get(user.id, other_user.ap_id)
 102
 103       result =
 104         conn
 105         |> get("/api/pleroma/admin/chats/#{chat.id}/messages")
 106         |> json_response_and_validate_schema(200)
 107
 108       result
 109       |> Enum.each(fn message ->
 110         assert message["chat_id"] == chat.id |> to_string()
 111       end)
 112
 113       assert length(result) == 3
 114     end
 115   end
 116
 117   describe "GET /api/pleroma/admin/chats/:id" do
 118     setup do: admin_setup()
 119
 120     test "it returns a chat", %{conn: conn} do
 121       user = insert(:user)
 122       other_user = insert(:user)
 123
 124       {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
 125
 126       result =
 127         conn
 128         |> get("/api/pleroma/admin/chats/#{chat.id}")
 129         |> json_response_and_validate_schema(200)
 130
 131       assert result["id"] == to_string(chat.id)
 132       assert %{} = result["sender"]
 133       assert %{} = result["receiver"]
 134       refute result["account"]
 135     end
 136   end
 137
 138   describe "unauthorized chat moderation" do
 139     setup do
 140       user = insert(:user)
 141       recipient = insert(:user)
 142
 143       {:ok, message} = CommonAPI.post_chat_message(user, recipient, "Yo")
 144       object = Object.normalize(message, false)
 145       chat = Chat.get(user.id, recipient.ap_id)
 146       cm_ref = MessageReference.for_chat_and_object(chat, object)
 147
 148       %{conn: conn} = oauth_access(["read:chats", "write:chats"])
 149       %{conn: conn, chat: chat, cm_ref: cm_ref}
 150     end
 151
 152     test "DELETE /api/pleroma/admin/chats/:id/messages/:message_id", %{
 153       conn: conn,
 154       chat: chat,
 155       cm_ref: cm_ref
 156     } do
 157       conn
 158       |> put_req_header("content-type", "application/json")
 159       |> delete("/api/pleroma/admin/chats/#{chat.id}/messages/#{cm_ref.id}")
 160       |> json_response(403)
 161
 162       assert MessageReference.get_by_id(cm_ref.id) == cm_ref
 163     end
 164
 165     test "GET /api/pleroma/admin/chats/:id/messages", %{conn: conn, chat: chat} do
 166       conn
 167       |> get("/api/pleroma/admin/chats/#{chat.id}/messages")
 168       |> json_response(403)
 169     end
 170
 171     test "GET /api/pleroma/admin/chats/:id", %{conn: conn, chat: chat} do
 172       conn
 173       |> get("/api/pleroma/admin/chats/#{chat.id}")
 174       |> json_response(403)
 175     end
 176   end
 177
 178   describe "unauthenticated chat moderation" do
 179     setup do
 180       user = insert(:user)
 181       recipient = insert(:user)
 182
 183       {:ok, message} = CommonAPI.post_chat_message(user, recipient, "Yo")
 184       object = Object.normalize(message, false)
 185       chat = Chat.get(user.id, recipient.ap_id)
 186       cm_ref = MessageReference.for_chat_and_object(chat, object)
 187
 188       %{conn: build_conn(), chat: chat, cm_ref: cm_ref}
 189     end
 190
 191     test "DELETE /api/pleroma/admin/chats/:id/messages/:message_id", %{
 192       conn: conn,
 193       chat: chat,
 194       cm_ref: cm_ref
 195     } do
 196       conn
 197       |> put_req_header("content-type", "application/json")
 198       |> delete("/api/pleroma/admin/chats/#{chat.id}/messages/#{cm_ref.id}")
 199       |> json_response(403)
 200
 201       assert MessageReference.get_by_id(cm_ref.id) == cm_ref
 202     end
 203
 204     test "GET /api/pleroma/admin/chats/:id/messages", %{conn: conn, chat: chat} do
 205       conn
 206       |> get("/api/pleroma/admin/chats/#{chat.id}/messages")
 207       |> json_response(403)
 208     end
 209
 210     test "GET /api/pleroma/admin/chats/:id", %{conn: conn, chat: chat} do
 211       conn
 212       |> get("/api/pleroma/admin/chats/#{chat.id}")
 213       |> json_response(403)
 214     end
 215   end
 216 end