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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 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 "get_topic/_ (unauthenticated)" do
  21     test "allows public" do
  22       assert {:ok, "public"} = Streamer.get_topic("public", nil, nil)
  23       assert {:ok, "public:local"} = Streamer.get_topic("public:local", nil, nil)
  24       assert {:ok, "public:media"} = Streamer.get_topic("public:media", nil, nil)
  25       assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", nil, nil)
  26     end
  27
  28     test "allows instance streams" do
  29       assert {:ok, "public:remote:lain.com"} =
  30                Streamer.get_topic("public:remote", nil, nil, %{"instance" => "lain.com"})
  31
  32       assert {:ok, "public:remote:media:lain.com"} =
  33                Streamer.get_topic("public:remote:media", nil, nil, %{"instance" => "lain.com"})
  34     end
  35
  36     test "allows hashtag streams" do
  37       assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", nil, nil, %{"tag" => "cofe"})
  38     end
  39
  40     test "disallows user streams" do
  41       assert {:error, _} = Streamer.get_topic("user", nil, nil)
  42       assert {:error, _} = Streamer.get_topic("user:notification", nil, nil)
  43       assert {:error, _} = Streamer.get_topic("direct", nil, nil)
  44     end
  45
  46     test "disallows list streams" do
  47       assert {:error, _} = Streamer.get_topic("list", nil, nil, %{"list" => 42})
  48     end
  49   end
  50
  51   describe "get_topic/_ (authenticated)" do
  52     setup do: oauth_access(["read"])
  53
  54     test "allows public streams (regardless of OAuth token scopes)", %{
  55       user: user,
  56       token: read_oauth_token
  57     } do
  58       with oauth_token <- [nil, read_oauth_token] do
  59         assert {:ok, "public"} = Streamer.get_topic("public", user, oauth_token)
  60         assert {:ok, "public:local"} = Streamer.get_topic("public:local", user, oauth_token)
  61         assert {:ok, "public:media"} = Streamer.get_topic("public:media", user, oauth_token)
  62
  63         assert {:ok, "public:local:media"} =
  64                  Streamer.get_topic("public:local:media", user, oauth_token)
  65       end
  66     end
  67
  68     test "allows user streams (with proper OAuth token scopes)", %{
  69       user: user,
  70       token: read_oauth_token
  71     } do
  72       %{token: read_notifications_token} = oauth_access(["read:notifications"], user: user)
  73       %{token: read_statuses_token} = oauth_access(["read:statuses"], user: user)
  74       %{token: badly_scoped_token} = oauth_access(["irrelevant:scope"], user: user)
  75
  76       expected_user_topic = "user:#{user.id}"
  77       expected_notification_topic = "user:notification:#{user.id}"
  78       expected_direct_topic = "direct:#{user.id}"
  79
  80       for valid_user_token <- [read_oauth_token, read_statuses_token] do
  81         assert {:ok, ^expected_user_topic} = Streamer.get_topic("user", user, valid_user_token)
  82
  83         assert {:ok, ^expected_direct_topic} =
  84                  Streamer.get_topic("direct", user, valid_user_token)
  85       end
  86
  87       for invalid_user_token <- [read_notifications_token, badly_scoped_token],
  88           user_topic <- ["user", "direct"] do
  89         assert {:error, :unauthorized} = Streamer.get_topic(user_topic, user, invalid_user_token)
  90       end
  91
  92       for valid_notification_token <- [read_oauth_token, read_notifications_token] do
  93         assert {:ok, ^expected_notification_topic} =
  94                  Streamer.get_topic("user:notification", user, valid_notification_token)
  95       end
  96
  97       for invalid_notification_token <- [read_statuses_token, badly_scoped_token] do
  98         assert {:error, :unauthorized} =
  99                  Streamer.get_topic("user:notification", user, invalid_notification_token)
 100       end
 101     end
 102
 103     test "allows hashtag streams (regardless of OAuth token scopes)", %{
 104       user: user,
 105       token: read_oauth_token
 106     } do
 107       for oauth_token <- [nil, read_oauth_token] do
 108         assert {:ok, "hashtag:cofe"} =
 109                  Streamer.get_topic("hashtag", user, oauth_token, %{"tag" => "cofe"})
 110       end
 111     end
 112
 113     test "disallows registering to another user's stream", %{user: user, token: read_oauth_token} do
 114       another_user = insert(:user)
 115       assert {:error, _} = Streamer.get_topic("user:#{another_user.id}", user, read_oauth_token)
 116
 117       assert {:error, _} =
 118                Streamer.get_topic("user:notification:#{another_user.id}", user, read_oauth_token)
 119
 120       assert {:error, _} = Streamer.get_topic("direct:#{another_user.id}", user, read_oauth_token)
 121     end
 122
 123     test "allows list stream that are owned by the user (with `read` or `read:lists` scopes)", %{
 124       user: user,
 125       token: read_oauth_token
 126     } do
 127       %{token: read_lists_token} = oauth_access(["read:lists"], user: user)
 128       %{token: invalid_token} = oauth_access(["irrelevant:scope"], user: user)
 129       {:ok, list} = List.create("Test", user)
 130
 131       assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, read_oauth_token)
 132
 133       for valid_token <- [read_oauth_token, read_lists_token] do
 134         assert {:ok, _} = Streamer.get_topic("list", user, valid_token, %{"list" => list.id})
 135       end
 136
 137       assert {:error, _} = Streamer.get_topic("list", user, invalid_token, %{"list" => list.id})
 138     end
 139
 140     test "disallows list stream that are not owned by the user", %{user: user, token: oauth_token} do
 141       another_user = insert(:user)
 142       {:ok, list} = List.create("Test", another_user)
 143
 144       assert {:error, _} = Streamer.get_topic("list:#{list.id}", user, oauth_token)
 145       assert {:error, _} = Streamer.get_topic("list", user, oauth_token, %{"list" => list.id})
 146     end
 147   end
 148
 149   describe "user streams" do
 150     setup do
 151       %{user: user, token: token} = oauth_access(["read"])
 152       notify = insert(:notification, user: user, activity: build(:note_activity))
 153       {:ok, %{user: user, notify: notify, token: token}}
 154     end
 155
 156     test "it streams the user's post in the 'user' stream", %{user: user, token: oauth_token} do
 157       Streamer.get_topic_and_add_socket("user", user, oauth_token)
 158       {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
 159
 160       stream_name = "user:#{user.id}"
 161       assert_receive {:render_with_user, _, _, ^activity, ^stream_name}
 162       refute Streamer.filtered_by_user?(user, activity)
 163     end
 164
 165     test "it streams boosts of the user in the 'user' stream", %{user: user, token: oauth_token} do
 166       Streamer.get_topic_and_add_socket("user", user, oauth_token)
 167
 168       other_user = insert(:user)
 169       {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
 170       {:ok, announce} = CommonAPI.repeat(activity.id, user)
 171
 172       stream_name = "user:#{user.id}"
 173
 174       assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce,
 175                       ^stream_name}
 176
 177       refute Streamer.filtered_by_user?(user, announce)
 178     end
 179
 180     test "it does not stream announces of the user's own posts in the 'user' stream", %{
 181       user: user,
 182       token: oauth_token
 183     } do
 184       Streamer.get_topic_and_add_socket("user", user, oauth_token)
 185
 186       other_user = insert(:user)
 187       {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
 188       {:ok, announce} = CommonAPI.repeat(activity.id, other_user)
 189
 190       assert Streamer.filtered_by_user?(user, announce)
 191     end
 192
 193     test "it does stream notifications announces of the user's own posts in the 'user' stream", %{
 194       user: user,
 195       token: oauth_token
 196     } do
 197       Streamer.get_topic_and_add_socket("user", user, oauth_token)
 198
 199       other_user = insert(:user)
 200       {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
 201       {:ok, announce} = CommonAPI.repeat(activity.id, other_user)
 202
 203       notification =
 204         Pleroma.Notification
 205         |> Repo.get_by(%{user_id: user.id, activity_id: announce.id})
 206         |> Repo.preload(:activity)
 207
 208       refute Streamer.filtered_by_user?(user, notification)
 209     end
 210
 211     test "it streams boosts of mastodon user in the 'user' stream", %{
 212       user: user,
 213       token: oauth_token
 214     } do
 215       Streamer.get_topic_and_add_socket("user", user, oauth_token)
 216
 217       other_user = insert(:user)
 218       {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
 219
 220       data =
 221         File.read!("test/fixtures/mastodon-announce.json")
 222         |> Jason.decode!()
 223         |> Map.put("object", activity.data["object"])
 224         |> Map.put("actor", user.ap_id)
 225
 226       {:ok, %Pleroma.Activity{data: _data, local: false} = announce} =
 227         Pleroma.Web.ActivityPub.Transmogrifier.handle_incoming(data)
 228
 229       stream_name = "user:#{user.id}"
 230
 231       assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce,
 232                       ^stream_name}
 233
 234       refute Streamer.filtered_by_user?(user, announce)
 235     end
 236
 237     test "it sends notify to in the 'user' stream", %{
 238       user: user,
 239       token: oauth_token,
 240       notify: notify
 241     } do
 242       Streamer.get_topic_and_add_socket("user", user, oauth_token)
 243       Streamer.stream("user", notify)
 244
 245       assert_receive {:render_with_user, _, _, ^notify, "user"}
 246       refute Streamer.filtered_by_user?(user, notify)
 247     end
 248
 249     test "it sends notify to in the 'user:notification' stream", %{
 250       user: user,
 251       token: oauth_token,
 252       notify: notify
 253     } do
 254       Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
 255       Streamer.stream("user:notification", notify)
 256
 257       assert_receive {:render_with_user, _, _, ^notify, "user:notification"}
 258       refute Streamer.filtered_by_user?(user, notify)
 259     end
 260
 261     test "it doesn't send notify to the 'user:notification' stream when a user is blocked", %{
 262       user: user,
 263       token: oauth_token
 264     } do
 265       blocked = insert(:user)
 266       {:ok, _user_relationship} = User.block(user, blocked)
 267
 268       Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
 269
 270       {:ok, activity} = CommonAPI.post(user, %{status: ":("})
 271       {:ok, _} = CommonAPI.favorite(blocked, activity.id)
 272
 273       refute_receive _
 274     end
 275
 276     test "it doesn't send notify to the 'user:notification' stream when a thread is muted", %{
 277       user: user,
 278       token: oauth_token
 279     } do
 280       user2 = insert(:user)
 281
 282       {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 283       {:ok, _} = CommonAPI.add_mute(user, activity)
 284
 285       Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
 286
 287       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 288
 289       refute_receive _
 290       assert Streamer.filtered_by_user?(user, favorite_activity)
 291     end
 292
 293     test "it sends favorite to 'user:notification' stream'", %{
 294       user: user,
 295       token: oauth_token
 296     } do
 297       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
 298
 299       {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 300       Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
 301       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 302
 303       assert_receive {:render_with_user, _, "notification.json", notif, "user:notification"}
 304       assert notif.activity.id == favorite_activity.id
 305       refute Streamer.filtered_by_user?(user, notif)
 306     end
 307
 308     test "it doesn't send the 'user:notification' stream' when a domain is blocked", %{
 309       user: user,
 310       token: oauth_token
 311     } do
 312       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
 313
 314       {:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
 315       {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 316       Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
 317       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 318
 319       refute_receive _
 320       assert Streamer.filtered_by_user?(user, favorite_activity)
 321     end
 322
 323     test "it sends follow activities to the 'user:notification' stream", %{
 324       user: user,
 325       token: oauth_token
 326     } do
 327       user2 = insert(:user)
 328
 329       Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
 330       {:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user2, user)
 331
 332       assert_receive {:render_with_user, _, "notification.json", notif, "user:notification"}
 333       assert notif.activity.id == follow_activity.id
 334       refute Streamer.filtered_by_user?(user, notif)
 335     end
 336
 337     test "it sends follow relationships updates to the 'user' stream", %{
 338       user: user,
 339       token: oauth_token
 340     } do
 341       user_id = user.id
 342       other_user = insert(:user)
 343       other_user_id = other_user.id
 344
 345       Streamer.get_topic_and_add_socket("user", user, oauth_token)
 346       {:ok, _follower, _followed, _follow_activity} = CommonAPI.follow(user, other_user)
 347
 348       assert_receive {:text, event}
 349
 350       assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
 351                Jason.decode!(event)
 352
 353       assert %{
 354                "follower" => %{
 355                  "follower_count" => 0,
 356                  "following_count" => 0,
 357                  "id" => ^user_id
 358                },
 359                "following" => %{
 360                  "follower_count" => 0,
 361                  "following_count" => 0,
 362                  "id" => ^other_user_id
 363                },
 364                "state" => "follow_pending"
 365              } = Jason.decode!(payload)
 366
 367       assert_receive {:text, event}
 368
 369       assert %{"event" => "pleroma:follow_relationships_update", "payload" => payload} =
 370                Jason.decode!(event)
 371
 372       assert %{
 373                "follower" => %{
 374                  "follower_count" => 0,
 375                  "following_count" => 1,
 376                  "id" => ^user_id
 377                },
 378                "following" => %{
 379                  "follower_count" => 1,
 380                  "following_count" => 0,
 381                  "id" => ^other_user_id
 382                },
 383                "state" => "follow_accept"
 384              } = Jason.decode!(payload)
 385     end
 386   end
 387
 388   describe "public streams" do
 389     test "it sends to public (authenticated)" do
 390       %{user: user, token: oauth_token} = oauth_access(["read"])
 391       other_user = insert(:user)
 392
 393       Streamer.get_topic_and_add_socket("public", user, oauth_token)
 394
 395       {:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
 396       assert_receive {:render_with_user, _, _, ^activity, "public"}
 397       refute Streamer.filtered_by_user?(other_user, activity)
 398     end
 399
 400     test "it sends to public (unauthenticated)" do
 401       user = insert(:user)
 402
 403       Streamer.get_topic_and_add_socket("public", nil, nil)
 404
 405       {:ok, activity} = CommonAPI.post(user, %{status: "Test"})
 406       activity_id = activity.id
 407       assert_receive {:text, event}
 408       assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
 409       assert %{"id" => ^activity_id} = Jason.decode!(payload)
 410
 411       {:ok, _} = CommonAPI.delete(activity.id, user)
 412       assert_receive {:text, event}
 413       assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
 414     end
 415
 416     test "handles deletions" do
 417       %{user: user, token: oauth_token} = oauth_access(["read"])
 418       other_user = insert(:user)
 419       {:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
 420
 421       Streamer.get_topic_and_add_socket("public", user, oauth_token)
 422
 423       {:ok, _} = CommonAPI.delete(activity.id, other_user)
 424       activity_id = activity.id
 425       assert_receive {:text, event}
 426       assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
 427     end
 428   end
 429
 430   describe "thread_containment/2" do
 431     test "it filters to user if recipients invalid and thread containment is enabled" do
 432       clear_config([:instance, :skip_thread_containment], false)
 433       author = insert(:user)
 434       %{user: user, token: oauth_token} = oauth_access(["read"])
 435       User.follow(user, author, :follow_accept)
 436
 437       activity =
 438         insert(:note_activity,
 439           note:
 440             insert(:note,
 441               user: author,
 442               data: %{"to" => ["TEST-FFF"]}
 443             )
 444         )
 445
 446       Streamer.get_topic_and_add_socket("public", user, oauth_token)
 447       Streamer.stream("public", activity)
 448       assert_receive {:render_with_user, _, _, ^activity, "public"}
 449       assert Streamer.filtered_by_user?(user, activity)
 450     end
 451
 452     test "it sends message if recipients invalid and thread containment is disabled" do
 453       clear_config([:instance, :skip_thread_containment], true)
 454       author = insert(:user)
 455       %{user: user, token: oauth_token} = oauth_access(["read"])
 456       User.follow(user, author, :follow_accept)
 457
 458       activity =
 459         insert(:note_activity,
 460           note:
 461             insert(:note,
 462               user: author,
 463               data: %{"to" => ["TEST-FFF"]}
 464             )
 465         )
 466
 467       Streamer.get_topic_and_add_socket("public", user, oauth_token)
 468       Streamer.stream("public", activity)
 469
 470       assert_receive {:render_with_user, _, _, ^activity, "public"}
 471       refute Streamer.filtered_by_user?(user, activity)
 472     end
 473
 474     test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
 475       clear_config([:instance, :skip_thread_containment], false)
 476       author = insert(:user)
 477       user = insert(:user, skip_thread_containment: true)
 478       %{token: oauth_token} = oauth_access(["read"], user: user)
 479       User.follow(user, author, :follow_accept)
 480
 481       activity =
 482         insert(:note_activity,
 483           note:
 484             insert(:note,
 485               user: author,
 486               data: %{"to" => ["TEST-FFF"]}
 487             )
 488         )
 489
 490       Streamer.get_topic_and_add_socket("public", user, oauth_token)
 491       Streamer.stream("public", activity)
 492
 493       assert_receive {:render_with_user, _, _, ^activity, "public"}
 494       refute Streamer.filtered_by_user?(user, activity)
 495     end
 496   end
 497
 498   describe "blocks" do
 499     setup do: oauth_access(["read"])
 500
 501     test "it filters messages involving blocked users", %{user: user, token: oauth_token} do
 502       blocked_user = insert(:user)
 503       {:ok, _user_relationship} = User.block(user, blocked_user)
 504
 505       Streamer.get_topic_and_add_socket("public", user, oauth_token)
 506       {:ok, activity} = CommonAPI.post(blocked_user, %{status: "Test"})
 507       assert_receive {:render_with_user, _, _, ^activity, "public"}
 508       assert Streamer.filtered_by_user?(user, activity)
 509     end
 510
 511     test "it filters messages transitively involving blocked users", %{
 512       user: blocker,
 513       token: blocker_token
 514     } do
 515       blockee = insert(:user)
 516       friend = insert(:user)
 517
 518       Streamer.get_topic_and_add_socket("public", blocker, blocker_token)
 519
 520       {:ok, _user_relationship} = User.block(blocker, blockee)
 521
 522       {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})
 523
 524       assert_receive {:render_with_user, _, _, ^activity_one, "public"}
 525       assert Streamer.filtered_by_user?(blocker, activity_one)
 526
 527       {:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
 528
 529       assert_receive {:render_with_user, _, _, ^activity_two, "public"}
 530       assert Streamer.filtered_by_user?(blocker, activity_two)
 531
 532       {:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})
 533
 534       assert_receive {:render_with_user, _, _, ^activity_three, "public"}
 535       assert Streamer.filtered_by_user?(blocker, activity_three)
 536     end
 537   end
 538
 539   describe "lists" do
 540     setup do: oauth_access(["read"])
 541
 542     test "it doesn't send unwanted DMs to list", %{user: user_a, token: user_a_token} do
 543       user_b = insert(:user)
 544       user_c = insert(:user)
 545
 546       {:ok, user_a, user_b} = User.follow(user_a, user_b)
 547
 548       {:ok, list} = List.create("Test", user_a)
 549       {:ok, list} = List.follow(list, user_b)
 550
 551       Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})
 552
 553       {:ok, _activity} =
 554         CommonAPI.post(user_b, %{
 555           status: "@#{user_c.nickname} Test",
 556           visibility: "direct"
 557         })
 558
 559       refute_receive _
 560     end
 561
 562     test "it doesn't send unwanted private posts to list", %{user: user_a, token: user_a_token} do
 563       user_b = insert(:user)
 564
 565       {:ok, list} = List.create("Test", user_a)
 566       {:ok, list} = List.follow(list, user_b)
 567
 568       Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})
 569
 570       {:ok, _activity} =
 571         CommonAPI.post(user_b, %{
 572           status: "Test",
 573           visibility: "private"
 574         })
 575
 576       refute_receive _
 577     end
 578
 579     test "it sends wanted private posts to list", %{user: user_a, token: user_a_token} do
 580       user_b = insert(:user)
 581
 582       {:ok, user_a, user_b} = User.follow(user_a, user_b)
 583
 584       {:ok, list} = List.create("Test", user_a)
 585       {:ok, list} = List.follow(list, user_b)
 586
 587       Streamer.get_topic_and_add_socket("list", user_a, user_a_token, %{"list" => list.id})
 588
 589       {:ok, activity} =
 590         CommonAPI.post(user_b, %{
 591           status: "Test",
 592           visibility: "private"
 593         })
 594
 595       stream_name = "list:#{list.id}"
 596       assert_receive {:render_with_user, _, _, ^activity, ^stream_name}
 597       refute Streamer.filtered_by_user?(user_a, activity)
 598     end
 599   end
 600
 601   describe "muted reblogs" do
 602     setup do: oauth_access(["read"])
 603
 604     test "it filters muted reblogs", %{user: user1, token: user1_token} do
 605       user2 = insert(:user)
 606       user3 = insert(:user)
 607       CommonAPI.follow(user1, user2)
 608       CommonAPI.hide_reblogs(user1, user2)
 609
 610       {:ok, create_activity} = CommonAPI.post(user3, %{status: "I'm kawen"})
 611
 612       Streamer.get_topic_and_add_socket("user", user1, user1_token)
 613       {:ok, announce_activity} = CommonAPI.repeat(create_activity.id, user2)
 614       stream_name = "user:#{user1.id}"
 615       assert_receive {:render_with_user, _, _, ^announce_activity, ^stream_name}
 616       assert Streamer.filtered_by_user?(user1, announce_activity)
 617     end
 618
 619     test "it filters reblog notification for reblog-muted actors", %{
 620       user: user1,
 621       token: user1_token
 622     } do
 623       user2 = insert(:user)
 624       CommonAPI.follow(user1, user2)
 625       CommonAPI.hide_reblogs(user1, user2)
 626
 627       {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
 628       Streamer.get_topic_and_add_socket("user", user1, user1_token)
 629       {:ok, _announce_activity} = CommonAPI.repeat(create_activity.id, user2)
 630
 631       assert_receive {:render_with_user, _, "notification.json", notif, "user"}
 632       assert Streamer.filtered_by_user?(user1, notif)
 633     end
 634
 635     test "it send non-reblog notification for reblog-muted actors", %{
 636       user: user1,
 637       token: user1_token
 638     } do
 639       user2 = insert(:user)
 640       CommonAPI.follow(user1, user2)
 641       CommonAPI.hide_reblogs(user1, user2)
 642
 643       {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
 644       Streamer.get_topic_and_add_socket("user", user1, user1_token)
 645       {:ok, _favorite_activity} = CommonAPI.favorite(user2, create_activity.id)
 646
 647       assert_receive {:render_with_user, _, "notification.json", notif, "user"}
 648       refute Streamer.filtered_by_user?(user1, notif)
 649     end
 650   end
 651
 652   describe "muted threads" do
 653     test "it filters posts from muted threads" do
 654       user = insert(:user)
 655       %{user: user2, token: user2_token} = oauth_access(["read"])
 656       Streamer.get_topic_and_add_socket("user", user2, user2_token)
 657
 658       {:ok, user2, user, _activity} = CommonAPI.follow(user2, user)
 659       {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 660       {:ok, _} = CommonAPI.add_mute(user2, activity)
 661
 662       stream_name = "user:#{user2.id}"
 663       assert_receive {:render_with_user, _, _, ^activity, ^stream_name}
 664       assert Streamer.filtered_by_user?(user2, activity)
 665     end
 666   end
 667
 668   describe "direct streams" do
 669     setup do: oauth_access(["read"])
 670
 671     test "it sends conversation update to the 'direct' stream", %{user: user, token: oauth_token} do
 672       another_user = insert(:user)
 673
 674       Streamer.get_topic_and_add_socket("direct", user, oauth_token)
 675
 676       {:ok, _create_activity} =
 677         CommonAPI.post(another_user, %{
 678           status: "hey @#{user.nickname}",
 679           visibility: "direct"
 680         })
 681
 682       assert_receive {:text, received_event}
 683
 684       assert %{"event" => "conversation", "payload" => received_payload} =
 685                Jason.decode!(received_event)
 686
 687       assert %{"last_status" => last_status} = Jason.decode!(received_payload)
 688       [participation] = Participation.for_user(user)
 689       assert last_status["pleroma"]["direct_conversation_id"] == participation.id
 690     end
 691
 692     test "it doesn't send conversation update to the 'direct' stream when the last message in the conversation is deleted",
 693          %{user: user, token: oauth_token} do
 694       another_user = insert(:user)
 695
 696       Streamer.get_topic_and_add_socket("direct", user, oauth_token)
 697
 698       {:ok, create_activity} =
 699         CommonAPI.post(another_user, %{
 700           status: "hi @#{user.nickname}",
 701           visibility: "direct"
 702         })
 703
 704       create_activity_id = create_activity.id
 705       stream_name = "direct:#{user.id}"
 706       assert_receive {:render_with_user, _, _, ^create_activity, ^stream_name}
 707       assert_receive {:text, received_conversation1}
 708       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 709
 710       {:ok, _} = CommonAPI.delete(create_activity_id, another_user)
 711
 712       assert_receive {:text, received_event}
 713
 714       assert %{"event" => "delete", "payload" => ^create_activity_id} =
 715                Jason.decode!(received_event)
 716
 717       refute_receive _
 718     end
 719
 720     @tag :erratic
 721     test "it sends conversation update to the 'direct' stream when a message is deleted", %{
 722       user: user,
 723       token: oauth_token
 724     } do
 725       another_user = insert(:user)
 726       Streamer.get_topic_and_add_socket("direct", user, oauth_token)
 727
 728       {:ok, create_activity} =
 729         CommonAPI.post(another_user, %{
 730           status: "hi @#{user.nickname}",
 731           visibility: "direct"
 732         })
 733
 734       {:ok, create_activity2} =
 735         CommonAPI.post(another_user, %{
 736           status: "hi @#{user.nickname} 2",
 737           in_reply_to_status_id: create_activity.id,
 738           visibility: "direct"
 739         })
 740
 741       stream_name = "direct:#{user.id}"
 742       assert_receive {:render_with_user, _, _, ^create_activity, ^stream_name}
 743       assert_receive {:render_with_user, _, _, ^create_activity2, ^stream_name}
 744       assert_receive {:text, received_conversation1}
 745       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 746       assert_receive {:text, received_conversation1}
 747       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 748
 749       {:ok, _} = CommonAPI.delete(create_activity2.id, another_user)
 750
 751       assert_receive {:text, received_event}
 752       assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)
 753
 754       assert_receive {:text, received_event}
 755
 756       assert %{"event" => "conversation", "payload" => received_payload} =
 757                Jason.decode!(received_event)
 758
 759       assert %{"last_status" => last_status} = Jason.decode!(received_payload)
 760       assert last_status["id"] == to_string(create_activity.id)
 761     end
 762   end
 763
 764   describe "stop streaming if token got revoked" do
 765     setup do
 766       child_proc = fn start, finalize ->
 767         fn ->
 768           start.()
 769
 770           receive do
 771             {StreamerTest, :ready} ->
 772               assert_receive {:render_with_user, _, "update.json", _, _}
 773
 774               receive do
 775                 {StreamerTest, :revoked} -> finalize.()
 776               end
 777           end
 778         end
 779       end
 780
 781       starter = fn user, token ->
 782         fn -> Streamer.get_topic_and_add_socket("user", user, token) end
 783       end
 784
 785       hit = fn -> assert_receive :close end
 786       miss = fn -> refute_receive :close end
 787
 788       send_all = fn tasks, thing -> Enum.each(tasks, &send(&1.pid, thing)) end
 789
 790       %{
 791         child_proc: child_proc,
 792         starter: starter,
 793         hit: hit,
 794         miss: miss,
 795         send_all: send_all
 796       }
 797     end
 798
 799     test "do not revoke other tokens", %{
 800       child_proc: child_proc,
 801       starter: starter,
 802       hit: hit,
 803       miss: miss,
 804       send_all: send_all
 805     } do
 806       %{user: user, token: token} = oauth_access(["read"])
 807       %{token: token2} = oauth_access(["read"], user: user)
 808       %{user: user2, token: user2_token} = oauth_access(["read"])
 809
 810       post_user = insert(:user)
 811       CommonAPI.follow(user, post_user)
 812       CommonAPI.follow(user2, post_user)
 813
 814       tasks = [
 815         Task.async(child_proc.(starter.(user, token), hit)),
 816         Task.async(child_proc.(starter.(user, token2), miss)),
 817         Task.async(child_proc.(starter.(user2, user2_token), miss))
 818       ]
 819
 820       {:ok, _} =
 821         CommonAPI.post(post_user, %{
 822           status: "hi"
 823         })
 824
 825       send_all.(tasks, {StreamerTest, :ready})
 826
 827       Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)
 828
 829       send_all.(tasks, {StreamerTest, :revoked})
 830
 831       Enum.each(tasks, &Task.await/1)
 832     end
 833
 834     test "revoke all streams for this token", %{
 835       child_proc: child_proc,
 836       starter: starter,
 837       hit: hit,
 838       send_all: send_all
 839     } do
 840       %{user: user, token: token} = oauth_access(["read"])
 841
 842       post_user = insert(:user)
 843       CommonAPI.follow(user, post_user)
 844
 845       tasks = [
 846         Task.async(child_proc.(starter.(user, token), hit)),
 847         Task.async(child_proc.(starter.(user, token), hit))
 848       ]
 849
 850       {:ok, _} =
 851         CommonAPI.post(post_user, %{
 852           status: "hi"
 853         })
 854
 855       send_all.(tasks, {StreamerTest, :ready})
 856
 857       Pleroma.Web.OAuth.Token.Strategy.Revoke.revoke(token)
 858
 859       send_all.(tasks, {StreamerTest, :revoked})
 860
 861       Enum.each(tasks, &Task.await/1)
 862     end
 863   end
 864 end