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.Chat
  11   alias Pleroma.Chat.MessageReference
  12   alias Pleroma.Conversation.Participation
  13   alias Pleroma.List
  14   alias Pleroma.Object
  15   alias Pleroma.User
  16   alias Pleroma.Web.CommonAPI
  17   alias Pleroma.Web.Streamer
  18   alias Pleroma.Web.StreamerView
  19
  20   @moduletag needs_streamer: true, capture_log: true
  21
  22   setup do: clear_config([:instance, :skip_thread_containment])
  23
  24   describe "get_topic without an user" do
  25     test "allows public" do
  26       assert {:ok, "public"} = Streamer.get_topic("public", nil)
  27       assert {:ok, "public:local"} = Streamer.get_topic("public:local", nil)
  28       assert {:ok, "public:media"} = Streamer.get_topic("public:media", nil)
  29       assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", nil)
  30     end
  31
  32     test "allows hashtag streams" do
  33       assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", nil, %{"tag" => "cofe"})
  34     end
  35
  36     test "disallows user streams" do
  37       assert {:error, _} = Streamer.get_topic("user", nil)
  38       assert {:error, _} = Streamer.get_topic("user:notification", nil)
  39       assert {:error, _} = Streamer.get_topic("direct", nil)
  40     end
  41
  42     test "disallows list streams" do
  43       assert {:error, _} = Streamer.get_topic("list", nil, %{"list" => 42})
  44     end
  45   end
  46
  47   describe "get_topic with an user" do
  48     setup do
  49       user = insert(:user)
  50       {:ok, %{user: user}}
  51     end
  52
  53     test "allows public streams", %{user: user} do
  54       assert {:ok, "public"} = Streamer.get_topic("public", user)
  55       assert {:ok, "public:local"} = Streamer.get_topic("public:local", user)
  56       assert {:ok, "public:media"} = Streamer.get_topic("public:media", user)
  57       assert {:ok, "public:local:media"} = Streamer.get_topic("public:local:media", user)
  58     end
  59
  60     test "allows user streams", %{user: user} do
  61       expected_user_topic = "user:#{user.id}"
  62       expected_notif_topic = "user:notification:#{user.id}"
  63       expected_direct_topic = "direct:#{user.id}"
  64       assert {:ok, ^expected_user_topic} = Streamer.get_topic("user", user)
  65       assert {:ok, ^expected_notif_topic} = Streamer.get_topic("user:notification", user)
  66       assert {:ok, ^expected_direct_topic} = Streamer.get_topic("direct", user)
  67     end
  68
  69     test "allows hashtag streams", %{user: user} do
  70       assert {:ok, "hashtag:cofe"} = Streamer.get_topic("hashtag", user, %{"tag" => "cofe"})
  71     end
  72
  73     test "disallows registering to an user stream", %{user: user} do
  74       another_user = insert(:user)
  75       assert {:error, _} = Streamer.get_topic("user:#{another_user.id}", user)
  76       assert {:error, _} = Streamer.get_topic("user:notification:#{another_user.id}", user)
  77       assert {:error, _} = Streamer.get_topic("direct:#{another_user.id}", user)
  78     end
  79
  80     test "allows list stream that are owned by the user", %{user: user} do
  81       {:ok, list} = List.create("Test", user)
  82       assert {:error, _} = Streamer.get_topic("list:#{list.id}", user)
  83       assert {:ok, _} = Streamer.get_topic("list", user, %{"list" => list.id})
  84     end
  85
  86     test "disallows list stream that are not owned by the user", %{user: user} do
  87       another_user = insert(:user)
  88       {:ok, list} = List.create("Test", another_user)
  89       assert {:error, _} = Streamer.get_topic("list:#{list.id}", user)
  90       assert {:error, _} = Streamer.get_topic("list", user, %{"list" => list.id})
  91     end
  92   end
  93
  94   describe "user streams" do
  95     setup do
  96       user = insert(:user)
  97       notify = insert(:notification, user: user, activity: build(:note_activity))
  98       {:ok, %{user: user, notify: notify}}
  99     end
 100
 101     test "it streams the user's post in the 'user' stream", %{user: user} do
 102       Streamer.get_topic_and_add_socket("user", user)
 103       {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
 104       assert_receive {:render_with_user, _, _, ^activity}
 105       refute Streamer.filtered_by_user?(user, activity)
 106     end
 107
 108     test "it streams boosts of the user in the 'user' stream", %{user: user} do
 109       Streamer.get_topic_and_add_socket("user", user)
 110
 111       other_user = insert(:user)
 112       {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
 113       {:ok, announce} = CommonAPI.repeat(activity.id, user)
 114
 115       assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce}
 116       refute Streamer.filtered_by_user?(user, announce)
 117     end
 118
 119     test "it streams boosts of mastodon user in the 'user' stream", %{user: user} do
 120       Streamer.get_topic_and_add_socket("user", user)
 121
 122       other_user = insert(:user)
 123       {:ok, activity} = CommonAPI.post(other_user, %{status: "hey"})
 124
 125       data =
 126         File.read!("test/fixtures/mastodon-announce.json")
 127         |> Poison.decode!()
 128         |> Map.put("object", activity.data["object"])
 129         |> Map.put("actor", user.ap_id)
 130
 131       {:ok, %Pleroma.Activity{data: _data, local: false} = announce} =
 132         Pleroma.Web.ActivityPub.Transmogrifier.handle_incoming(data)
 133
 134       assert_receive {:render_with_user, Pleroma.Web.StreamerView, "update.json", ^announce}
 135       refute Streamer.filtered_by_user?(user, announce)
 136     end
 137
 138     test "it sends notify to in the 'user' stream", %{user: user, notify: notify} do
 139       Streamer.get_topic_and_add_socket("user", user)
 140       Streamer.stream("user", notify)
 141       assert_receive {:render_with_user, _, _, ^notify}
 142       refute Streamer.filtered_by_user?(user, notify)
 143     end
 144
 145     test "it sends notify to in the 'user:notification' stream", %{user: user, notify: notify} do
 146       Streamer.get_topic_and_add_socket("user:notification", user)
 147       Streamer.stream("user:notification", notify)
 148       assert_receive {:render_with_user, _, _, ^notify}
 149       refute Streamer.filtered_by_user?(user, notify)
 150     end
 151
 152     test "it sends chat messages to the 'user:pleroma_chat' stream", %{user: user} do
 153       other_user = insert(:user)
 154
 155       {:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey cirno")
 156       object = Object.normalize(create_activity, false)
 157       chat = Chat.get(user.id, other_user.ap_id)
 158       cm_ref = MessageReference.for_chat_and_object(chat, object)
 159       cm_ref = %{cm_ref | chat: chat, object: object}
 160
 161       Streamer.get_topic_and_add_socket("user:pleroma_chat", user)
 162       Streamer.stream("user:pleroma_chat", {user, cm_ref})
 163
 164       text = StreamerView.render("chat_update.json", %{chat_message_reference: cm_ref})
 165
 166       assert text =~ "hey cirno"
 167       assert_receive {:text, ^text}
 168     end
 169
 170     test "it sends chat messages to the 'user' stream", %{user: user} do
 171       other_user = insert(:user)
 172
 173       {:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey cirno")
 174       object = Object.normalize(create_activity, false)
 175       chat = Chat.get(user.id, other_user.ap_id)
 176       cm_ref = MessageReference.for_chat_and_object(chat, object)
 177       cm_ref = %{cm_ref | chat: chat, object: object}
 178
 179       Streamer.get_topic_and_add_socket("user", user)
 180       Streamer.stream("user", {user, cm_ref})
 181
 182       text = StreamerView.render("chat_update.json", %{chat_message_reference: cm_ref})
 183
 184       assert text =~ "hey cirno"
 185       assert_receive {:text, ^text}
 186     end
 187
 188     test "it sends chat message notifications to the 'user:notification' stream", %{user: user} do
 189       other_user = insert(:user)
 190
 191       {:ok, create_activity} = CommonAPI.post_chat_message(other_user, user, "hey")
 192
 193       notify =
 194         Repo.get_by(Pleroma.Notification, user_id: user.id, activity_id: create_activity.id)
 195         |> Repo.preload(:activity)
 196
 197       Streamer.get_topic_and_add_socket("user:notification", user)
 198       Streamer.stream("user:notification", notify)
 199       assert_receive {:render_with_user, _, _, ^notify}
 200       refute Streamer.filtered_by_user?(user, notify)
 201     end
 202
 203     test "it doesn't send notify to the 'user:notification' stream when a user is blocked", %{
 204       user: user
 205     } do
 206       blocked = insert(:user)
 207       {:ok, _user_relationship} = User.block(user, blocked)
 208
 209       Streamer.get_topic_and_add_socket("user:notification", user)
 210
 211       {:ok, activity} = CommonAPI.post(user, %{status: ":("})
 212       {:ok, _} = CommonAPI.favorite(blocked, activity.id)
 213
 214       refute_receive _
 215     end
 216
 217     test "it doesn't send notify to the 'user:notification' stream when a thread is muted", %{
 218       user: user
 219     } do
 220       user2 = insert(:user)
 221
 222       {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 223       {:ok, _} = CommonAPI.add_mute(user, activity)
 224
 225       Streamer.get_topic_and_add_socket("user:notification", user)
 226
 227       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 228
 229       refute_receive _
 230       assert Streamer.filtered_by_user?(user, favorite_activity)
 231     end
 232
 233     test "it sends favorite to 'user:notification' stream'", %{
 234       user: user
 235     } do
 236       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
 237
 238       {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 239       Streamer.get_topic_and_add_socket("user:notification", user)
 240       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 241
 242       assert_receive {:render_with_user, _, "notification.json", notif}
 243       assert notif.activity.id == favorite_activity.id
 244       refute Streamer.filtered_by_user?(user, notif)
 245     end
 246
 247     test "it doesn't send the 'user:notification' stream' when a domain is blocked", %{
 248       user: user
 249     } do
 250       user2 = insert(:user, %{ap_id: "https://hecking-lewd-place.com/user/meanie"})
 251
 252       {:ok, user} = User.block_domain(user, "hecking-lewd-place.com")
 253       {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 254       Streamer.get_topic_and_add_socket("user:notification", user)
 255       {:ok, favorite_activity} = CommonAPI.favorite(user2, activity.id)
 256
 257       refute_receive _
 258       assert Streamer.filtered_by_user?(user, favorite_activity)
 259     end
 260
 261     test "it sends follow activities to the 'user:notification' stream", %{
 262       user: user
 263     } do
 264       user_url = user.ap_id
 265       user2 = insert(:user)
 266
 267       body =
 268         File.read!("test/fixtures/users_mock/localhost.json")
 269         |> String.replace("{{nickname}}", user.nickname)
 270         |> Jason.encode!()
 271
 272       Tesla.Mock.mock_global(fn
 273         %{method: :get, url: ^user_url} ->
 274           %Tesla.Env{status: 200, body: body}
 275       end)
 276
 277       Streamer.get_topic_and_add_socket("user:notification", user)
 278       {:ok, _follower, _followed, follow_activity} = CommonAPI.follow(user2, user)
 279
 280       assert_receive {:render_with_user, _, "notification.json", notif}
 281       assert notif.activity.id == follow_activity.id
 282       refute Streamer.filtered_by_user?(user, notif)
 283     end
 284   end
 285
 286   test "it sends to public authenticated" do
 287     user = insert(:user)
 288     other_user = insert(:user)
 289
 290     Streamer.get_topic_and_add_socket("public", other_user)
 291
 292     {:ok, activity} = CommonAPI.post(user, %{status: "Test"})
 293     assert_receive {:render_with_user, _, _, ^activity}
 294     refute Streamer.filtered_by_user?(user, activity)
 295   end
 296
 297   test "works for deletions" do
 298     user = insert(:user)
 299     other_user = insert(:user)
 300     {:ok, activity} = CommonAPI.post(other_user, %{status: "Test"})
 301
 302     Streamer.get_topic_and_add_socket("public", user)
 303
 304     {:ok, _} = CommonAPI.delete(activity.id, other_user)
 305     activity_id = activity.id
 306     assert_receive {:text, event}
 307     assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
 308   end
 309
 310   test "it sends to public unauthenticated" do
 311     user = insert(:user)
 312
 313     Streamer.get_topic_and_add_socket("public", nil)
 314
 315     {:ok, activity} = CommonAPI.post(user, %{status: "Test"})
 316     activity_id = activity.id
 317     assert_receive {:text, event}
 318     assert %{"event" => "update", "payload" => payload} = Jason.decode!(event)
 319     assert %{"id" => ^activity_id} = Jason.decode!(payload)
 320
 321     {:ok, _} = CommonAPI.delete(activity.id, user)
 322     assert_receive {:text, event}
 323     assert %{"event" => "delete", "payload" => ^activity_id} = Jason.decode!(event)
 324   end
 325
 326   describe "thread_containment" do
 327     test "it filters to user if recipients invalid and thread containment is enabled" do
 328       Pleroma.Config.put([:instance, :skip_thread_containment], false)
 329       author = insert(:user)
 330       user = insert(:user)
 331       User.follow(user, author, :follow_accept)
 332
 333       activity =
 334         insert(:note_activity,
 335           note:
 336             insert(:note,
 337               user: author,
 338               data: %{"to" => ["TEST-FFF"]}
 339             )
 340         )
 341
 342       Streamer.get_topic_and_add_socket("public", user)
 343       Streamer.stream("public", activity)
 344       assert_receive {:render_with_user, _, _, ^activity}
 345       assert Streamer.filtered_by_user?(user, activity)
 346     end
 347
 348     test "it sends message if recipients invalid and thread containment is disabled" do
 349       Pleroma.Config.put([:instance, :skip_thread_containment], true)
 350       author = insert(:user)
 351       user = insert(:user)
 352       User.follow(user, author, :follow_accept)
 353
 354       activity =
 355         insert(:note_activity,
 356           note:
 357             insert(:note,
 358               user: author,
 359               data: %{"to" => ["TEST-FFF"]}
 360             )
 361         )
 362
 363       Streamer.get_topic_and_add_socket("public", user)
 364       Streamer.stream("public", activity)
 365
 366       assert_receive {:render_with_user, _, _, ^activity}
 367       refute Streamer.filtered_by_user?(user, activity)
 368     end
 369
 370     test "it sends message if recipients invalid and thread containment is enabled but user's thread containment is disabled" do
 371       Pleroma.Config.put([:instance, :skip_thread_containment], false)
 372       author = insert(:user)
 373       user = insert(:user, skip_thread_containment: true)
 374       User.follow(user, author, :follow_accept)
 375
 376       activity =
 377         insert(:note_activity,
 378           note:
 379             insert(:note,
 380               user: author,
 381               data: %{"to" => ["TEST-FFF"]}
 382             )
 383         )
 384
 385       Streamer.get_topic_and_add_socket("public", user)
 386       Streamer.stream("public", activity)
 387
 388       assert_receive {:render_with_user, _, _, ^activity}
 389       refute Streamer.filtered_by_user?(user, activity)
 390     end
 391   end
 392
 393   describe "blocks" do
 394     test "it filters messages involving blocked users" do
 395       user = insert(:user)
 396       blocked_user = insert(:user)
 397       {:ok, _user_relationship} = User.block(user, blocked_user)
 398
 399       Streamer.get_topic_and_add_socket("public", user)
 400       {:ok, activity} = CommonAPI.post(blocked_user, %{status: "Test"})
 401       assert_receive {:render_with_user, _, _, ^activity}
 402       assert Streamer.filtered_by_user?(user, activity)
 403     end
 404
 405     test "it filters messages transitively involving blocked users" do
 406       blocker = insert(:user)
 407       blockee = insert(:user)
 408       friend = insert(:user)
 409
 410       Streamer.get_topic_and_add_socket("public", blocker)
 411
 412       {:ok, _user_relationship} = User.block(blocker, blockee)
 413
 414       {:ok, activity_one} = CommonAPI.post(friend, %{status: "hey! @#{blockee.nickname}"})
 415
 416       assert_receive {:render_with_user, _, _, ^activity_one}
 417       assert Streamer.filtered_by_user?(blocker, activity_one)
 418
 419       {:ok, activity_two} = CommonAPI.post(blockee, %{status: "hey! @#{friend.nickname}"})
 420
 421       assert_receive {:render_with_user, _, _, ^activity_two}
 422       assert Streamer.filtered_by_user?(blocker, activity_two)
 423
 424       {:ok, activity_three} = CommonAPI.post(blockee, %{status: "hey! @#{blocker.nickname}"})
 425
 426       assert_receive {:render_with_user, _, _, ^activity_three}
 427       assert Streamer.filtered_by_user?(blocker, activity_three)
 428     end
 429   end
 430
 431   describe "lists" do
 432     test "it doesn't send unwanted DMs to list" do
 433       user_a = insert(:user)
 434       user_b = insert(:user)
 435       user_c = insert(:user)
 436
 437       {:ok, user_a} = User.follow(user_a, user_b)
 438
 439       {:ok, list} = List.create("Test", user_a)
 440       {:ok, list} = List.follow(list, user_b)
 441
 442       Streamer.get_topic_and_add_socket("list", user_a, %{"list" => list.id})
 443
 444       {:ok, _activity} =
 445         CommonAPI.post(user_b, %{
 446           status: "@#{user_c.nickname} Test",
 447           visibility: "direct"
 448         })
 449
 450       refute_receive _
 451     end
 452
 453     test "it doesn't send unwanted private posts to list" do
 454       user_a = insert(:user)
 455       user_b = insert(:user)
 456
 457       {:ok, list} = List.create("Test", user_a)
 458       {:ok, list} = List.follow(list, user_b)
 459
 460       Streamer.get_topic_and_add_socket("list", user_a, %{"list" => list.id})
 461
 462       {:ok, _activity} =
 463         CommonAPI.post(user_b, %{
 464           status: "Test",
 465           visibility: "private"
 466         })
 467
 468       refute_receive _
 469     end
 470
 471     test "it sends wanted private posts to list" do
 472       user_a = insert(:user)
 473       user_b = insert(:user)
 474
 475       {:ok, user_a} = User.follow(user_a, user_b)
 476
 477       {:ok, list} = List.create("Test", user_a)
 478       {:ok, list} = List.follow(list, user_b)
 479
 480       Streamer.get_topic_and_add_socket("list", user_a, %{"list" => list.id})
 481
 482       {:ok, activity} =
 483         CommonAPI.post(user_b, %{
 484           status: "Test",
 485           visibility: "private"
 486         })
 487
 488       assert_receive {:render_with_user, _, _, ^activity}
 489       refute Streamer.filtered_by_user?(user_a, activity)
 490     end
 491   end
 492
 493   describe "muted reblogs" do
 494     test "it filters muted reblogs" do
 495       user1 = insert(:user)
 496       user2 = insert(:user)
 497       user3 = insert(:user)
 498       CommonAPI.follow(user1, user2)
 499       CommonAPI.hide_reblogs(user1, user2)
 500
 501       {:ok, create_activity} = CommonAPI.post(user3, %{status: "I'm kawen"})
 502
 503       Streamer.get_topic_and_add_socket("user", user1)
 504       {:ok, announce_activity} = CommonAPI.repeat(create_activity.id, user2)
 505       assert_receive {:render_with_user, _, _, ^announce_activity}
 506       assert Streamer.filtered_by_user?(user1, announce_activity)
 507     end
 508
 509     test "it filters reblog notification for reblog-muted actors" do
 510       user1 = insert(:user)
 511       user2 = insert(:user)
 512       CommonAPI.follow(user1, user2)
 513       CommonAPI.hide_reblogs(user1, user2)
 514
 515       {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
 516       Streamer.get_topic_and_add_socket("user", user1)
 517       {:ok, _announce_activity} = CommonAPI.repeat(create_activity.id, user2)
 518
 519       assert_receive {:render_with_user, _, "notification.json", notif}
 520       assert Streamer.filtered_by_user?(user1, notif)
 521     end
 522
 523     test "it send non-reblog notification for reblog-muted actors" do
 524       user1 = insert(:user)
 525       user2 = insert(:user)
 526       CommonAPI.follow(user1, user2)
 527       CommonAPI.hide_reblogs(user1, user2)
 528
 529       {:ok, create_activity} = CommonAPI.post(user1, %{status: "I'm kawen"})
 530       Streamer.get_topic_and_add_socket("user", user1)
 531       {:ok, _favorite_activity} = CommonAPI.favorite(user2, create_activity.id)
 532
 533       assert_receive {:render_with_user, _, "notification.json", notif}
 534       refute Streamer.filtered_by_user?(user1, notif)
 535     end
 536   end
 537
 538   test "it filters posts from muted threads" do
 539     user = insert(:user)
 540     user2 = insert(:user)
 541     Streamer.get_topic_and_add_socket("user", user2)
 542     {:ok, user2, user, _activity} = CommonAPI.follow(user2, user)
 543     {:ok, activity} = CommonAPI.post(user, %{status: "super hot take"})
 544     {:ok, _} = CommonAPI.add_mute(user2, activity)
 545     assert_receive {:render_with_user, _, _, ^activity}
 546     assert Streamer.filtered_by_user?(user2, activity)
 547   end
 548
 549   describe "direct streams" do
 550     setup do
 551       :ok
 552     end
 553
 554     test "it sends conversation update to the 'direct' stream", %{} do
 555       user = insert(:user)
 556       another_user = insert(:user)
 557
 558       Streamer.get_topic_and_add_socket("direct", user)
 559
 560       {:ok, _create_activity} =
 561         CommonAPI.post(another_user, %{
 562           status: "hey @#{user.nickname}",
 563           visibility: "direct"
 564         })
 565
 566       assert_receive {:text, received_event}
 567
 568       assert %{"event" => "conversation", "payload" => received_payload} =
 569                Jason.decode!(received_event)
 570
 571       assert %{"last_status" => last_status} = Jason.decode!(received_payload)
 572       [participation] = Participation.for_user(user)
 573       assert last_status["pleroma"]["direct_conversation_id"] == participation.id
 574     end
 575
 576     test "it doesn't send conversation update to the 'direct' stream when the last message in the conversation is deleted" do
 577       user = insert(:user)
 578       another_user = insert(:user)
 579
 580       Streamer.get_topic_and_add_socket("direct", user)
 581
 582       {:ok, create_activity} =
 583         CommonAPI.post(another_user, %{
 584           status: "hi @#{user.nickname}",
 585           visibility: "direct"
 586         })
 587
 588       create_activity_id = create_activity.id
 589       assert_receive {:render_with_user, _, _, ^create_activity}
 590       assert_receive {:text, received_conversation1}
 591       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 592
 593       {:ok, _} = CommonAPI.delete(create_activity_id, another_user)
 594
 595       assert_receive {:text, received_event}
 596
 597       assert %{"event" => "delete", "payload" => ^create_activity_id} =
 598                Jason.decode!(received_event)
 599
 600       refute_receive _
 601     end
 602
 603     test "it sends conversation update to the 'direct' stream when a message is deleted" do
 604       user = insert(:user)
 605       another_user = insert(:user)
 606       Streamer.get_topic_and_add_socket("direct", user)
 607
 608       {:ok, create_activity} =
 609         CommonAPI.post(another_user, %{
 610           status: "hi @#{user.nickname}",
 611           visibility: "direct"
 612         })
 613
 614       {:ok, create_activity2} =
 615         CommonAPI.post(another_user, %{
 616           status: "hi @#{user.nickname} 2",
 617           in_reply_to_status_id: create_activity.id,
 618           visibility: "direct"
 619         })
 620
 621       assert_receive {:render_with_user, _, _, ^create_activity}
 622       assert_receive {:render_with_user, _, _, ^create_activity2}
 623       assert_receive {:text, received_conversation1}
 624       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 625       assert_receive {:text, received_conversation1}
 626       assert %{"event" => "conversation", "payload" => _} = Jason.decode!(received_conversation1)
 627
 628       {:ok, _} = CommonAPI.delete(create_activity2.id, another_user)
 629
 630       assert_receive {:text, received_event}
 631       assert %{"event" => "delete", "payload" => _} = Jason.decode!(received_event)
 632
 633       assert_receive {:text, received_event}
 634
 635       assert %{"event" => "conversation", "payload" => received_payload} =
 636                Jason.decode!(received_event)
 637
 638       assert %{"last_status" => last_status} = Jason.decode!(received_payload)
 639       assert last_status["id"] == to_string(create_activity.id)
 640     end
 641   end
 642 end