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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 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   import Pleroma.Factory
   9
  10   alias Pleroma.Conversation.Participation
  11   alias Pleroma.List
  12   alias Pleroma.User
  13   alias Pleroma.Web.CommonAPI
  14   alias Pleroma.Web.Streamer
  15
  16   @moduletag needs_streamer: true, capture_log: true
  17
  18   setup do: clear_config([:instance, :skip_thread_containment])
  19
  20   describe "user streams" do
  21     setup do
  22       user = insert(:user)
  23       notify = insert(:notification, user: user, activity: build(:note_activity))
  24       {:ok, %{user: user, notify: notify}}
  25     end
  26
  27     test "it streams the user's post in the 'user' stream", %{user: user} do
  28       Streamer.add_socket("user", user)
  29       {:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
  30       assert_receive {:render_with_user, _, _, ^activity}
  31       refute Streamer.filtered_by_user?(user, activity)
  32     end
  33
  34     test "it streams boosts of the user in the 'user' stream", %{user: user} do
  35       Streamer.add_socket("user", user)
  36
  37       other_user = insert(:user)
  38       {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"})
  39       {:ok, announce, _} = CommonAPI.repeat(activity.id, user)
  40
  41       assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce}
  42       refute Streamer.filtered_by_user?(user, announce)
  43     end
  44
  45     test "it sends notify to in the 'user' stream", %{user: user, notify: notify} do
  46       Streamer.add_socket("user", user)
  47       Streamer.stream("user", notify)
  48       assert_receive {:render_with_user, _, _, ^notify}
  49       refute Streamer.filtered_by_user?(user, notify)
  50     end
  51
  52     test "it sends notify to in the 'user:notification' stream", %{user: user, notify: notify} do
  53       Streamer.add_socket("user:notification", user)
  54       Streamer.stream("user:notification", notify)
  55       assert_receive {:render_with_user, _, _, ^notify}
  56       refute Streamer.filtered_by_user?(user, notify)
  57     end
  58
  59     test "it doesn't send notify to the 'user:notification' stream when a user is blocked", %{
  60       user: user
  61     } do
  62       blocked = insert(:user)
  63       {:ok, _user_relationship} = User.block(user, blocked)
  64
  65       Streamer.add_socket("user:notification", user)
  66
  67       {:ok, activity} = CommonAPI.post(user, %{"status" => ":("})
  68       {:ok, _} = CommonAPI.favorite(blocked, activity.id)
  69
  70       refute_receive _
  71     end
  72
  73     test "it doesn't send notify to the 'user:notification' stream when a thread is muted", %{
  74       user: user
  75     } do
  76       user2 = insert(:user)
  77
  78       {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
  79       {:ok, _} = CommonAPI.add_mute(user, activity)
  80
  81       Streamer.add_socket("user:notification", user)
  82
  83       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
  84
  85       refute_receive _
  86       assert Streamer.filtered_by_user?(user, favorite_activity)
  87     end
  88
  89     test "it sends favorite to 'user:notification' stream'", %{
  90       user: user
  91     } do
  92       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
  93
  94       {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
  95       Streamer.add_socket("user:notification", user)
  96       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
  97
  98       assert_receive {:render_with_user, _, "notification.json", notif}
  99       assert notif.activity.id == favorite_activity.id
 100       refute Streamer.filtered_by_user?(user, notif)
 101     end
 102
 103     test "it doesn't send the 'user:notification' stream' when a domain is blocked", %{
 104       user: user
 105     } do
 106       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
 107
 108       {:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
 109       {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
 110       Streamer.add_socket("user:notification", user)
 111       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 112
 113       refute_receive _
 114       assert Streamer.filtered_by_user?(user, favorite_activity)
 115     end
 116
 117     test "it sends follow activities to the 'user:notification' stream", %{
 118       user: user
 119     } do
 120       user_url = user.ap_id
 121       user2 = insert(:user)
 122
 123       body =
 124         File.read!("test/fixtures/users_mock/localhost.json")
 125         |> String.replace("{{nickname}}", user.nickname)
 126         |> Jason.encode!()
 127
 128       Tesla.Mock.mock_global(fn
 129         %{method: :get, url: ^user_url} ->
 130           %Tesla.Env{status: 200, body: body}
 131       end)
 132
 133       Streamer.add_socket("user:notification", user)
 134       {:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user2, user)
 135
 136       assert_receive {:render_with_user, _, "notification.json", notif}
 137       assert notif.activity.id == follow_activity.id
 138       refute Streamer.filtered_by_user?(user, notif)
 139     end
 140   end
 141
 142   test "it sends to public authenticated" do
 143     user = insert(:user)
 144     other_user = insert(:user)
 145
 146     Streamer.add_socket("public", other_user)
 147
 148     {:ok, activity} = CommonAPI.post(user, %{"status" => "Test"})
 149     assert_receive {:render_with_user, _, _, ^activity}
 150     refute Streamer.filtered_by_user?(user, activity)
 151   end
 152
 153   test "works for deletions" do
 154     user = insert(:user)
 155     other_user = insert(:user)
 156     {:ok, activity} = CommonAPI.post(other_user, %{"status" => "Test"})
 157
 158     Streamer.add_socket("public", user)
 159
 160     {:ok, _} = CommonAPI.delete(activity.id, other_user)
 161     activity_id = activity.id
 162     assert_receive {:text, event}
 163     assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
 164   end
 165
 166   test "it sends to public unauthenticated" do
 167     user = insert(:user)
 168
 169     Streamer.add_socket("public", nil)
 170
 171     {:ok, activity} = CommonAPI.post(user, %{"status" => "Test"})
 172     activity_id = activity.id
 173     assert_receive {:text, event}
 174     assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
 175     assert %{"id" => ^activity_id} = Jason.decode!(payload)
 176
 177     {:ok, _} = CommonAPI.delete(activity.id, user)
 178     assert_receive {:text, event}
 179     assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
 180   end
 181
 182   describe "thread_containment" do
 183     test "it filters to user if recipients invalid and thread containment is enabled" do
 184       Pleroma.Config.put([:instance, :skip_thread_containment], false)
 185       author = insert(:user)
 186       user = insert(:user)
 187       User.follow(user, author, :follow_accept)
 188
 189       activity =
 190         insert(:note_activity,
 191           note:
 192             insert(:note,
 193               user: author,
 194               data: %{"to" => ["TEST-FFF"]}
 195             )
 196         )
 197
 198       Streamer.add_socket("public", user)
 199       Streamer.stream("public", activity)
 200       assert_receive {:render_with_user, _, _, ^activity}
 201       assert Streamer.filtered_by_user?(user, activity)
 202     end
 203
 204     test "it sends message if recipients invalid and thread containment is disabled" do
 205       Pleroma.Config.put([:instance, :skip_thread_containment], true)
 206       author = insert(:user)
 207       user = insert(:user)
 208       User.follow(user, author, :follow_accept)
 209
 210       activity =
 211         insert(:note_activity,
 212           note:
 213             insert(:note,
 214               user: author,
 215               data: %{"to" => ["TEST-FFF"]}
 216             )
 217         )
 218
 219       Streamer.add_socket("public", user)
 220       Streamer.stream("public", activity)
 221
 222       assert_receive {:render_with_user, _, _, ^activity}
 223       refute Streamer.filtered_by_user?(user, activity)
 224     end
 225
 226     test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
 227       Pleroma.Config.put([:instance, :skip_thread_containment], false)
 228       author = insert(:user)
 229       user = insert(:user, skip_thread_containment: true)
 230       User.follow(user, author, :follow_accept)
 231
 232       activity =
 233         insert(:note_activity,
 234           note:
 235             insert(:note,
 236               user: author,
 237               data: %{"to" => ["TEST-FFF"]}
 238             )
 239         )
 240
 241       Streamer.add_socket("public", user)
 242       Streamer.stream("public", activity)
 243
 244       assert_receive {:render_with_user, _, _, ^activity}
 245       refute Streamer.filtered_by_user?(user, activity)
 246     end
 247   end
 248
 249   describe "blocks" do
 250     test "it filters messages involving blocked users" do
 251       user = insert(:user)
 252       blocked_user = insert(:user)
 253       {:ok, _user_relationship} = User.block(user, blocked_user)
 254
 255       Streamer.add_socket("public", user)
 256       {:ok, activity} = CommonAPI.post(blocked_user, %{"status" => "Test"})
 257       assert_receive {:render_with_user, _, _, ^activity}
 258       assert Streamer.filtered_by_user?(user, activity)
 259     end
 260
 261     test "it filters messages transitively involving blocked users" do
 262       blocker = insert(:user)
 263       blockee = insert(:user)
 264       friend = insert(:user)
 265
 266       Streamer.add_socket("public", blocker)
 267
 268       {:ok, _user_relationship} = User.block(blocker, blockee)
 269
 270       {:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})
 271
 272       assert_receive {:render_with_user, _, _, ^activity_one}
 273       assert Streamer.filtered_by_user?(blocker, activity_one)
 274
 275       {:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})
 276
 277       assert_receive {:render_with_user, _, _, ^activity_two}
 278       assert Streamer.filtered_by_user?(blocker, activity_two)
 279
 280       {:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})
 281
 282       assert_receive {:render_with_user, _, _, ^activity_three}
 283       assert Streamer.filtered_by_user?(blocker, activity_three)
 284     end
 285   end
 286
 287   describe "lists" do
 288     test "it doesn't send unwanted DMs to list" do
 289       user_a = insert(:user)
 290       user_b = insert(:user)
 291       user_c = insert(:user)
 292
 293       {:ok, user_a} = User.follow(user_a, user_b)
 294
 295       {:ok, list} = List.create("Test", user_a)
 296       {:ok, list} = List.follow(list, user_b)
 297
 298       Streamer.add_socket("list:#{list.id}", user_a)
 299
 300       {:ok, _activity} =
 301         CommonAPI.post(user_b, %{
 302           "status" => "@#{user_c.nickname} Test",
 303           "visibility" => "direct"
 304         })
 305
 306       refute_receive _
 307     end
 308
 309     test "it doesn't send unwanted private posts to list" do
 310       user_a = insert(:user)
 311       user_b = insert(:user)
 312
 313       {:ok, list} = List.create("Test", user_a)
 314       {:ok, list} = List.follow(list, user_b)
 315
 316       Streamer.add_socket("list:#{list.id}", user_a)
 317
 318       {:ok, _activity} =
 319         CommonAPI.post(user_b, %{
 320           "status" => "Test",
 321           "visibility" => "private"
 322         })
 323
 324       refute_receive _
 325     end
 326
 327     test "it sends wanted private posts to list" do
 328       user_a = insert(:user)
 329       user_b = insert(:user)
 330
 331       {:ok, user_a} = User.follow(user_a, user_b)
 332
 333       {:ok, list} = List.create("Test", user_a)
 334       {:ok, list} = List.follow(list, user_b)
 335
 336       Streamer.add_socket("list:#{list.id}", user_a)
 337
 338       {:ok, activity} =
 339         CommonAPI.post(user_b, %{
 340           "status" => "Test",
 341           "visibility" => "private"
 342         })
 343
 344       assert_receive {:render_with_user, _, _, ^activity}
 345       refute Streamer.filtered_by_user?(user_a, activity)
 346     end
 347   end
 348
 349   describe "muted reblogs" do
 350     test "it filters muted reblogs" do
 351       user1 = insert(:user)
 352       user2 = insert(:user)
 353       user3 = insert(:user)
 354       CommonAPI.follow(user1, user2)
 355       CommonAPI.hide_reblogs(user1, user2)
 356
 357       {:ok, create_activity} = CommonAPI.post(user3, %{"status" => "I'm kawen"})
 358
 359       Streamer.add_socket("user", user1)
 360       {:ok, announce_activity, _} = CommonAPI.repeat(create_activity.id, user2)
 361       assert_receive {:render_with_user, _, _, ^announce_activity}
 362       assert Streamer.filtered_by_user?(user1, announce_activity)
 363     end
 364
 365     test "it filters reblog notification for reblog-muted actors" do
 366       user1 = insert(:user)
 367       user2 = insert(:user)
 368       CommonAPI.follow(user1, user2)
 369       CommonAPI.hide_reblogs(user1, user2)
 370
 371       {:ok, create_activity} = CommonAPI.post(user1, %{"status" => "I'm kawen"})
 372       Streamer.add_socket("user", user1)
 373       {:ok, _favorite_activity, _} = CommonAPI.repeat(create_activity.id, user2)
 374
 375       assert_receive {:render_with_user, _, "notification.json", notif}
 376       assert Streamer.filtered_by_user?(user1, notif)
 377     end
 378
 379     test "it send non-reblog notification for reblog-muted actors" do
 380       user1 = insert(:user)
 381       user2 = insert(:user)
 382       CommonAPI.follow(user1, user2)
 383       CommonAPI.hide_reblogs(user1, user2)
 384
 385       {:ok, create_activity} = CommonAPI.post(user1, %{"status" => "I'm kawen"})
 386       Streamer.add_socket("user", user1)
 387       {:ok, _favorite_activity} = CommonAPI.favorite(user2, create_activity.id)
 388
 389       assert_receive {:render_with_user, _, "notification.json", notif}
 390       refute Streamer.filtered_by_user?(user1, notif)
 391     end
 392   end
 393
 394   test "it filters posts from muted threads" do
 395     user = insert(:user)
 396     user2 = insert(:user)
 397     Streamer.add_socket("user", user2)
 398     {:ok, user2, user, _activity} = CommonAPI.follow(user2, user)
 399     {:ok, activity} = CommonAPI.post(user, %{"status" => "super hot take"})
 400     {:ok, _} = CommonAPI.add_mute(user2, activity)
 401     assert_receive {:render_with_user, _, _, ^activity}
 402     assert Streamer.filtered_by_user?(user2, activity)
 403   end
 404
 405   describe "direct streams" do
 406     setup do
 407       :ok
 408     end
 409
 410     test "it sends conversation update to the 'direct' stream", %{} do
 411       user = insert(:user)
 412       another_user = insert(:user)
 413
 414       Streamer.add_socket("direct", user)
 415
 416       {:ok, _create_activity} =
 417         CommonAPI.post(another_user, %{
 418           "status" => "hey @#{user.nickname}",
 419           "visibility" => "direct"
 420         })
 421
 422       assert_receive {:text, received_event}
 423
 424       assert %{"event" => "conversation", "payload" => received_payload} =
 425                Jason.decode!(received_event)
 426
 427       assert %{"last_status" => last_status} = Jason.decode!(received_payload)
 428       [participation] = Participation.for_user(user)
 429       assert last_status["pleroma"]["direct_conversation_id"] == participation.id
 430     end
 431
 432     test "it doesn't send conversation update to the 'direct' stream when the last message in the conversation is deleted" do
 433       user = insert(:user)
 434       another_user = insert(:user)
 435
 436       Streamer.add_socket("direct", user)
 437
 438       {:ok, create_activity} =
 439         CommonAPI.post(another_user, %{
 440           "status" => "hi @#{user.nickname}",
 441           "visibility" => "direct"
 442         })
 443
 444       create_activity_id = create_activity.id
 445       assert_receive {:render_with_user, _, _, ^create_activity}
 446       assert_receive {:text, received_conversation1}
 447       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 448
 449       {:ok, _} = CommonAPI.delete(create_activity_id, another_user)
 450
 451       assert_receive {:text, received_event}
 452
 453       assert %{"event" => "delete", "payload" => ^create_activity_id} =
 454                Jason.decode!(received_event)
 455
 456       refute_receive _
 457     end
 458
 459     test "it sends conversation update to the 'direct' stream when a message is deleted" do
 460       user = insert(:user)
 461       another_user = insert(:user)
 462       Streamer.add_socket("direct", user)
 463
 464       {:ok, create_activity} =
 465         CommonAPI.post(another_user, %{
 466           "status" => "hi @#{user.nickname}",
 467           "visibility" => "direct"
 468         })
 469
 470       {:ok, create_activity2} =
 471         CommonAPI.post(another_user, %{
 472           "status" => "hi @#{user.nickname} 2",
 473           "in_reply_to_status_id" => create_activity.id,
 474           "visibility" => "direct"
 475         })
 476
 477       assert_receive {:render_with_user, _, _, ^create_activity}
 478       assert_receive {:render_with_user, _, _, ^create_activity2}
 479       assert_receive {:text, received_conversation1}
 480       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 481       assert_receive {:text, received_conversation1}
 482       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 483
 484       {:ok, _} = CommonAPI.delete(create_activity2.id, another_user)
 485
 486       assert_receive {:text, received_event}
 487       assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)
 488
 489       assert_receive {:text, received_event}
 490
 491       assert %{"event" => "conversation", "payload" => received_payload} =
 492                Jason.decode!(received_event)
 493
 494       assert %{"last_status" => last_status} = Jason.decode!(received_payload)
 495       assert last_status["id"] == to_string(create_activity.id)
 496     end
 497   end
 498 end