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