git.squeep.com Git - akkoma/blob - test/conversation_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.ConversationTest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Activity
   8   alias Pleroma.Conversation
   9   alias Pleroma.Object
  10   alias Pleroma.Web.CommonAPI
  11
  12   import Pleroma.Factory
  13
  14   test "it creates a conversation for given ap_id" do
  15     assert {:ok, %Conversation{} = conversation} =
  16              Conversation.create_for_ap_id("https://some_ap_id")
  17
  18     # Inserting again returns the same
  19     assert {:ok, conversation_two} = Conversation.create_for_ap_id("https://some_ap_id")
  20     assert conversation_two.id == conversation.id
  21   end
  22
  23   test "public posts don't create conversations" do
  24     user = insert(:user)
  25     {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey"})
  26
  27     object = Pleroma.Object.normalize(activity)
  28     context = object.data["context"]
  29
  30     conversation = Conversation.get_for_ap_id(context)
  31
  32     refute conversation
  33   end
  34
  35   test "it creates or updates a conversation and participations for a given DM" do
  36     har = insert(:user)
  37     jafnhar = insert(:user, local: false)
  38     tridi = insert(:user)
  39
  40     {:ok, activity} =
  41       CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
  42
  43     object = Pleroma.Object.normalize(activity)
  44     context = object.data["context"]
  45
  46     conversation =
  47       Conversation.get_for_ap_id(context)
  48       |> Repo.preload(:participations)
  49
  50     assert conversation
  51
  52     assert Enum.find(conversation.participations, fn %{user_id: user_id} -> har.id == user_id end)
  53
  54     assert Enum.find(conversation.participations, fn %{user_id: user_id} ->
  55              jafnhar.id == user_id
  56            end)
  57
  58     {:ok, activity} =
  59       CommonAPI.post(jafnhar, %{
  60         "status" => "Hey @#{har.nickname}",
  61         "visibility" => "direct",
  62         "in_reply_to_status_id" => activity.id
  63       })
  64
  65     object = Pleroma.Object.normalize(activity)
  66     context = object.data["context"]
  67
  68     conversation_two =
  69       Conversation.get_for_ap_id(context)
  70       |> Repo.preload(:participations)
  71
  72     assert conversation_two.id == conversation.id
  73
  74     assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
  75              har.id == user_id
  76            end)
  77
  78     assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
  79              jafnhar.id == user_id
  80            end)
  81
  82     {:ok, activity} =
  83       CommonAPI.post(tridi, %{
  84         "status" => "Hey @#{har.nickname}",
  85         "visibility" => "direct",
  86         "in_reply_to_status_id" => activity.id
  87       })
  88
  89     object = Pleroma.Object.normalize(activity)
  90     context = object.data["context"]
  91
  92     conversation_three =
  93       Conversation.get_for_ap_id(context)
  94       |> Repo.preload([:participations, :users])
  95
  96     assert conversation_three.id == conversation.id
  97
  98     assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
  99              har.id == user_id
 100            end)
 101
 102     assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
 103              jafnhar.id == user_id
 104            end)
 105
 106     assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
 107              tridi.id == user_id
 108            end)
 109
 110     assert Enum.find(conversation_three.users, fn %{id: user_id} ->
 111              har.id == user_id
 112            end)
 113
 114     assert Enum.find(conversation_three.users, fn %{id: user_id} ->
 115              jafnhar.id == user_id
 116            end)
 117
 118     assert Enum.find(conversation_three.users, fn %{id: user_id} ->
 119              tridi.id == user_id
 120            end)
 121   end
 122
 123   test "create_or_bump_for returns the conversation with participations" do
 124     har = insert(:user)
 125     jafnhar = insert(:user, local: false)
 126
 127     {:ok, activity} =
 128       CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
 129
 130     {:ok, conversation} = Conversation.create_or_bump_for(activity)
 131
 132     assert length(conversation.participations) == 2
 133
 134     {:ok, activity} =
 135       CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "public"})
 136
 137     assert {:error, _} = Conversation.create_or_bump_for(activity)
 138   end
 139
 140   test "create_or_bump_for does not normalize objects before checking the activity type" do
 141     note = insert(:note)
 142     note_id = note.data["id"]
 143     Repo.delete(note)
 144     refute Object.get_by_ap_id(note_id)
 145
 146     Tesla.Mock.mock(fn env ->
 147       case env.url do
 148         ^note_id ->
 149           # TODO: add attributedTo and tag to the note factory
 150           body =
 151             note.data
 152             |> Map.put("attributedTo", note.data["actor"])
 153             |> Map.put("tag", [])
 154             |> Jason.encode!()
 155
 156           %Tesla.Env{status: 200, body: body}
 157       end
 158     end)
 159
 160     undo = %Activity{
 161       id: "fake",
 162       data: %{
 163         "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
 164         "actor" => note.data["actor"],
 165         "to" => [note.data["actor"]],
 166         "object" => note_id,
 167         "type" => "Undo"
 168       }
 169     }
 170
 171     Conversation.create_or_bump_for(undo)
 172
 173     refute Object.get_by_ap_id(note_id)
 174   end
 175 end