pleroma

notification_test.exs (43043B)

# Pleroma: A lightweight social networking server
# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.NotificationTest do
  use Pleroma.DataCase, async: false
  import Pleroma.Factory
  import Mock
  alias Pleroma.FollowingRelationship
  alias Pleroma.Notification
  alias Pleroma.Repo
  alias Pleroma.Tests.ObanHelpers
  alias Pleroma.User
  alias Pleroma.Web.ActivityPub.ActivityPub
  alias Pleroma.Web.ActivityPub.Builder
  alias Pleroma.Web.ActivityPub.Transmogrifier
  alias Pleroma.Web.CommonAPI
  alias Pleroma.Web.MastodonAPI.NotificationView
  alias Pleroma.Web.Push
  alias Pleroma.Web.Streamer
  setup do
    Mox.stub_with(Pleroma.UnstubbedConfigMock, Pleroma.Config)
    :ok
  end
  describe "create_notifications" do
    test "never returns nil" do
      user = insert(:user)
      other_user = insert(:user, %{invisible: true})
      {:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
      {:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
      refute {:ok, [nil]} == Notification.create_notifications(activity)
    end
    test "creates a report notification only for privileged users" do
      reporting_user = insert(:user)
      reported_user = insert(:user)
      moderator_user = insert(:user, is_moderator: true)
      clear_config([:instance, :moderator_privileges], [])
      {:ok, activity1} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
      {:ok, []} = Notification.create_notifications(activity1)
      clear_config([:instance, :moderator_privileges], [:reports_manage_reports])
      {:ok, activity2} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
      {:ok, [notification]} = Notification.create_notifications(activity2)
      assert notification.user_id == moderator_user.id
      assert notification.type == "pleroma:report"
    end
    test "suppresses notifications for own reports" do
      clear_config([:instance, :admin_privileges], [:reports_manage_reports])
      reporting_admin = insert(:user, is_admin: true)
      reported_user = insert(:user)
      other_admin = insert(:user, is_admin: true)
      {:ok, activity} = CommonAPI.report(reporting_admin, %{account_id: reported_user.id})
      {:ok, [notification]} = Notification.create_notifications(activity)
      refute notification.user_id == reporting_admin.id
      assert notification.user_id == other_admin.id
      assert notification.type == "pleroma:report"
    end
    test "creates a notification for an emoji reaction" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
      {:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
      {:ok, [notification]} = Notification.create_notifications(activity)
      assert notification.user_id == user.id
      assert notification.type == "pleroma:emoji_reaction"
    end
    test "notifies someone when they are directly addressed" do
      user = insert(:user)
      other_user = insert(:user)
      third_user = insert(:user)
      {:ok, activity} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname} and @#{third_user.nickname}"
        })
      {:ok, [notification, other_notification]} = Notification.create_notifications(activity)
      notified_ids = Enum.sort([notification.user_id, other_notification.user_id])
      assert notified_ids == [other_user.id, third_user.id]
      assert notification.activity_id == activity.id
      assert notification.type == "mention"
      assert other_notification.activity_id == activity.id
      assert [%Pleroma.Marker{unread_count: 2}] =
               Pleroma.Marker.get_markers(other_user, ["notifications"])
    end
    test "it creates a notification for subscribed users" do
      user = insert(:user)
      subscriber = insert(:user)
      User.subscribe(subscriber, user)
      {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
      {:ok, [notification]} = Notification.create_notifications(status)
      assert notification.user_id == subscriber.id
    end
    test "does not create a notification for subscribed users if status is a reply" do
      user = insert(:user)
      other_user = insert(:user)
      subscriber = insert(:user)
      User.subscribe(subscriber, other_user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      {:ok, _reply_activity} =
        CommonAPI.post(other_user, %{
          status: "test reply",
          in_reply_to_status_id: activity.id
        })
      user_notifications = Notification.for_user(user)
      assert length(user_notifications) == 1
      subscriber_notifications = Notification.for_user(subscriber)
      assert Enum.empty?(subscriber_notifications)
    end
    test "it sends edited notifications to those who repeated a status" do
      user = insert(:user)
      repeated_user = insert(:user)
      other_user = insert(:user)
      {:ok, activity_one} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname}!"
        })
      {:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)
      {:ok, _edit_activity} =
        CommonAPI.update(user, activity_one, %{
          status: "hey @#{other_user.nickname}! mew mew"
        })
      assert [%{type: "reblog"}] = Notification.for_user(user)
      assert [%{type: "update"}] = Notification.for_user(repeated_user)
      assert [%{type: "mention"}] = Notification.for_user(other_user)
    end
  end
  test "create_poll_notifications/1" do
    [user1, user2, user3, _, _] = insert_list(5, :user)
    question = insert(:question, user: user1)
    activity = insert(:question_activity, question: question)
    {:ok, _, _} = CommonAPI.vote(user2, question, [0])
    {:ok, _, _} = CommonAPI.vote(user3, question, [1])
    {:ok, notifications} = Notification.create_poll_notifications(activity)
    assert [user2.id, user3.id, user1.id] == Enum.map(notifications, & &1.user_id)
  end
  describe "CommonApi.post/2 notification-related functionality" do
    test_with_mock "creates but does NOT send notification to blocker user",
                   Push,
                   [:passthrough],
                   [] do
      user = insert(:user)
      blocker = insert(:user)
      {:ok, _user_relationship} = User.block(blocker, user)
      {:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{blocker.nickname}!"})
      blocker_id = blocker.id
      assert [%Notification{user_id: ^blocker_id}] = Repo.all(Notification)
      refute called(Push.send(:_))
    end
    test_with_mock "creates but does NOT send notification to notification-muter user",
                   Push,
                   [:passthrough],
                   [] do
      user = insert(:user)
      muter = insert(:user)
      {:ok, _user_relationships} = User.mute(muter, user)
      {:ok, _activity} = CommonAPI.post(user, %{status: "hey @#{muter.nickname}!"})
      muter_id = muter.id
      assert [%Notification{user_id: ^muter_id}] = Repo.all(Notification)
      refute called(Push.send(:_))
    end
    test_with_mock "creates but does NOT send notification to thread-muter user",
                   Push,
                   [:passthrough],
                   [] do
      user = insert(:user)
      thread_muter = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{thread_muter.nickname}!"})
      {:ok, _} = CommonAPI.add_mute(thread_muter, activity)
      {:ok, _same_context_activity} =
        CommonAPI.post(user, %{
          status: "hey-hey-hey @#{thread_muter.nickname}!",
          in_reply_to_status_id: activity.id
        })
      [pre_mute_notification, post_mute_notification] =
        Repo.all(from(n in Notification, where: n.user_id == ^thread_muter.id, order_by: n.id))
      pre_mute_notification_id = pre_mute_notification.id
      post_mute_notification_id = post_mute_notification.id
      assert called(
               Push.send(
                 :meck.is(fn
                   %Notification{id: ^pre_mute_notification_id} -> true
                   _ -> false
                 end)
               )
             )
      refute called(
               Push.send(
                 :meck.is(fn
                   %Notification{id: ^post_mute_notification_id} -> true
                   _ -> false
                 end)
               )
             )
    end
  end
  describe "create_notification" do
    @tag needs_streamer: true
    test "it creates a notification for user and send to the 'user' and the 'user:notification' stream" do
      %{user: user, token: oauth_token} = oauth_access(["read"])
      task =
        Task.async(fn ->
          {:ok, _topic} = Streamer.get_topic_and_add_socket("user", user, oauth_token)
          assert_receive {:render_with_user, _, _, _, _}, 4_000
        end)
      task_user_notification =
        Task.async(fn ->
          {:ok, _topic} =
            Streamer.get_topic_and_add_socket("user:notification", user, oauth_token)
          assert_receive {:render_with_user, _, _, _, _}, 4_000
        end)
      activity = insert(:note_activity)
      notify = Notification.create_notification(activity, user)
      assert notify.user_id == user.id
      Task.await(task)
      Task.await(task_user_notification)
    end
    test "it creates a notification for user if the user blocks the activity author" do
      activity = insert(:note_activity)
      author = User.get_cached_by_ap_id(activity.data["actor"])
      user = insert(:user)
      {:ok, _user_relationship} = User.block(user, author)
      assert Notification.create_notification(activity, user)
    end
    test "it creates a notification for the user if the user mutes the activity author" do
      muter = insert(:user)
      muted = insert(:user)
      {:ok, _} = User.mute(muter, muted)
      muter = Repo.get(User, muter.id)
      {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})
      notification = Notification.create_notification(activity, muter)
      assert notification.id
      assert notification.seen
    end
    test "notification created if user is muted without notifications" do
      muter = insert(:user)
      muted = insert(:user)
      {:ok, _user_relationships} = User.mute(muter, muted, %{notifications: false})
      {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})
      assert Notification.create_notification(activity, muter)
    end
    test "it creates a notification for an activity from a muted thread" do
      muter = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(muter, %{status: "hey"})
      CommonAPI.add_mute(muter, activity)
      {:ok, activity} =
        CommonAPI.post(other_user, %{
          status: "Hi @#{muter.nickname}",
          in_reply_to_status_id: activity.id
        })
      notification = Notification.create_notification(activity, muter)
      assert notification.id
      assert notification.seen
    end
    test "it disables notifications from strangers" do
      follower = insert(:user)
      followed =
        insert(:user,
          notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
        )
      {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
      refute Notification.create_notification(activity, followed)
    end
    test "it disables notifications from non-followees" do
      follower = insert(:user)
      followed =
        insert(:user,
          notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
        )
      CommonAPI.follow(follower, followed)
      {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})
      refute Notification.create_notification(activity, followed)
    end
    test "it allows notifications from followees" do
      poster = insert(:user)
      receiver =
        insert(:user,
          notification_settings: %Pleroma.User.NotificationSetting{block_from_strangers: true}
        )
      CommonAPI.follow(receiver, poster)
      {:ok, activity} = CommonAPI.post(poster, %{status: "hey @#{receiver.nickname}"})
      assert Notification.create_notification(activity, receiver)
    end
    test "it doesn't create a notification for user if he is the activity author" do
      activity = insert(:note_activity)
      author = User.get_cached_by_ap_id(activity.data["actor"])
      refute Notification.create_notification(activity, author)
    end
    test "it doesn't create duplicate notifications for follow+subscribed users" do
      user = insert(:user)
      subscriber = insert(:user)
      {:ok, _, _, _} = CommonAPI.follow(subscriber, user)
      User.subscribe(subscriber, user)
      {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})
      {:ok, [_notif]} = Notification.create_notifications(status)
    end
    test "it doesn't create subscription notifications if the recipient cannot see the status" do
      user = insert(:user)
      subscriber = insert(:user)
      User.subscribe(subscriber, user)
      {:ok, status} = CommonAPI.post(user, %{status: "inwisible", visibility: "direct"})
      assert {:ok, []} == Notification.create_notifications(status)
    end
    test "it disables notifications from people who are invisible" do
      author = insert(:user, invisible: true)
      user = insert(:user)
      {:ok, status} = CommonAPI.post(author, %{status: "hey @#{user.nickname}"})
      refute Notification.create_notification(status, user)
    end
    test "it doesn't create notifications if content matches with an irreversible filter" do
      user = insert(:user)
      subscriber = insert(:user)
      User.subscribe(subscriber, user)
      insert(:filter, user: subscriber, phrase: "cofe", hide: true)
      {:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})
      assert {:ok, []} == Notification.create_notifications(status)
    end
    test "it creates notifications if content matches with a not irreversible filter" do
      user = insert(:user)
      subscriber = insert(:user)
      User.subscribe(subscriber, user)
      insert(:filter, user: subscriber, phrase: "cofe", hide: false)
      {:ok, status} = CommonAPI.post(user, %{status: "got cofe?"})
      {:ok, [notification]} = Notification.create_notifications(status)
      assert notification
      refute notification.seen
    end
    test "it creates notifications when someone likes user's status with a filtered word" do
      user = insert(:user)
      other_user = insert(:user)
      insert(:filter, user: user, phrase: "tesla", hide: true)
      {:ok, activity_one} = CommonAPI.post(user, %{status: "wow tesla"})
      {:ok, activity_two} = CommonAPI.favorite(other_user, activity_one.id)
      {:ok, [notification]} = Notification.create_notifications(activity_two)
      assert notification
      refute notification.seen
    end
  end
  describe "follow / follow_request notifications" do
    test "it creates `follow` notification for approved Follow activity" do
      user = insert(:user)
      followed_user = insert(:user, is_locked: false)
      {:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
      assert FollowingRelationship.following?(user, followed_user)
      assert [notification] = Notification.for_user(followed_user)
      assert %{type: "follow"} =
               NotificationView.render("show.json", %{
                 notification: notification,
                 for: followed_user
               })
    end
    test "it creates `follow_request` notification for pending Follow activity" do
      user = insert(:user)
      followed_user = insert(:user, is_locked: true)
      {:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
      refute FollowingRelationship.following?(user, followed_user)
      assert [notification] = Notification.for_user(followed_user)
      render_opts = %{notification: notification, for: followed_user}
      assert %{type: "follow_request"} = NotificationView.render("show.json", render_opts)
      # After request is accepted, the same notification is rendered with type "follow":
      assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)
      notification =
        Repo.get(Notification, notification.id)
        |> Repo.preload(:activity)
      assert %{type: "follow"} =
               NotificationView.render("show.json", notification: notification, for: followed_user)
    end
    test "it doesn't create a notification for follow-unfollow-follow chains" do
      user = insert(:user)
      followed_user = insert(:user, is_locked: false)
      {:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
      assert FollowingRelationship.following?(user, followed_user)
      assert [notification] = Notification.for_user(followed_user)
      CommonAPI.unfollow(user, followed_user)
      {:ok, _, _, _activity_dupe} = CommonAPI.follow(user, followed_user)
      notification_id = notification.id
      assert [%{id: ^notification_id}] = Notification.for_user(followed_user)
    end
    test "dismisses the notification on follow request rejection" do
      user = insert(:user, is_locked: true)
      follower = insert(:user)
      {:ok, _, _, _follow_activity} = CommonAPI.follow(follower, user)
      assert [_notification] = Notification.for_user(user)
      {:ok, _follower} = CommonAPI.reject_follow_request(follower, user)
      assert [] = Notification.for_user(user)
    end
  end
  describe "get notification" do
    test "it gets a notification that belongs to the user" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
      {:ok, [notification]} = Notification.create_notifications(activity)
      {:ok, notification} = Notification.get(other_user, notification.id)
      assert notification.user_id == other_user.id
    end
    test "it returns error if the notification doesn't belong to the user" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
      {:ok, [notification]} = Notification.create_notifications(activity)
      {:error, _notification} = Notification.get(user, notification.id)
    end
  end
  describe "dismiss notification" do
    test "it dismisses a notification that belongs to the user" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
      {:ok, [notification]} = Notification.create_notifications(activity)
      {:ok, notification} = Notification.dismiss(other_user, notification.id)
      assert notification.user_id == other_user.id
    end
    test "it returns error if the notification doesn't belong to the user" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})
      {:ok, [notification]} = Notification.create_notifications(activity)
      {:error, _notification} = Notification.dismiss(user, notification.id)
    end
  end
  describe "clear notification" do
    test "it clears all notifications belonging to the user" do
      user = insert(:user)
      other_user = insert(:user)
      third_user = insert(:user)
      {:ok, activity} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname} and @#{third_user.nickname} !"
        })
      {:ok, _notifs} = Notification.create_notifications(activity)
      {:ok, activity} =
        CommonAPI.post(user, %{
          status: "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
        })
      {:ok, _notifs} = Notification.create_notifications(activity)
      Notification.clear(other_user)
      assert Notification.for_user(other_user) == []
      assert Notification.for_user(third_user) != []
    end
  end
  describe "set_read_up_to()" do
    test "it sets all notifications as read up to a specified notification ID" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, _activity} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname}!"
        })
      {:ok, _activity} =
        CommonAPI.post(user, %{
          status: "hey again @#{other_user.nickname}!"
        })
      [n2, n1] = Notification.for_user(other_user)
      assert n2.id > n1.id
      {:ok, _activity} =
        CommonAPI.post(user, %{
          status: "hey yet again @#{other_user.nickname}!"
        })
      [_, read_notification] = Notification.set_read_up_to(other_user, n2.id)
      assert read_notification.activity.object
      [n3, n2, n1] = Notification.for_user(other_user)
      assert n1.seen == true
      assert n2.seen == true
      assert n3.seen == false
      assert %Pleroma.Marker{} =
               m =
               Pleroma.Repo.get_by(
                 Pleroma.Marker,
                 user_id: other_user.id,
                 timeline: "notifications"
               )
      assert m.last_read_id == to_string(n2.id)
    end
  end
  describe "for_user_since/2" do
    defp days_ago(days) do
      NaiveDateTime.add(
        NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second),
        -days * 60 * 60 * 24,
        :second
      )
    end
    test "Returns recent notifications" do
      user1 = insert(:user)
      user2 = insert(:user)
      Enum.each(0..10, fn i ->
        {:ok, _activity} =
          CommonAPI.post(user1, %{
            status: "hey ##{i} @#{user2.nickname}!"
          })
      end)
      {old, new} = Enum.split(Notification.for_user(user2), 5)
      Enum.each(old, fn notification ->
        notification
        |> cast(%{updated_at: days_ago(10)}, [:updated_at])
        |> Pleroma.Repo.update!()
      end)
      recent_notifications_ids =
        user2
        |> Notification.for_user_since(
          NaiveDateTime.add(NaiveDateTime.utc_now(), -5 * 86_400, :second)
        )
        |> Enum.map(& &1.id)
      Enum.each(old, fn %{id: id} ->
        refute id in recent_notifications_ids
      end)
      Enum.each(new, fn %{id: id} ->
        assert id in recent_notifications_ids
      end)
    end
  end
  describe "notification target determination / get_notified_from_activity/2" do
    test "it sends notifications to addressed users in new messages" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname}!"
        })
      {enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)
      assert other_user in enabled_receivers
    end
    test "it sends notifications to mentioned users in new messages" do
      user = insert(:user)
      other_user = insert(:user)
      create_activity = %{
        "@context" => "https://www.w3.org/ns/activitystreams",
        "type" => "Create",
        "to" => ["https://www.w3.org/ns/activitystreams#Public"],
        "actor" => user.ap_id,
        "object" => %{
          "type" => "Note",
          "id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
          "to" => ["https://www.w3.org/ns/activitystreams#Public"],
          "content" => "message with a Mention tag, but no explicit tagging",
          "tag" => [
            %{
              "type" => "Mention",
              "href" => other_user.ap_id,
              "name" => other_user.nickname
            }
          ],
          "attributedTo" => user.ap_id
        }
      }
      {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
      {enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)
      assert other_user in enabled_receivers
    end
    test "it does not send notifications to users who are only cc in new messages" do
      user = insert(:user)
      other_user = insert(:user)
      create_activity = %{
        "@context" => "https://www.w3.org/ns/activitystreams",
        "type" => "Create",
        "to" => ["https://www.w3.org/ns/activitystreams#Public"],
        "cc" => [other_user.ap_id],
        "actor" => user.ap_id,
        "object" => %{
          "type" => "Note",
          "id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
          "to" => ["https://www.w3.org/ns/activitystreams#Public"],
          "cc" => [other_user.ap_id],
          "content" => "hi everyone",
          "attributedTo" => user.ap_id
        }
      }
      {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
      {enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(activity)
      assert other_user not in enabled_receivers
    end
    test "it does not send notification to mentioned users in likes" do
      user = insert(:user)
      other_user = insert(:user)
      third_user = insert(:user)
      {:ok, activity_one} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname}!"
        })
      {:ok, activity_two} = CommonAPI.favorite(third_user, activity_one.id)
      {enabled_receivers, _disabled_receivers} =
        Notification.get_notified_from_activity(activity_two)
      assert other_user not in enabled_receivers
    end
    test "it only notifies the post's author in likes" do
      user = insert(:user)
      other_user = insert(:user)
      third_user = insert(:user)
      {:ok, activity_one} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname}!"
        })
      {:ok, like_data, _} = Builder.like(third_user, activity_one.object)
      {:ok, like, _} =
        like_data
        |> Map.put("to", [other_user.ap_id | like_data["to"]])
        |> ActivityPub.persist(local: true)
      {enabled_receivers, _disabled_receivers} = Notification.get_notified_from_activity(like)
      assert other_user not in enabled_receivers
    end
    test "it does not send notification to mentioned users in announces" do
      user = insert(:user)
      other_user = insert(:user)
      third_user = insert(:user)
      {:ok, activity_one} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname}!"
        })
      {:ok, activity_two} = CommonAPI.repeat(activity_one.id, third_user)
      {enabled_receivers, _disabled_receivers} =
        Notification.get_notified_from_activity(activity_two)
      assert other_user not in enabled_receivers
    end
    test "it returns blocking recipient in disabled recipients list" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, _user_relationship} = User.block(other_user, user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
      {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
      assert [] == enabled_receivers
      assert [other_user] == disabled_receivers
    end
    test "it returns notification-muting recipient in disabled recipients list" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, _user_relationships} = User.mute(other_user, user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
      {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
      assert [] == enabled_receivers
      assert [other_user] == disabled_receivers
    end
    test "it returns thread-muting recipient in disabled recipients list" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
      {:ok, _} = CommonAPI.add_mute(other_user, activity)
      {:ok, same_context_activity} =
        CommonAPI.post(user, %{
          status: "hey-hey-hey @#{other_user.nickname}!",
          in_reply_to_status_id: activity.id
        })
      {enabled_receivers, disabled_receivers} =
        Notification.get_notified_from_activity(same_context_activity)
      assert [other_user] == disabled_receivers
      refute other_user in enabled_receivers
    end
    test "it returns non-following domain-blocking recipient in disabled recipients list" do
      blocked_domain = "blocked.domain"
      user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
      other_user = insert(:user)
      {:ok, other_user} = User.block_domain(other_user, blocked_domain)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
      {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
      assert [] == enabled_receivers
      assert [other_user] == disabled_receivers
    end
    test "it returns following domain-blocking recipient in enabled recipients list" do
      blocked_domain = "blocked.domain"
      user = insert(:user, %{ap_id: "https://#{blocked_domain}/@actor"})
      other_user = insert(:user)
      {:ok, other_user} = User.block_domain(other_user, blocked_domain)
      {:ok, other_user, user} = User.follow(other_user, user)
      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}!"})
      {enabled_receivers, disabled_receivers} = Notification.get_notified_from_activity(activity)
      assert [other_user] == enabled_receivers
      assert [] == disabled_receivers
    end
    test "it sends edited notifications to those who repeated a status" do
      user = insert(:user)
      repeated_user = insert(:user)
      other_user = insert(:user)
      {:ok, activity_one} =
        CommonAPI.post(user, %{
          status: "hey @#{other_user.nickname}!"
        })
      {:ok, _activity_two} = CommonAPI.repeat(activity_one.id, repeated_user)
      {:ok, edit_activity} =
        CommonAPI.update(user, activity_one, %{
          status: "hey @#{other_user.nickname}! mew mew"
        })
      {enabled_receivers, _disabled_receivers} =
        Notification.get_notified_from_activity(edit_activity)
      assert repeated_user in enabled_receivers
      assert other_user not in enabled_receivers
    end
  end
  describe "notification lifecycle" do
    test "liking an activity results in 1 notification, then 0 if the activity is deleted" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      assert Enum.empty?(Notification.for_user(user))
      {:ok, _} = CommonAPI.favorite(other_user, activity.id)
      assert length(Notification.for_user(user)) == 1
      {:ok, _} = CommonAPI.delete(activity.id, user)
      assert Enum.empty?(Notification.for_user(user))
    end
    test "liking an activity results in 1 notification, then 0 if the activity is unliked" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      assert Enum.empty?(Notification.for_user(user))
      {:ok, _} = CommonAPI.favorite(other_user, activity.id)
      assert length(Notification.for_user(user)) == 1
      {:ok, _} = CommonAPI.unfavorite(activity.id, other_user)
      assert Enum.empty?(Notification.for_user(user))
    end
    test "repeating an activity results in 1 notification, then 0 if the activity is deleted" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      assert Enum.empty?(Notification.for_user(user))
      {:ok, _} = CommonAPI.repeat(activity.id, other_user)
      assert length(Notification.for_user(user)) == 1
      {:ok, _} = CommonAPI.delete(activity.id, user)
      assert Enum.empty?(Notification.for_user(user))
    end
    test "repeating an activity results in 1 notification, then 0 if the activity is unrepeated" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      assert Enum.empty?(Notification.for_user(user))
      {:ok, _} = CommonAPI.repeat(activity.id, other_user)
      assert length(Notification.for_user(user)) == 1
      {:ok, _} = CommonAPI.unrepeat(activity.id, other_user)
      assert Enum.empty?(Notification.for_user(user))
    end
    test "liking an activity which is already deleted does not generate a notification" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      assert Enum.empty?(Notification.for_user(user))
      {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
      assert Enum.empty?(Notification.for_user(user))
      {:error, :not_found} = CommonAPI.favorite(other_user, activity.id)
      assert Enum.empty?(Notification.for_user(user))
    end
    test "repeating an activity which is already deleted does not generate a notification" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      assert Enum.empty?(Notification.for_user(user))
      {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
      assert Enum.empty?(Notification.for_user(user))
      {:error, _} = CommonAPI.repeat(activity.id, other_user)
      assert Enum.empty?(Notification.for_user(user))
    end
    test "replying to a deleted post without tagging does not generate a notification" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})
      {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
      {:ok, _reply_activity} =
        CommonAPI.post(other_user, %{
          status: "test reply",
          in_reply_to_status_id: activity.id
        })
      assert Enum.empty?(Notification.for_user(user))
    end
    test "notifications are deleted if a local user is deleted" do
      user = insert(:user)
      other_user = insert(:user)
      {:ok, _activity} =
        CommonAPI.post(user, %{status: "hi @#{other_user.nickname}", visibility: "direct"})
      refute Enum.empty?(Notification.for_user(other_user))
      {:ok, job} = User.delete(user)
      ObanHelpers.perform(job)
      assert Enum.empty?(Notification.for_user(other_user))
    end
    test "notifications are deleted if a remote user is deleted" do
      remote_user = insert(:user)
      local_user = insert(:user)
      dm_message = %{
        "@context" => "https://www.w3.org/ns/activitystreams",
        "type" => "Create",
        "actor" => remote_user.ap_id,
        "id" => remote_user.ap_id <> "/activities/test",
        "to" => [local_user.ap_id],
        "cc" => [],
        "object" => %{
          "type" => "Note",
          "id" => remote_user.ap_id <> "/objects/test",
          "content" => "Hello!",
          "tag" => [
            %{
              "type" => "Mention",
              "href" => local_user.ap_id,
              "name" => "@#{local_user.nickname}"
            }
          ],
          "to" => [local_user.ap_id],
          "cc" => [],
          "attributedTo" => remote_user.ap_id
        }
      }
      {:ok, _dm_activity} = Transmogrifier.handle_incoming(dm_message)
      refute Enum.empty?(Notification.for_user(local_user))
      delete_user_message = %{
        "@context" => "https://www.w3.org/ns/activitystreams",
        "id" => remote_user.ap_id <> "/activities/delete",
        "actor" => remote_user.ap_id,
        "type" => "Delete",
        "object" => remote_user.ap_id
      }
      remote_user_url = remote_user.ap_id
      Tesla.Mock.mock(fn
        %{method: :get, url: ^remote_user_url} ->
          %Tesla.Env{status: 404, body: ""}
      end)
      {:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)
      ObanHelpers.perform_all()
      assert Enum.empty?(Notification.for_user(local_user))
    end
    test "move activity generates a notification" do
      %{ap_id: old_ap_id} = old_user = insert(:user)
      %{ap_id: new_ap_id} = new_user = insert(:user, also_known_as: [old_ap_id])
      follower = insert(:user)
      other_follower = insert(:user, %{allow_following_move: false})
      User.follow(follower, old_user)
      User.follow(other_follower, old_user)
      Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
      ObanHelpers.perform_all()
      assert [
               %{
                 activity: %{
                   data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
                 }
               }
             ] = Notification.for_user(follower)
      assert [
               %{
                 activity: %{
                   data: %{"type" => "Move", "actor" => ^old_ap_id, "target" => ^new_ap_id}
                 }
               }
             ] = Notification.for_user(other_follower)
    end
  end
  describe "for_user" do
    setup do
      user = insert(:user)
      {:ok, %{user: user}}
    end
    test "it returns notifications for muted user without notifications", %{user: user} do
      muted = insert(:user)
      {:ok, _user_relationships} = User.mute(user, muted, %{notifications: false})
      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
      [notification] = Notification.for_user(user)
      assert notification.activity.object
      assert notification.seen
    end
    test "it doesn't return notifications for muted user with notifications", %{user: user} do
      muted = insert(:user)
      {:ok, _user_relationships} = User.mute(user, muted)
      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
      assert Notification.for_user(user) == []
    end
    test "it doesn't return notifications for blocked user", %{user: user} do
      blocked = insert(:user)
      {:ok, _user_relationship} = User.block(user, blocked)
      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
      assert Notification.for_user(user) == []
    end
    test "it doesn't return notifications for domain-blocked non-followed user", %{user: user} do
      blocked = insert(:user, ap_id: "http://some-domain.com")
      {:ok, user} = User.block_domain(user, "some-domain.com")
      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
      assert Notification.for_user(user) == []
    end
    test "it returns notifications for domain-blocked but followed user" do
      user = insert(:user)
      blocked = insert(:user, ap_id: "http://some-domain.com")
      {:ok, user} = User.block_domain(user, "some-domain.com")
      {:ok, _, _} = User.follow(user, blocked)
      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
      assert length(Notification.for_user(user)) == 1
    end
    test "it doesn't return notifications for muted thread", %{user: user} do
      another_user = insert(:user)
      {:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})
      {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
      assert Notification.for_user(user) == []
    end
    test "it returns notifications from a muted user when with_muted is set", %{user: user} do
      muted = insert(:user)
      {:ok, _user_relationships} = User.mute(user, muted)
      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})
      assert length(Notification.for_user(user, %{with_muted: true})) == 1
    end
    test "it doesn't return notifications from a blocked user when with_muted is set", %{
      user: user
    } do
      blocked = insert(:user)
      {:ok, _user_relationship} = User.block(user, blocked)
      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
      assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
    end
    test "when with_muted is set, " <>
           "it doesn't return notifications from a domain-blocked non-followed user",
         %{user: user} do
      blocked = insert(:user, ap_id: "http://some-domain.com")
      {:ok, user} = User.block_domain(user, "some-domain.com")
      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})
      assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
    end
    test "it returns notifications from muted threads when with_muted is set", %{user: user} do
      another_user = insert(:user)
      {:ok, activity} = CommonAPI.post(another_user, %{status: "hey @#{user.nickname}"})
      {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
      assert length(Notification.for_user(user, %{with_muted: true})) == 1
    end
    test "it doesn't return notifications about mentions with filtered word", %{user: user} do
      insert(:filter, user: user, phrase: "cofe", hide: true)
      another_user = insert(:user)
      {:ok, _activity} = CommonAPI.post(another_user, %{status: "@#{user.nickname} got cofe?"})
      assert Enum.empty?(Notification.for_user(user))
    end
    test "it returns notifications about mentions with not hidden filtered word", %{user: user} do
      insert(:filter, user: user, phrase: "test", hide: false)
      another_user = insert(:user)
      {:ok, _} = CommonAPI.post(another_user, %{status: "@#{user.nickname} test"})
      assert length(Notification.for_user(user)) == 1
    end
    test "it returns notifications about favorites with filtered word", %{user: user} do
      insert(:filter, user: user, phrase: "cofe", hide: true)
      another_user = insert(:user)
      {:ok, activity} = CommonAPI.post(user, %{status: "Give me my cofe!"})
      {:ok, _} = CommonAPI.favorite(another_user, activity.id)
      assert length(Notification.for_user(user)) == 1
    end
    test "it returns notifications when related object is without content and filters are defined",
         %{user: user} do
      followed_user = insert(:user, is_locked: true)
      insert(:filter, user: followed_user, phrase: "test", hide: true)
      {:ok, _, _, _activity} = CommonAPI.follow(user, followed_user)
      refute FollowingRelationship.following?(user, followed_user)
      assert [notification] = Notification.for_user(followed_user)
      assert %{type: "follow_request"} =
               NotificationView.render("show.json", %{
                 notification: notification,
                 for: followed_user
               })
      assert {:ok, _} = CommonAPI.accept_follow_request(user, followed_user)
      assert [notification] = Notification.for_user(followed_user)
      assert %{type: "follow"} =
               NotificationView.render("show.json", %{
                 notification: notification,
                 for: followed_user
               })
    end
  end
end