git.squeep.com Git - akkoma/blob - test/web/pleroma_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 defmodule Pleroma.Web.PleromaAPI.ChatControllerTest do
   5   use Pleroma.Web.ConnCase, async: true
   6
   7   alias Pleroma.Chat
   8   alias Pleroma.Chat.MessageReference
   9   alias Pleroma.Object
  10   alias Pleroma.User
  11   alias Pleroma.Web.ActivityPub.ActivityPub
  12   alias Pleroma.Web.CommonAPI
  13
  14   import Pleroma.Factory
  15
  16   describe "POST /api/v1/pleroma/chats/:id/messages/:message_id/read" do
  17     setup do: oauth_access(["write:chats"])
  18
  19     test "it marks one message as read", %{conn: conn, user: user} do
  20       other_user = insert(:user)
  21
  22       {:ok, create} = CommonAPI.post_chat_message(other_user, user, "sup")
  23       {:ok, _create} = CommonAPI.post_chat_message(other_user, user, "sup part 2")
  24       {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
  25       object = Object.normalize(create, false)
  26       cm_ref = MessageReference.for_chat_and_object(chat, object)
  27
  28       assert cm_ref.unread == true
  29
  30       result =
  31         conn
  32         |> post("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}/read")
  33         |> json_response_and_validate_schema(200)
  34
  35       assert result["unread"] == false
  36
  37       cm_ref = MessageReference.for_chat_and_object(chat, object)
  38
  39       assert cm_ref.unread == false
  40     end
  41   end
  42
  43   describe "POST /api/v1/pleroma/chats/:id/read" do
  44     setup do: oauth_access(["write:chats"])
  45
  46     test "given a `last_read_id`, it marks everything until then as read", %{
  47       conn: conn,
  48       user: user
  49     } do
  50       other_user = insert(:user)
  51
  52       {:ok, create} = CommonAPI.post_chat_message(other_user, user, "sup")
  53       {:ok, _create} = CommonAPI.post_chat_message(other_user, user, "sup part 2")
  54       {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
  55       object = Object.normalize(create, false)
  56       cm_ref = MessageReference.for_chat_and_object(chat, object)
  57
  58       assert cm_ref.unread == true
  59
  60       result =
  61         conn
  62         |> put_req_header("content-type", "application/json")
  63         |> post("/api/v1/pleroma/chats/#{chat.id}/read", %{"last_read_id" => cm_ref.id})
  64         |> json_response_and_validate_schema(200)
  65
  66       assert result["unread"] == 1
  67
  68       cm_ref = MessageReference.for_chat_and_object(chat, object)
  69
  70       assert cm_ref.unread == false
  71     end
  72   end
  73
  74   describe "POST /api/v1/pleroma/chats/:id/messages" do
  75     setup do: oauth_access(["write:chats"])
  76
  77     test "it posts a message to the chat", %{conn: conn, user: user} do
  78       other_user = insert(:user)
  79
  80       {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
  81
  82       result =
  83         conn
  84         |> put_req_header("content-type", "application/json")
  85         |> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{"content" => "Hallo!!"})
  86         |> json_response_and_validate_schema(200)
  87
  88       assert result["content"] == "Hallo!!"
  89       assert result["chat_id"] == chat.id |> to_string()
  90     end
  91
  92     test "it fails if there is no content", %{conn: conn, user: user} do
  93       other_user = insert(:user)
  94
  95       {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
  96
  97       result =
  98         conn
  99         |> put_req_header("content-type", "application/json")
 100         |> post("/api/v1/pleroma/chats/#{chat.id}/messages")
 101         |> json_response_and_validate_schema(400)
 102
 103       assert result
 104     end
 105
 106     test "it works with an attachment", %{conn: conn, user: user} do
 107       file = %Plug.Upload{
 108         content_type: "image/jpg",
 109         path: Path.absname("test/fixtures/image.jpg"),
 110         filename: "an_image.jpg"
 111       }
 112
 113       {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
 114
 115       other_user = insert(:user)
 116
 117       {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
 118
 119       result =
 120         conn
 121         |> put_req_header("content-type", "application/json")
 122         |> post("/api/v1/pleroma/chats/#{chat.id}/messages", %{
 123           "media_id" => to_string(upload.id)
 124         })
 125         |> json_response_and_validate_schema(200)
 126
 127       assert result["attachment"]
 128     end
 129   end
 130
 131   describe "DELETE /api/v1/pleroma/chats/:id/messages/:message_id" do
 132     setup do: oauth_access(["write:chats"])
 133
 134     test "it deletes a message from the chat", %{conn: conn, user: user} do
 135       recipient = insert(:user)
 136
 137       {:ok, message} =
 138         CommonAPI.post_chat_message(user, recipient, "Hello darkness my old friend")
 139
 140       {:ok, other_message} = CommonAPI.post_chat_message(recipient, user, "nico nico ni")
 141
 142       object = Object.normalize(message, false)
 143
 144       chat = Chat.get(user.id, recipient.ap_id)
 145
 146       cm_ref = MessageReference.for_chat_and_object(chat, object)
 147
 148       # Deleting your own message removes the message and the reference
 149       result =
 150         conn
 151         |> put_req_header("content-type", "application/json")
 152         |> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
 153         |> json_response_and_validate_schema(200)
 154
 155       assert result["id"] == cm_ref.id
 156       refute MessageReference.get_by_id(cm_ref.id)
 157       assert %{data: %{"type" => "Tombstone"}} = Object.get_by_id(object.id)
 158
 159       # Deleting other people's messages just removes the reference
 160       object = Object.normalize(other_message, false)
 161       cm_ref = MessageReference.for_chat_and_object(chat, object)
 162
 163       result =
 164         conn
 165         |> put_req_header("content-type", "application/json")
 166         |> delete("/api/v1/pleroma/chats/#{chat.id}/messages/#{cm_ref.id}")
 167         |> json_response_and_validate_schema(200)
 168
 169       assert result["id"] == cm_ref.id
 170       refute MessageReference.get_by_id(cm_ref.id)
 171       assert Object.get_by_id(object.id)
 172     end
 173   end
 174
 175   describe "GET /api/v1/pleroma/chats/:id/messages" do
 176     setup do: oauth_access(["read:chats"])
 177
 178     test "it paginates", %{conn: conn, user: user} do
 179       recipient = insert(:user)
 180
 181       Enum.each(1..30, fn _ ->
 182         {:ok, _} = CommonAPI.post_chat_message(user, recipient, "hey")
 183       end)
 184
 185       chat = Chat.get(user.id, recipient.ap_id)
 186
 187       result =
 188         conn
 189         |> get("/api/v1/pleroma/chats/#{chat.id}/messages")
 190         |> json_response_and_validate_schema(200)
 191
 192       assert length(result) == 20
 193
 194       result =
 195         conn
 196         |> get("/api/v1/pleroma/chats/#{chat.id}/messages?max_id=#{List.last(result)["id"]}")
 197         |> json_response_and_validate_schema(200)
 198
 199       assert length(result) == 10
 200     end
 201
 202     test "it returns the messages for a given chat", %{conn: conn, user: user} do
 203       other_user = insert(:user)
 204       third_user = insert(:user)
 205
 206       {:ok, _} = CommonAPI.post_chat_message(user, other_user, "hey")
 207       {:ok, _} = CommonAPI.post_chat_message(user, third_user, "hey")
 208       {:ok, _} = CommonAPI.post_chat_message(user, other_user, "how are you?")
 209       {:ok, _} = CommonAPI.post_chat_message(other_user, user, "fine, how about you?")
 210
 211       chat = Chat.get(user.id, other_user.ap_id)
 212
 213       result =
 214         conn
 215         |> get("/api/v1/pleroma/chats/#{chat.id}/messages")
 216         |> json_response_and_validate_schema(200)
 217
 218       result
 219       |> Enum.each(fn message ->
 220         assert message["chat_id"] == chat.id |> to_string()
 221       end)
 222
 223       assert length(result) == 3
 224
 225       # Trying to get the chat of a different user
 226       result =
 227         conn
 228         |> assign(:user, other_user)
 229         |> get("/api/v1/pleroma/chats/#{chat.id}/messages")
 230
 231       assert result |> json_response(404)
 232     end
 233   end
 234
 235   describe "POST /api/v1/pleroma/chats/by-account-id/:id" do
 236     setup do: oauth_access(["write:chats"])
 237
 238     test "it creates or returns a chat", %{conn: conn} do
 239       other_user = insert(:user)
 240
 241       result =
 242         conn
 243         |> post("/api/v1/pleroma/chats/by-account-id/#{other_user.id}")
 244         |> json_response_and_validate_schema(200)
 245
 246       assert result["id"]
 247     end
 248   end
 249
 250   describe "GET /api/v1/pleroma/chats/:id" do
 251     setup do: oauth_access(["read:chats"])
 252
 253     test "it returns a chat", %{conn: conn, user: user} do
 254       other_user = insert(:user)
 255
 256       {:ok, chat} = Chat.get_or_create(user.id, other_user.ap_id)
 257
 258       result =
 259         conn
 260         |> get("/api/v1/pleroma/chats/#{chat.id}")
 261         |> json_response_and_validate_schema(200)
 262
 263       assert result["id"] == to_string(chat.id)
 264     end
 265   end
 266
 267   describe "GET /api/v1/pleroma/chats" do
 268     setup do: oauth_access(["read:chats"])
 269
 270     test "it does not return chats with users you blocked", %{conn: conn, user: user} do
 271       recipient = insert(:user)
 272
 273       {:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)
 274
 275       result =
 276         conn
 277         |> get("/api/v1/pleroma/chats")
 278         |> json_response_and_validate_schema(200)
 279
 280       assert length(result) == 1
 281
 282       User.block(user, recipient)
 283
 284       result =
 285         conn
 286         |> get("/api/v1/pleroma/chats")
 287         |> json_response_and_validate_schema(200)
 288
 289       assert length(result) == 0
 290     end
 291
 292     test "it returns all chats", %{conn: conn, user: user} do
 293       Enum.each(1..30, fn _ ->
 294         recipient = insert(:user)
 295         {:ok, _} = Chat.get_or_create(user.id, recipient.ap_id)
 296       end)
 297
 298       result =
 299         conn
 300         |> get("/api/v1/pleroma/chats")
 301         |> json_response_and_validate_schema(200)
 302
 303       assert length(result) == 30
 304     end
 305
 306     test "it return a list of chats the current user is participating in, in descending order of updates",
 307          %{conn: conn, user: user} do
 308       har = insert(:user)
 309       jafnhar = insert(:user)
 310       tridi = insert(:user)
 311
 312       {:ok, chat_1} = Chat.get_or_create(user.id, har.ap_id)
 313       :timer.sleep(1000)
 314       {:ok, _chat_2} = Chat.get_or_create(user.id, jafnhar.ap_id)
 315       :timer.sleep(1000)
 316       {:ok, chat_3} = Chat.get_or_create(user.id, tridi.ap_id)
 317       :timer.sleep(1000)
 318
 319       # bump the second one
 320       {:ok, chat_2} = Chat.bump_or_create(user.id, jafnhar.ap_id)
 321
 322       result =
 323         conn
 324         |> get("/api/v1/pleroma/chats")
 325         |> json_response_and_validate_schema(200)
 326
 327       ids = Enum.map(result, & &1["id"])
 328
 329       assert ids == [
 330                chat_2.id |> to_string(),
 331                chat_3.id |> to_string(),
 332                chat_1.id |> to_string()
 333              ]
 334     end
 335   end
 336 end