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.Web.Streamer
   9   alias Pleroma.List
  10   alias Pleroma.User
  11   alias Pleroma.Web.CommonAPI
  12   import Pleroma.Factory
  13
  14   test "it sends to public" do
  15     user = insert(:user)
  16     other_user = insert(:user)
  17
  18     task =
  19       Task.async(fn ->
  20         assert_receive {:text, _}, 4_000
  21       end)
  22
  23     fake_socket = %{
  24       transport_pid: task.pid,
  25       assigns: %{
  26         user: user
  27       }
  28     }
  29
  30     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "Test"})
  31
  32     topics = %{
  33       "public" => [fake_socket]
  34     }
  35
  36     Streamer.push_to_socket(topics, "public", activity)
  37
  38     Task.await(task)
  39
  40     task =
  41       Task.async(fn ->
  42         assert_receive {:text, _}, 4_000
  43       end)
  44
  45     fake_socket = %{
  46       transport_pid: task.pid,
  47       assigns: %{
  48         user: user
  49       }
  50     }
  51
  52     {:ok, activity} = CommonAPI.delete(activity.id, other_user)
  53
  54     topics = %{
  55       "public" => [fake_socket]
  56     }
  57
  58     Streamer.push_to_socket(topics, "public", activity)
  59
  60     Task.await(task)
  61   end
  62
  63   test "it doesn't send to blocked users" do
  64     user = insert(:user)
  65     blocked_user = insert(:user)
  66     {:ok, user} = User.block(user, blocked_user)
  67
  68     task =
  69       Task.async(fn ->
  70         refute_receive {:text, _}, 1_000
  71       end)
  72
  73     fake_socket = %{
  74       transport_pid: task.pid,
  75       assigns: %{
  76         user: user
  77       }
  78     }
  79
  80     {:ok, activity} = CommonAPI.post(blocked_user, %{"status" => "Test"})
  81
  82     topics = %{
  83       "public" => [fake_socket]
  84     }
  85
  86     Streamer.push_to_socket(topics, "public", activity)
  87
  88     Task.await(task)
  89   end
  90
  91   test "it doesn't send unwanted DMs to list" do
  92     user_a = insert(:user)
  93     user_b = insert(:user)
  94     user_c = insert(:user)
  95
  96     {:ok, user_a} = User.follow(user_a, user_b)
  97
  98     {:ok, list} = List.create("Test", user_a)
  99     {:ok, list} = List.follow(list, user_b)
 100
 101     task =
 102       Task.async(fn ->
 103         refute_receive {:text, _}, 1_000
 104       end)
 105
 106     fake_socket = %{
 107       transport_pid: task.pid,
 108       assigns: %{
 109         user: user_a
 110       }
 111     }
 112
 113     {:ok, activity} =
 114       CommonAPI.post(user_b, %{
 115         "status" => "@#{user_c.nickname} Test",
 116         "visibility" => "direct"
 117       })
 118
 119     topics = %{
 120       "list:#{list.id}" => [fake_socket]
 121     }
 122
 123     Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
 124
 125     Task.await(task)
 126   end
 127
 128   test "it doesn't send unwanted private posts to list" do
 129     user_a = insert(:user)
 130     user_b = insert(:user)
 131
 132     {:ok, list} = List.create("Test", user_a)
 133     {:ok, list} = List.follow(list, user_b)
 134
 135     task =
 136       Task.async(fn ->
 137         refute_receive {:text, _}, 1_000
 138       end)
 139
 140     fake_socket = %{
 141       transport_pid: task.pid,
 142       assigns: %{
 143         user: user_a
 144       }
 145     }
 146
 147     {:ok, activity} =
 148       CommonAPI.post(user_b, %{
 149         "status" => "Test",
 150         "visibility" => "private"
 151       })
 152
 153     topics = %{
 154       "list:#{list.id}" => [fake_socket]
 155     }
 156
 157     Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
 158
 159     Task.await(task)
 160   end
 161
 162   test "it send wanted private posts to list" do
 163     user_a = insert(:user)
 164     user_b = insert(:user)
 165
 166     {:ok, user_a} = User.follow(user_a, user_b)
 167
 168     {:ok, list} = List.create("Test", user_a)
 169     {:ok, list} = List.follow(list, user_b)
 170
 171     task =
 172       Task.async(fn ->
 173         assert_receive {:text, _}, 1_000
 174       end)
 175
 176     fake_socket = %{
 177       transport_pid: task.pid,
 178       assigns: %{
 179         user: user_a
 180       }
 181     }
 182
 183     {:ok, activity} =
 184       CommonAPI.post(user_b, %{
 185         "status" => "Test",
 186         "visibility" => "private"
 187       })
 188
 189     topics = %{
 190       "list:#{list.id}" => [fake_socket]
 191     }
 192
 193     Streamer.handle_cast(%{action: :stream, topic: "list", item: activity}, topics)
 194
 195     Task.await(task)
 196   end
 197 end