git.squeep.com Git - akkoma/blob - test/web/streamer_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.StreamerTest do
   6   use Pleroma.DataCase
   7
   8   alias Pleroma.List
   9   alias Pleroma.User
  10   alias Pleroma.Web.CommonAPI
  11   alias Pleroma.Web.Streamer
  12   import Pleroma.Factory
  13
  14   setup do
  15     skip_thread_containment = Pleroma.Config.get([:instance, :skip_thread_containment])
  16
  17     on_exit(fn ->
  18       Pleroma.Config.put([:instance, :skip_thread_containment], skip_thread_containment)
  19     end)
  20
  21     :ok
  22   end
  23
  24   test "it sends to public" do
  25     user = insert(:user)
  26     other_user = insert(:user)
  27
  28     task =
  29       Task.async(fn ->
  30         assert_receive {:text, _}, 4_000
  31       end)
  32
  33     fake_socket = %{
  34       transport_pid: task.pid,
  35       assigns: %{
  36         user: user
  37       }
  38     }
  39
  40     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "Test"})
  41
  42     topics = %{
  43       "public" => [fake_socket]
  44     }
  45
  46     Streamer.push_to_socket(topics, "public", activity)
  47
  48     Task.await(task)
  49
  50     task =
  51       Task.async(fn ->
  52         expected_event =
  53           %{
  54             "event" => "delete",
  55             "payload" => activity.id
  56           }
  57           |> Jason.encode!()
  58
  59         assert_receive {:text, received_event}, 4_000
  60         assert received_event == expected_event
  61       end)
  62
  63     fake_socket = %{
  64       transport_pid: task.pid,
  65       assigns: %{
  66         user: user
  67       }
  68     }
  69
  70     {:ok, activity} = CommonAPI.delete(activity.id, other_user)
  71
  72     topics = %{
  73       "public" => [fake_socket]
  74     }
  75
  76     Streamer.push_to_socket(topics, "public", activity)
  77
  78     Task.await(task)
  79   end
  80
  81   describe "thread_containment" do
  82     test "it doesn't send to user if recipients invalid and thread containment is enabled" do
  83       Pleroma.Config.put([:instance, :skip_thread_containment], false)
  84       author = insert(:user)
  85       user = insert(:user, following: [author.ap_id])
  86
  87       activity =
  88         insert(:note_activity,
  89           note:
  90             insert(:note,
  91               user: author,
  92               data: %{"to" => ["TEST-FFF"]}
  93             )
  94         )
  95
  96       task = Task.async(fn -> refute_receive {:text, _}, 1_000 end)
  97       fake_socket = %{transport_pid: task.pid, assigns: %{user: user}}
  98       topics = %{"public" => [fake_socket]}
  99       Streamer.push_to_socket(topics, "public", activity)
 100
 101       Task.await(task)
 102     end
 103
 104     test "it sends message if recipients invalid and thread containment is disabled" do
 105       Pleroma.Config.put([:instance, :skip_thread_containment], true)
 106       author = insert(:user)
 107       user = insert(:user, following: [author.ap_id])
 108
 109       activity =
 110         insert(:note_activity,
 111           note:
 112             insert(:note,
 113               user: author,
 114               data: %{"to" => ["TEST-FFF"]}
 115             )
 116         )
 117
 118       task = Task.async(fn -> assert_receive {:text, _}, 1_000 end)
 119       fake_socket = %{transport_pid: task.pid, assigns: %{user: user}}
 120       topics = %{"public" => [fake_socket]}
 121       Streamer.push_to_socket(topics, "public", activity)
 122
 123       Task.await(task)
 124     end
 125
 126     test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
 127       Pleroma.Config.put([:instance, :skip_thread_containment], false)
 128       author = insert(:user)
 129       user = insert(:user, following: [author.ap_id], info: %{skip_thread_containment: true})
 130
 131       activity =
 132         insert(:note_activity,
 133           note:
 134             insert(:note,
 135               user: author,
 136               data: %{"to" => ["TEST-FFF"]}
 137             )
 138         )
 139
 140       task = Task.async(fn -> assert_receive {:text, _}, 1_000 end)
 141       fake_socket = %{transport_pid: task.pid, assigns: %{user: user}}
 142       topics = %{"public" => [fake_socket]}
 143       Streamer.push_to_socket(topics, "public", activity)
 144
 145       Task.await(task)
 146     end
 147   end
 148
 149   test "it doesn't send to blocked users" do
 150     user = insert(:user)
 151     blocked_user = insert(:user)
 152     {:ok, user} = User.block(user, blocked_user)
 153
 154     task =
 155       Task.async(fn ->
 156         refute_receive {:text, _}, 1_000
 157       end)
 158
 159     fake_socket = %{
 160       transport_pid: task.pid,
 161       assigns: %{
 162         user: user
 163       }
 164     }
 165
 166     {:ok, activity} = CommonAPI.post(blocked_user, %{"status" => "Test"})
 167
 168     topics = %{
 169       "public" => [fake_socket]
 170     }
 171
 172     Streamer.push_to_socket(topics, "public", activity)
 173
 174     Task.await(task)
 175   end
 176
 177   test "it doesn't send unwanted DMs to list" do
 178     user_a = insert(:user)
 179     user_b = insert(:user)
 180     user_c = insert(:user)
 181
 182     {:ok, user_a} = User.follow(user_a, user_b)
 183
 184     {:ok, list} = List.create("Test", user_a)
 185     {:ok, list} = List.follow(list, user_b)
 186
 187     task =
 188       Task.async(fn ->
 189         refute_receive {:text, _}, 1_000
 190       end)
 191
 192     fake_socket = %{
 193       transport_pid: task.pid,
 194       assigns: %{
 195         user: user_a
 196       }
 197     }
 198
 199     {:ok, activity} =
 200       CommonAPI.post(user_b, %{
 201         "status" => "@#{user_c.nickname} Test",
 202         "visibility" => "direct"
 203       })
 204
 205     topics = %{
 206       "list:#{list.id}" => [fake_socket]
 207     }
 208
 209     Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
 210
 211     Task.await(task)
 212   end
 213
 214   test "it doesn't send unwanted private posts to list" do
 215     user_a = insert(:user)
 216     user_b = insert(:user)
 217
 218     {:ok, list} = List.create("Test", user_a)
 219     {:ok, list} = List.follow(list, user_b)
 220
 221     task =
 222       Task.async(fn ->
 223         refute_receive {:text, _}, 1_000
 224       end)
 225
 226     fake_socket = %{
 227       transport_pid: task.pid,
 228       assigns: %{
 229         user: user_a
 230       }
 231     }
 232
 233     {:ok, activity} =
 234       CommonAPI.post(user_b, %{
 235         "status" => "Test",
 236         "visibility" => "private"
 237       })
 238
 239     topics = %{
 240       "list:#{list.id}" => [fake_socket]
 241     }
 242
 243     Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
 244
 245     Task.await(task)
 246   end
 247
 248   test "it send wanted private posts to list" do
 249     user_a = insert(:user)
 250     user_b = insert(:user)
 251
 252     {:ok, user_a} = User.follow(user_a, user_b)
 253
 254     {:ok, list} = List.create("Test", user_a)
 255     {:ok, list} = List.follow(list, user_b)
 256
 257     task =
 258       Task.async(fn ->
 259         assert_receive {:text, _}, 1_000
 260       end)
 261
 262     fake_socket = %{
 263       transport_pid: task.pid,
 264       assigns: %{
 265         user: user_a
 266       }
 267     }
 268
 269     {:ok, activity} =
 270       CommonAPI.post(user_b, %{
 271         "status" => "Test",
 272         "visibility" => "private"
 273       })
 274
 275     topics = %{
 276       "list:#{list.id}" => [fake_socket]
 277     }
 278
 279     Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
 280
 281     Task.await(task)
 282   end
 283
 284   test "it doesn't send muted reblogs" do
 285     user1 = insert(:user)
 286     user2 = insert(:user)
 287     user3 = insert(:user)
 288     CommonAPI.hide_reblogs(user1, user2)
 289
 290     task =
 291       Task.async(fn ->
 292         refute_receive {:text, _}, 1_000
 293       end)
 294
 295     fake_socket = %{
 296       transport_pid: task.pid,
 297       assigns: %{
 298         user: user1
 299       }
 300     }
 301
 302     {:ok, create_activity} = CommonAPI.post(user3, %{"status" => "I'm kawen"})
 303     {:ok, announce_activity, _} = CommonAPI.repeat(create_activity.id, user2)
 304
 305     topics = %{
 306       "public" => [fake_socket]
 307     }
 308
 309     Streamer.push_to_socket(topics, "public", announce_activity)
 310
 311     Task.await(task)
 312   end
 313 end