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   setup_all do
  15     config_path = [:instance, :federating]
  16     initial_setting = Pleroma.Config.get(config_path)
  17
  18     Pleroma.Config.put(config_path, true)
  19     on_exit(fn -> Pleroma.Config.put(config_path, initial_setting) end)
  20
  21     :ok
  22   end
  23
  24   test "it goes through old direct conversations" do
  25     user = insert(:user)
  26     other_user = insert(:user)
  27
  28     {:ok, _activity} =
  29       CommonAPI.post(user, %{"visibility" => "direct", "status" => "hey @#{other_user.nickname}"})
  30
  31     Pleroma.Tests.ObanHelpers.perform_all()
  32
  33     Repo.delete_all(Conversation)
  34     Repo.delete_all(Conversation.Participation)
  35
  36     refute Repo.one(Conversation)
  37
  38     Conversation.bump_for_all_activities()
  39
  40     assert Repo.one(Conversation)
  41     [participation, _p2] = Repo.all(Conversation.Participation)
  42
  43     assert participation.read
  44   end
  45
  46   test "it creates a conversation for given ap_id" do
  47     assert {:ok, %Conversation{} = conversation} =
  48              Conversation.create_for_ap_id("https://some_ap_id")
  49
  50     # Inserting again returns the same
  51     assert {:ok, conversation_two} = Conversation.create_for_ap_id("https://some_ap_id")
  52     assert conversation_two.id == conversation.id
  53   end
  54
  55   test "public posts don't create conversations" do
  56     user = insert(:user)
  57     {:ok, activity} = CommonAPI.post(user, %{"status" => "Hey"})
  58
  59     object = Pleroma.Object.normalize(activity)
  60     context = object.data["context"]
  61
  62     conversation = Conversation.get_for_ap_id(context)
  63
  64     refute conversation
  65   end
  66
  67   test "it creates or updates a conversation and participations for a given DM" do
  68     har = insert(:user)
  69     jafnhar = insert(:user, local: false)
  70     tridi = insert(:user)
  71
  72     {:ok, activity} =
  73       CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
  74
  75     object = Pleroma.Object.normalize(activity)
  76     context = object.data["context"]
  77
  78     conversation =
  79       Conversation.get_for_ap_id(context)
  80       |> Repo.preload(:participations)
  81
  82     assert conversation
  83
  84     assert Enum.find(conversation.participations, fn %{user_id: user_id} -> har.id == user_id end)
  85
  86     assert Enum.find(conversation.participations, fn %{user_id: user_id} ->
  87              jafnhar.id == user_id
  88            end)
  89
  90     {:ok, activity} =
  91       CommonAPI.post(jafnhar, %{
  92         "status" => "Hey @#{har.nickname}",
  93         "visibility" => "direct",
  94         "in_reply_to_status_id" => activity.id
  95       })
  96
  97     object = Pleroma.Object.normalize(activity)
  98     context = object.data["context"]
  99
 100     conversation_two =
 101       Conversation.get_for_ap_id(context)
 102       |> Repo.preload(:participations)
 103
 104     assert conversation_two.id == conversation.id
 105
 106     assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
 107              har.id == user_id
 108            end)
 109
 110     assert Enum.find(conversation_two.participations, fn %{user_id: user_id} ->
 111              jafnhar.id == user_id
 112            end)
 113
 114     {:ok, activity} =
 115       CommonAPI.post(tridi, %{
 116         "status" => "Hey @#{har.nickname}",
 117         "visibility" => "direct",
 118         "in_reply_to_status_id" => activity.id
 119       })
 120
 121     object = Pleroma.Object.normalize(activity)
 122     context = object.data["context"]
 123
 124     conversation_three =
 125       Conversation.get_for_ap_id(context)
 126       |> Repo.preload([:participations, :users])
 127
 128     assert conversation_three.id == conversation.id
 129
 130     assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
 131              har.id == user_id
 132            end)
 133
 134     assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
 135              jafnhar.id == user_id
 136            end)
 137
 138     assert Enum.find(conversation_three.participations, fn %{user_id: user_id} ->
 139              tridi.id == user_id
 140            end)
 141
 142     assert Enum.find(conversation_three.users, fn %{id: user_id} ->
 143              har.id == user_id
 144            end)
 145
 146     assert Enum.find(conversation_three.users, fn %{id: user_id} ->
 147              jafnhar.id == user_id
 148            end)
 149
 150     assert Enum.find(conversation_three.users, fn %{id: user_id} ->
 151              tridi.id == user_id
 152            end)
 153   end
 154
 155   test "create_or_bump_for returns the conversation with participations" do
 156     har = insert(:user)
 157     jafnhar = insert(:user, local: false)
 158
 159     {:ok, activity} =
 160       CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "direct"})
 161
 162     {:ok, conversation} = Conversation.create_or_bump_for(activity)
 163
 164     assert length(conversation.participations) == 2
 165
 166     {:ok, activity} =
 167       CommonAPI.post(har, %{"status" => "Hey @#{jafnhar.nickname}", "visibility" => "public"})
 168
 169     assert {:error, _} = Conversation.create_or_bump_for(activity)
 170   end
 171
 172   test "create_or_bump_for does not normalize objects before checking the activity type" do
 173     note = insert(:note)
 174     note_id = note.data["id"]
 175     Repo.delete(note)
 176     refute Object.get_by_ap_id(note_id)
 177
 178     Tesla.Mock.mock(fn env ->
 179       case env.url do
 180         ^note_id ->
 181           # TODO: add attributedTo and tag to the note factory
 182           body =
 183             note.data
 184             |> Map.put("attributedTo", note.data["actor"])
 185             |> Map.put("tag", [])
 186             |> Jason.encode!()
 187
 188           %Tesla.Env{status: 200, body: body}
 189       end
 190     end)
 191
 192     undo = %Activity{
 193       id: "fake",
 194       data: %{
 195         "id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
 196         "actor" => note.data["actor"],
 197         "to" => [note.data["actor"]],
 198         "object" => note_id,
 199         "type" => "Undo"
 200       }
 201     }
 202
 203     Conversation.create_or_bump_for(undo)
 204
 205     refute Object.get_by_ap_id(note_id)
 206   end
 207 end