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