git.squeep.com Git - akkoma/blob - test/notification_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.NotificationTest do
   6   use Pleroma.DataCase
   7   alias Pleroma.Notification
   8   alias Pleroma.User
   9   alias Pleroma.Web.ActivityPub.Transmogrifier
  10   alias Pleroma.Web.CommonAPI
  11   alias Pleroma.Web.TwitterAPI.TwitterAPI
  12   import Pleroma.Factory
  13
  14   describe "create_notifications" do
  15     test "notifies someone when they are directly addressed" do
  16       user = insert(:user)
  17       other_user = insert(:user)
  18       third_user = insert(:user)
  19
  20       {:ok, activity} =
  21         TwitterAPI.create_status(user, %{
  22           "status" => "hey @#{other_user.nickname} and @#{third_user.nickname}"
  23         })
  24
  25       {:ok, [notification, other_notification]} = Notification.create_notifications(activity)
  26
  27       notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
  28       assert notified_ids == [other_user.id, third_user.id]
  29       assert notification.activity_id == activity.id
  30       assert other_notification.activity_id == activity.id
  31     end
  32
  33     test "it creates a notification for subscribed users" do
  34       user = insert(:user)
  35       subscriber = insert(:user)
  36
  37       User.subscribe(subscriber, user)
  38
  39       {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
  40       {:ok, [notification]} = Notification.create_notifications(status)
  41
  42       assert notification.user_id == subscriber.id
  43     end
  44   end
  45
  46   describe "create_notification" do
  47     test "it doesn't create a notification for user if the user blocks the activity author" do
  48       activity = insert(:note_activity)
  49       author = User.get_cached_by_ap_id(activity.data["actor"])
  50       user = insert(:user)
  51       {:ok, user} = User.block(user, author)
  52
  53       assert nil == Notification.create_notification(activity, user)
  54     end
  55
  56     test "it doesn't create a notificatin for the user if the user mutes the activity author" do
  57       muter = insert(:user)
  58       muted = insert(:user)
  59       {:ok, _} = User.mute(muter, muted)
  60       muter = Repo.get(User, muter.id)
  61       {:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})
  62
  63       assert nil == Notification.create_notification(activity, muter)
  64     end
  65
  66     test "it doesn't create a notification for an activity from a muted thread" do
  67       muter = insert(:user)
  68       other_user = insert(:user)
  69       {:ok, activity} = CommonAPI.post(muter, %{"status" => "hey"})
  70       CommonAPI.add_mute(muter, activity)
  71
  72       {:ok, activity} =
  73         CommonAPI.post(other_user, %{
  74           "status" => "Hi @#{muter.nickname}",
  75           "in_reply_to_status_id" => activity.id
  76         })
  77
  78       assert nil == Notification.create_notification(activity, muter)
  79     end
  80
  81     test "it disables notifications from followers" do
  82       follower = insert(:user)
  83       followed = insert(:user, info: %{notification_settings: %{"followers" => false}})
  84       User.follow(follower, followed)
  85       {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
  86       assert nil == Notification.create_notification(activity, followed)
  87     end
  88
  89     test "it disables notifications from non-followers" do
  90       follower = insert(:user)
  91       followed = insert(:user, info: %{notification_settings: %{"non_followers" => false}})
  92       {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
  93       assert nil == Notification.create_notification(activity, followed)
  94     end
  95
  96     test "it disables notifications from people the user follows" do
  97       follower = insert(:user, info: %{notification_settings: %{"follows" => false}})
  98       followed = insert(:user)
  99       User.follow(follower, followed)
 100       follower = Repo.get(User, follower.id)
 101       {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
 102       assert nil == Notification.create_notification(activity, follower)
 103     end
 104
 105     test "it disables notifications from people the user does not follow" do
 106       follower = insert(:user, info: %{notification_settings: %{"non_follows" => false}})
 107       followed = insert(:user)
 108       {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
 109       assert nil == Notification.create_notification(activity, follower)
 110     end
 111
 112     test "it doesn't create a notification for user if he is the activity author" do
 113       activity = insert(:note_activity)
 114       author = User.get_cached_by_ap_id(activity.data["actor"])
 115
 116       assert nil == Notification.create_notification(activity, author)
 117     end
 118
 119     test "it doesn't create a notification for follow-unfollow-follow chains" do
 120       user = insert(:user)
 121       followed_user = insert(:user)
 122       {:ok, _, _, activity} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
 123       Notification.create_notification(activity, followed_user)
 124       TwitterAPI.unfollow(user, %{"user_id" => followed_user.id})
 125       {:ok, _, _, activity_dupe} = TwitterAPI.follow(user, %{"user_id" => followed_user.id})
 126       assert nil == Notification.create_notification(activity_dupe, followed_user)
 127     end
 128
 129     test "it doesn't create a notification for like-unlike-like chains" do
 130       user = insert(:user)
 131       liked_user = insert(:user)
 132       {:ok, status} = TwitterAPI.create_status(liked_user, %{"status" => "Yui is best yuru"})
 133       {:ok, fav_status} = TwitterAPI.fav(user, status.id)
 134       Notification.create_notification(fav_status, liked_user)
 135       TwitterAPI.unfav(user, status.id)
 136       {:ok, dupe} = TwitterAPI.fav(user, status.id)
 137       assert nil == Notification.create_notification(dupe, liked_user)
 138     end
 139
 140     test "it doesn't create a notification for repeat-unrepeat-repeat chains" do
 141       user = insert(:user)
 142       retweeted_user = insert(:user)
 143
 144       {:ok, status} =
 145         TwitterAPI.create_status(retweeted_user, %{
 146           "status" => "Send dupe notifications to the shadow realm"
 147         })
 148
 149       {:ok, retweeted_activity} = TwitterAPI.repeat(user, status.id)
 150       Notification.create_notification(retweeted_activity, retweeted_user)
 151       TwitterAPI.unrepeat(user, status.id)
 152       {:ok, dupe} = TwitterAPI.repeat(user, status.id)
 153       assert nil == Notification.create_notification(dupe, retweeted_user)
 154     end
 155
 156     test "it doesn't create duplicate notifications for follow+subscribed users" do
 157       user = insert(:user)
 158       subscriber = insert(:user)
 159
 160       {:ok, _, _, _} = TwitterAPI.follow(subscriber, %{"user_id" => user.id})
 161       User.subscribe(subscriber, user)
 162       {:ok, status} = TwitterAPI.create_status(user, %{"status" => "Akariiiin"})
 163       {:ok, [_notif]} = Notification.create_notifications(status)
 164     end
 165
 166     test "it doesn't create subscription notifications if the recipient cannot see the status" do
 167       user = insert(:user)
 168       subscriber = insert(:user)
 169
 170       User.subscribe(subscriber, user)
 171
 172       {:ok, status} =
 173         TwitterAPI.create_status(user, %{"status" => "inwisible", "visibility" => "direct"})
 174
 175       assert {:ok, []} == Notification.create_notifications(status)
 176     end
 177   end
 178
 179   describe "get notification" do
 180     test "it gets a notification that belongs to the user" do
 181       user = insert(:user)
 182       other_user = insert(:user)
 183
 184       {:ok, activity} =
 185         TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
 186
 187       {:ok, [notification]} = Notification.create_notifications(activity)
 188       {:ok, notification} = Notification.get(other_user, notification.id)
 189
 190       assert notification.user_id == other_user.id
 191     end
 192
 193     test "it returns error if the notification doesn't belong to the user" do
 194       user = insert(:user)
 195       other_user = insert(:user)
 196
 197       {:ok, activity} =
 198         TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
 199
 200       {:ok, [notification]} = Notification.create_notifications(activity)
 201       {:error, _notification} = Notification.get(user, notification.id)
 202     end
 203   end
 204
 205   describe "dismiss notification" do
 206     test "it dismisses a notification that belongs to the user" do
 207       user = insert(:user)
 208       other_user = insert(:user)
 209
 210       {:ok, activity} =
 211         TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
 212
 213       {:ok, [notification]} = Notification.create_notifications(activity)
 214       {:ok, notification} = Notification.dismiss(other_user, notification.id)
 215
 216       assert notification.user_id == other_user.id
 217     end
 218
 219     test "it returns error if the notification doesn't belong to the user" do
 220       user = insert(:user)
 221       other_user = insert(:user)
 222
 223       {:ok, activity} =
 224         TwitterAPI.create_status(user, %{"status" => "hey @#{other_user.nickname}"})
 225
 226       {:ok, [notification]} = Notification.create_notifications(activity)
 227       {:error, _notification} = Notification.dismiss(user, notification.id)
 228     end
 229   end
 230
 231   describe "clear notification" do
 232     test "it clears all notifications belonging to the user" do
 233       user = insert(:user)
 234       other_user = insert(:user)
 235       third_user = insert(:user)
 236
 237       {:ok, activity} =
 238         TwitterAPI.create_status(user, %{
 239           "status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
 240         })
 241
 242       {:ok, _notifs} = Notification.create_notifications(activity)
 243
 244       {:ok, activity} =
 245         TwitterAPI.create_status(user, %{
 246           "status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
 247         })
 248
 249       {:ok, _notifs} = Notification.create_notifications(activity)
 250       Notification.clear(other_user)
 251
 252       assert Notification.for_user(other_user) == []
 253       assert Notification.for_user(third_user) != []
 254     end
 255   end
 256
 257   describe "set_read_up_to()" do
 258     test "it sets all notifications as read up to a specified notification ID" do
 259       user = insert(:user)
 260       other_user = insert(:user)
 261
 262       {:ok, _activity} =
 263         TwitterAPI.create_status(user, %{
 264           "status" => "hey @#{other_user.nickname}!"
 265         })
 266
 267       {:ok, _activity} =
 268         TwitterAPI.create_status(user, %{
 269           "status" => "hey again @#{other_user.nickname}!"
 270         })
 271
 272       [n2, n1] = notifs = Notification.for_user(other_user)
 273       assert length(notifs) == 2
 274
 275       assert n2.id > n1.id
 276
 277       {:ok, _activity} =
 278         TwitterAPI.create_status(user, %{
 279           "status" => "hey yet again @#{other_user.nickname}!"
 280         })
 281
 282       Notification.set_read_up_to(other_user, n2.id)
 283
 284       [n3, n2, n1] = Notification.for_user(other_user)
 285
 286       assert n1.seen == true
 287       assert n2.seen == true
 288       assert n3.seen == false
 289     end
 290   end
 291
 292   describe "notification target determination" do
 293     test "it sends notifications to addressed users in new messages" do
 294       user = insert(:user)
 295       other_user = insert(:user)
 296
 297       {:ok, activity} =
 298         CommonAPI.post(user, %{
 299           "status" => "hey @#{other_user.nickname}!"
 300         })
 301
 302       assert other_user in Notification.get_notified_from_activity(activity)
 303     end
 304
 305     test "it sends notifications to mentioned users in new messages" do
 306       user = insert(:user)
 307       other_user = insert(:user)
 308
 309       create_activity = %{
 310         "@context" => "https://www.w3.org/ns/activitystreams",
 311         "type" => "Create",
 312         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
 313         "actor" => user.ap_id,
 314         "object" => %{
 315           "type" => "Note",
 316           "content" => "message with a Mention tag, but no explicit tagging",
 317           "tag" => [
 318             %{
 319               "type" => "Mention",
 320               "href" => other_user.ap_id,
 321               "name" => other_user.nickname
 322             }
 323           ],
 324           "attributedTo" => user.ap_id
 325         }
 326       }
 327
 328       {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
 329
 330       assert other_user in Notification.get_notified_from_activity(activity)
 331     end
 332
 333     test "it does not send notifications to users who are only cc in new messages" do
 334       user = insert(:user)
 335       other_user = insert(:user)
 336
 337       create_activity = %{
 338         "@context" => "https://www.w3.org/ns/activitystreams",
 339         "type" => "Create",
 340         "to" => ["https://www.w3.org/ns/activitystreams#Public"],
 341         "cc" => [other_user.ap_id],
 342         "actor" => user.ap_id,
 343         "object" => %{
 344           "type" => "Note",
 345           "content" => "hi everyone",
 346           "attributedTo" => user.ap_id
 347         }
 348       }
 349
 350       {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
 351
 352       assert other_user not in Notification.get_notified_from_activity(activity)
 353     end
 354
 355     test "it does not send notification to mentioned users in likes" do
 356       user = insert(:user)
 357       other_user = insert(:user)
 358       third_user = insert(:user)
 359
 360       {:ok, activity_one} =
 361         CommonAPI.post(user, %{
 362           "status" => "hey @#{other_user.nickname}!"
 363         })
 364
 365       {:ok, activity_two, _} = CommonAPI.favorite(activity_one.id, third_user)
 366
 367       assert other_user not in Notification.get_notified_from_activity(activity_two)
 368     end
 369
 370     test "it does not send notification to mentioned users in announces" do
 371       user = insert(:user)
 372       other_user = insert(:user)
 373       third_user = insert(:user)
 374
 375       {:ok, activity_one} =
 376         CommonAPI.post(user, %{
 377           "status" => "hey @#{other_user.nickname}!"
 378         })
 379
 380       {:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)
 381
 382       assert other_user not in Notification.get_notified_from_activity(activity_two)
 383     end
 384   end
 385
 386   describe "notification lifecycle" do
 387     test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
 388       user = insert(:user)
 389       other_user = insert(:user)
 390
 391       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 392
 393       assert Enum.empty?(Notification.for_user(user))
 394
 395       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
 396
 397       assert length(Notification.for_user(user)) == 1
 398
 399       {:ok, _} = CommonAPI.delete(activity.id, user)
 400
 401       assert Enum.empty?(Notification.for_user(user))
 402     end
 403
 404     test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
 405       user = insert(:user)
 406       other_user = insert(:user)
 407
 408       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 409
 410       assert Enum.empty?(Notification.for_user(user))
 411
 412       {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
 413
 414       assert length(Notification.for_user(user)) == 1
 415
 416       {:ok, _, _, _} = CommonAPI.unfavorite(activity.id, other_user)
 417
 418       assert Enum.empty?(Notification.for_user(user))
 419     end
 420
 421     test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
 422       user = insert(:user)
 423       other_user = insert(:user)
 424
 425       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 426
 427       assert Enum.empty?(Notification.for_user(user))
 428
 429       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
 430
 431       assert length(Notification.for_user(user)) == 1
 432
 433       {:ok, _} = CommonAPI.delete(activity.id, user)
 434
 435       assert Enum.empty?(Notification.for_user(user))
 436     end
 437
 438     test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
 439       user = insert(:user)
 440       other_user = insert(:user)
 441
 442       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 443
 444       assert Enum.empty?(Notification.for_user(user))
 445
 446       {:ok, _, _} = CommonAPI.repeat(activity.id, other_user)
 447
 448       assert length(Notification.for_user(user)) == 1
 449
 450       {:ok, _, _} = CommonAPI.unrepeat(activity.id, other_user)
 451
 452       assert Enum.empty?(Notification.for_user(user))
 453     end
 454
 455     test "liking an activity which is already deleted does not generate a notification" do
 456       user = insert(:user)
 457       other_user = insert(:user)
 458
 459       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 460
 461       assert Enum.empty?(Notification.for_user(user))
 462
 463       {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
 464
 465       assert Enum.empty?(Notification.for_user(user))
 466
 467       {:error, _} = CommonAPI.favorite(activity.id, other_user)
 468
 469       assert Enum.empty?(Notification.for_user(user))
 470     end
 471
 472     test "repeating an activity which is already deleted does not generate a notification" do
 473       user = insert(:user)
 474       other_user = insert(:user)
 475
 476       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 477
 478       assert Enum.empty?(Notification.for_user(user))
 479
 480       {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
 481
 482       assert Enum.empty?(Notification.for_user(user))
 483
 484       {:error, _} = CommonAPI.repeat(activity.id, other_user)
 485
 486       assert Enum.empty?(Notification.for_user(user))
 487     end
 488
 489     test "replying to a deleted post without tagging does not generate a notification" do
 490       user = insert(:user)
 491       other_user = insert(:user)
 492
 493       {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
 494       {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
 495
 496       {:ok, _reply_activity} =
 497         CommonAPI.post(other_user, %{
 498           "status" => "test reply",
 499           "in_reply_to_status_id" => activity.id
 500         })
 501
 502       assert Enum.empty?(Notification.for_user(user))
 503     end
 504   end
 505 end