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