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