Merge branch 'develop' into 'remove-twitter-api'

[akkoma] / test / notification_test.exs

diff --git a/test/notification_test.exs b/test/notification_test.exs
index d240ede9413e1e09bff7b4196b2e525f76b985f1..111ff09f429c5cccb21a1da9c273dadcba6b07e3 100644 (file)
--- a/test/notification_test.exs
+++ b/test/notification_test.exs
@@ -6,12 +6,18 @@ defmodule Pleroma.NotificationTest do
   use Pleroma.DataCase
 
   import Pleroma.Factory
   use Pleroma.DataCase
 
   import Pleroma.Factory

+  import Mock

 
 

+  alias Pleroma.FollowingRelationship

   alias Pleroma.Notification
   alias Pleroma.Tests.ObanHelpers
   alias Pleroma.User
   alias Pleroma.Notification
   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.ActivityPub.Transmogrifier
   alias Pleroma.Web.CommonAPI

+  alias Pleroma.Web.MastodonAPI.NotificationView
+  alias Pleroma.Web.Push

   alias Pleroma.Web.Streamer
 
   describe "create_notifications" do
   alias Pleroma.Web.Streamer
 
   describe "create_notifications" do


@@ -19,8 +25,8 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "yeah"})
-      {:ok, activity, _object} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
+      {:ok, activity} = CommonAPI.post(user, %{status: "yeah"})
+      {:ok, activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

 
       {:ok, [notification]} = Notification.create_notifications(activity)
 
 
       {:ok, [notification]} = Notification.create_notifications(activity)
 


@@ -34,7 +40,7 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
 
       {:ok, activity} =
         CommonAPI.post(user, %{

-          "status" => "hey @#{other_user.nickname} and @#{third_user.nickname}"
+          status: "hey @#{other_user.nickname} and @#{third_user.nickname}"

         })
 
       {:ok, [notification, other_notification]} = Notification.create_notifications(activity)
         })
 
       {:ok, [notification, other_notification]} = Notification.create_notifications(activity)


@@ -43,6 +49,9 @@ defmodule Pleroma.NotificationTest do
       assert notified_ids == [other_user.id, third_user.id]
       assert notification.activity_id == activity.id
       assert other_notification.activity_id == activity.id
       assert notified_ids == [other_user.id, third_user.id]
       assert notification.activity_id == activity.id
       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
     end
 
     test "it creates a notification for subscribed users" do


@@ -51,7 +60,7 @@ defmodule Pleroma.NotificationTest do
 
       User.subscribe(subscriber, user)
 
 
       User.subscribe(subscriber, user)
 

-      {:ok, status} = CommonAPI.post(user, %{"status" => "Akariiiin"})
+      {:ok, status} = CommonAPI.post(user, %{status: "Akariiiin"})

       {:ok, [notification]} = Notification.create_notifications(status)
 
       assert notification.user_id == subscriber.id
       {:ok, [notification]} = Notification.create_notifications(status)
 
       assert notification.user_id == subscriber.id


@@ -64,12 +73,12 @@ defmodule Pleroma.NotificationTest do
 
       User.subscribe(subscriber, other_user)
 
 
       User.subscribe(subscriber, other_user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

 
       {:ok, _reply_activity} =
         CommonAPI.post(other_user, %{
 
       {:ok, _reply_activity} =
         CommonAPI.post(other_user, %{

-          "status" => "test reply",
-          "in_reply_to_status_id" => activity.id
+          status: "test reply",
+          in_reply_to_status_id: activity.id

         })
 
       user_notifications = Notification.for_user(user)
         })
 
       user_notifications = Notification.for_user(user)


@@ -80,18 +89,96 @@ defmodule Pleroma.NotificationTest do
     end
   end
 
     end
   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 = insert(:user)
   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 = insert(:user)

-      task = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
-      task_user_notification = Task.async(fn -> assert_receive {:text, _}, 4_000 end)
-      Streamer.add_socket("user", %{transport_pid: task.pid, assigns: %{user: user}})

 
 

-      Streamer.add_socket(
-        "user:notification",
-        %{transport_pid: task_user_notification.pid, assigns: %{user: user}}
-      )
+      task =
+        Task.async(fn ->
+          Streamer.get_topic_and_add_socket("user", user)
+          assert_receive {:render_with_user, _, _, _}, 4_000
+        end)
+
+      task_user_notification =
+        Task.async(fn ->
+          Streamer.get_topic_and_add_socket("user:notification", user)
+          assert_receive {:render_with_user, _, _, _}, 4_000
+        end)

 
       activity = insert(:note_activity)
 
 
       activity = insert(:note_activity)
 


@@ -115,7 +202,7 @@ defmodule Pleroma.NotificationTest do
       muted = insert(:user)
       {:ok, _} = User.mute(muter, muted)
       muter = Repo.get(User, muter.id)
       muted = insert(:user)
       {:ok, _} = User.mute(muter, muted)
       muter = Repo.get(User, muter.id)

-      {:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})
+      {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})

 
       assert Notification.create_notification(activity, muter)
     end
 
       assert Notification.create_notification(activity, muter)
     end


@@ -126,7 +213,7 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, _user_relationships} = User.mute(muter, muted, false)
 
 
       {:ok, _user_relationships} = User.mute(muter, muted, false)
 

-      {:ok, activity} = CommonAPI.post(muted, %{"status" => "Hi @#{muter.nickname}"})
+      {:ok, activity} = CommonAPI.post(muted, %{status: "Hi @#{muter.nickname}"})

 
       assert Notification.create_notification(activity, muter)
     end
 
       assert Notification.create_notification(activity, muter)
     end


@@ -134,13 +221,13 @@ defmodule Pleroma.NotificationTest do
     test "it creates a notification for an activity from a muted thread" do
       muter = insert(:user)
       other_user = insert(:user)
     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"})
+      {:ok, activity} = CommonAPI.post(muter, %{status: "hey"})

       CommonAPI.add_mute(muter, activity)
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{
       CommonAPI.add_mute(muter, activity)
 
       {:ok, activity} =
         CommonAPI.post(other_user, %{

-          "status" => "Hi @#{muter.nickname}",
-          "in_reply_to_status_id" => activity.id
+          status: "Hi @#{muter.nickname}",
+          in_reply_to_status_id: activity.id

         })
 
       assert Notification.create_notification(activity, muter)
         })
 
       assert Notification.create_notification(activity, muter)


@@ -153,7 +240,7 @@ defmodule Pleroma.NotificationTest do
         insert(:user, notification_settings: %Pleroma.User.NotificationSetting{followers: false})
 
       User.follow(follower, followed)
         insert(:user, notification_settings: %Pleroma.User.NotificationSetting{followers: false})
 
       User.follow(follower, followed)

-      {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
+      {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})

       refute Notification.create_notification(activity, followed)
     end
 
       refute Notification.create_notification(activity, followed)
     end
 


@@ -165,7 +252,7 @@ defmodule Pleroma.NotificationTest do
           notification_settings: %Pleroma.User.NotificationSetting{non_followers: false}
         )
 
           notification_settings: %Pleroma.User.NotificationSetting{non_followers: false}
         )
 

-      {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
+      {:ok, activity} = CommonAPI.post(follower, %{status: "hey @#{followed.nickname}"})

       refute Notification.create_notification(activity, followed)
     end
 
       refute Notification.create_notification(activity, followed)
     end
 


@@ -176,7 +263,7 @@ defmodule Pleroma.NotificationTest do
       followed = insert(:user)
       User.follow(follower, followed)
       follower = Repo.get(User, follower.id)
       followed = insert(:user)
       User.follow(follower, followed)
       follower = Repo.get(User, follower.id)

-      {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
+      {:ok, activity} = CommonAPI.post(followed, %{status: "hey @#{follower.nickname}"})

       refute Notification.create_notification(activity, follower)
     end
 
       refute Notification.create_notification(activity, follower)
     end
 


@@ -185,7 +272,7 @@ defmodule Pleroma.NotificationTest do
         insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false})
 
       followed = insert(:user)
         insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false})
 
       followed = insert(:user)

-      {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
+      {:ok, activity} = CommonAPI.post(followed, %{status: "hey @#{follower.nickname}"})

       refute Notification.create_notification(activity, follower)
     end
 
       refute Notification.create_notification(activity, follower)
     end
 


@@ -196,23 +283,13 @@ defmodule Pleroma.NotificationTest do
       refute Notification.create_notification(activity, author)
     end
 
       refute Notification.create_notification(activity, author)
     end
 

-    test "it doesn't create a notification for follow-unfollow-follow chains" do
-      user = insert(:user)
-      followed_user = insert(:user)
-      {:ok, _, _, activity} = CommonAPI.follow(user, followed_user)
-      Notification.create_notification(activity, followed_user)
-      CommonAPI.unfollow(user, followed_user)
-      {:ok, _, _, activity_dupe} = CommonAPI.follow(user, followed_user)
-      refute Notification.create_notification(activity_dupe, followed_user)
-    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)
     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, status} = CommonAPI.post(user, %{status: "Akariiiin"})

       {:ok, [_notif]} = Notification.create_notifications(status)
     end
 
       {:ok, [_notif]} = Notification.create_notifications(status)
     end
 


@@ -222,18 +299,78 @@ defmodule Pleroma.NotificationTest do
 
       User.subscribe(subscriber, user)
 
 
       User.subscribe(subscriber, user)
 

-      {:ok, status} = CommonAPI.post(user, %{"status" => "inwisible", "visibility" => "direct"})
+      {:ok, status} = CommonAPI.post(user, %{status: "inwisible", visibility: "direct"})

 
       assert {:ok, []} == Notification.create_notifications(status)
     end
   end
 
 
       assert {:ok, []} == Notification.create_notifications(status)
     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, 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, 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_id = notification.id
+      assert [%{id: ^notification_id}] = Notification.for_user(followed_user)
+      assert %{type: "follow"} = NotificationView.render("show.json", render_opts)
+    end
+
+    test "it doesn't create a notification for follow-unfollow-follow chains" do
+      user = insert(:user)
+      followed_user = insert(:user, 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, 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)
 
   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, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:ok, notification} = Notification.get(other_user, notification.id)
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:ok, notification} = Notification.get(other_user, notification.id)


@@ -245,7 +382,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:error, _notification} = Notification.get(user, notification.id)
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:error, _notification} = Notification.get(user, notification.id)


@@ -257,7 +394,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:ok, notification} = Notification.dismiss(other_user, notification.id)
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:ok, notification} = Notification.dismiss(other_user, notification.id)


@@ -269,7 +406,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "hey @#{other_user.nickname}"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{other_user.nickname}"})

 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:error, _notification} = Notification.dismiss(user, notification.id)
 
       {:ok, [notification]} = Notification.create_notifications(activity)
       {:error, _notification} = Notification.dismiss(user, notification.id)


@@ -284,14 +421,14 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, activity} =
         CommonAPI.post(user, %{
 
       {:ok, activity} =
         CommonAPI.post(user, %{

-          "status" => "hey @#{other_user.nickname} and @#{third_user.nickname} !"
+          status: "hey @#{other_user.nickname} and @#{third_user.nickname} !"

         })
 
       {:ok, _notifs} = Notification.create_notifications(activity)
 
       {:ok, activity} =
         CommonAPI.post(user, %{
         })
 
       {:ok, _notifs} = Notification.create_notifications(activity)
 
       {:ok, activity} =
         CommonAPI.post(user, %{

-          "status" => "hey again @#{other_user.nickname} and @#{third_user.nickname} !"
+          status: "hey again @#{other_user.nickname} and @#{third_user.nickname} !"

         })
 
       {:ok, _notifs} = Notification.create_notifications(activity)
         })
 
       {:ok, _notifs} = Notification.create_notifications(activity)


@@ -309,12 +446,12 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
 
       {:ok, _activity} =
         CommonAPI.post(user, %{

-          "status" => "hey @#{other_user.nickname}!"
+          status: "hey @#{other_user.nickname}!"

         })
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
         })
 
       {:ok, _activity} =
         CommonAPI.post(user, %{

-          "status" => "hey again @#{other_user.nickname}!"
+          status: "hey again @#{other_user.nickname}!"

         })
 
       [n2, n1] = notifs = Notification.for_user(other_user)
         })
 
       [n2, n1] = notifs = Notification.for_user(other_user)


@@ -324,7 +461,7 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, _activity} =
         CommonAPI.post(user, %{
 
       {:ok, _activity} =
         CommonAPI.post(user, %{

-          "status" => "hey yet again @#{other_user.nickname}!"
+          status: "hey yet again @#{other_user.nickname}!"

         })
 
       Notification.set_read_up_to(other_user, n2.id)
         })
 
       Notification.set_read_up_to(other_user, n2.id)


@@ -334,6 +471,16 @@ defmodule Pleroma.NotificationTest do
       assert n1.seen == true
       assert n2.seen == true
       assert n3.seen == false
       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
 
     end
   end
 


@@ -353,7 +500,7 @@ defmodule Pleroma.NotificationTest do
       Enum.each(0..10, fn i ->
         {:ok, _activity} =
           CommonAPI.post(user1, %{
       Enum.each(0..10, fn i ->
         {:ok, _activity} =
           CommonAPI.post(user1, %{

-            "status" => "hey ##{i} @#{user2.nickname}!"
+            status: "hey ##{i} @#{user2.nickname}!"

           })
       end)
 
           })
       end)
 


@@ -382,17 +529,19 @@ defmodule Pleroma.NotificationTest do
     end
   end
 
     end
   end
 

-  describe "notification target determination" do
+  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, %{
     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}!"
+          status: "hey @#{other_user.nickname}!"

         })
 
         })
 

-      assert other_user in Notification.get_notified_from_activity(activity)
+      {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
     end
 
     test "it sends notifications to mentioned users in new messages" do


@@ -420,7 +569,9 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
 
 
       {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
 

-      assert other_user in Notification.get_notified_from_activity(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
     end
 
     test "it does not send notifications to users who are only cc in new messages" do


@@ -442,7 +593,9 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
 
 
       {:ok, activity} = Transmogrifier.handle_incoming(create_activity)
 

-      assert other_user not in Notification.get_notified_from_activity(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
     end
 
     test "it does not send notification to mentioned users in likes" do


@@ -452,12 +605,37 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, activity_one} =
         CommonAPI.post(user, %{
 
       {:ok, activity_one} =
         CommonAPI.post(user, %{

-          "status" => "hey @#{other_user.nickname}!"
+          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, activity_two, _} = CommonAPI.favorite(activity_one.id, third_user)
+      {: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 Notification.get_notified_from_activity(activity_two)
+      assert other_user not in enabled_receivers

     end
 
     test "it does not send notification to mentioned users in announces" do
     end
 
     test "it does not send notification to mentioned users in announces" do


@@ -467,12 +645,93 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, activity_one} =
         CommonAPI.post(user, %{
 
       {:ok, activity_one} =
         CommonAPI.post(user, %{

-          "status" => "hey @#{other_user.nickname}!"
+          status: "hey @#{other_user.nickname}!"

         })
 
       {:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)
 
         })
 
       {:ok, activity_two, _} = CommonAPI.repeat(activity_one.id, third_user)
 

-      assert other_user not in Notification.get_notified_from_activity(activity_two)
+      {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.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
   end
 
     end
   end
 


@@ -481,11 +740,11 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

 
       assert Enum.empty?(Notification.for_user(user))
 
 
       assert Enum.empty?(Notification.for_user(user))
 

-      {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
+      {:ok, _} = CommonAPI.favorite(other_user, activity.id)

 
       assert length(Notification.for_user(user)) == 1
 
 
       assert length(Notification.for_user(user)) == 1
 


@@ -498,15 +757,15 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

 
       assert Enum.empty?(Notification.for_user(user))
 
 
       assert Enum.empty?(Notification.for_user(user))
 

-      {:ok, _, _} = CommonAPI.favorite(activity.id, other_user)
+      {:ok, _} = CommonAPI.favorite(other_user, activity.id)

 
       assert length(Notification.for_user(user)) == 1
 
 
       assert length(Notification.for_user(user)) == 1
 

-      {:ok, _, _, _} = CommonAPI.unfavorite(activity.id, other_user)
+      {:ok, _} = CommonAPI.unfavorite(activity.id, other_user)

 
       assert Enum.empty?(Notification.for_user(user))
     end
 
       assert Enum.empty?(Notification.for_user(user))
     end


@@ -515,7 +774,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

 
       assert Enum.empty?(Notification.for_user(user))
 
 
       assert Enum.empty?(Notification.for_user(user))
 


@@ -532,7 +791,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

 
       assert Enum.empty?(Notification.for_user(user))
 
 
       assert Enum.empty?(Notification.for_user(user))
 


@@ -540,7 +799,7 @@ defmodule Pleroma.NotificationTest do
 
       assert length(Notification.for_user(user)) == 1
 
 
       assert length(Notification.for_user(user)) == 1
 

-      {:ok, _, _} = CommonAPI.unrepeat(activity.id, other_user)
+      {:ok, _} = CommonAPI.unrepeat(activity.id, other_user)

 
       assert Enum.empty?(Notification.for_user(user))
     end
 
       assert Enum.empty?(Notification.for_user(user))
     end


@@ -549,7 +808,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

 
       assert Enum.empty?(Notification.for_user(user))
 
 
       assert Enum.empty?(Notification.for_user(user))
 


@@ -557,7 +816,7 @@ defmodule Pleroma.NotificationTest do
 
       assert Enum.empty?(Notification.for_user(user))
 
 
       assert Enum.empty?(Notification.for_user(user))
 

-      {:error, _} = CommonAPI.favorite(activity.id, other_user)
+      {:error, :not_found} = CommonAPI.favorite(other_user, activity.id)

 
       assert Enum.empty?(Notification.for_user(user))
     end
 
       assert Enum.empty?(Notification.for_user(user))
     end


@@ -566,7 +825,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

 
       assert Enum.empty?(Notification.for_user(user))
 
 
       assert Enum.empty?(Notification.for_user(user))
 


@@ -583,13 +842,13 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       other_user = insert(:user)
 
       user = insert(:user)
       other_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
+      {:ok, activity} = CommonAPI.post(user, %{status: "test post"})

       {:ok, _deletion_activity} = CommonAPI.delete(activity.id, user)
 
       {:ok, _reply_activity} =
         CommonAPI.post(other_user, %{
       {: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
+          status: "test reply",
+          in_reply_to_status_id: activity.id

         })
 
       assert Enum.empty?(Notification.for_user(user))
         })
 
       assert Enum.empty?(Notification.for_user(user))


@@ -600,7 +859,7 @@ defmodule Pleroma.NotificationTest do
       other_user = insert(:user)
 
       {:ok, _activity} =
       other_user = insert(:user)
 
       {:ok, _activity} =

-        CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}", "visibility" => "direct"})
+        CommonAPI.post(user, %{status: "hi @#{other_user.nickname}", visibility: "direct"})

 
       refute Enum.empty?(Notification.for_user(other_user))
 
 
       refute Enum.empty?(Notification.for_user(other_user))
 


@@ -649,12 +908,20 @@ defmodule Pleroma.NotificationTest do
         "object" => remote_user.ap_id
       }
 
         "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
 
       {:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)
       ObanHelpers.perform_all()
 
       assert Enum.empty?(Notification.for_user(local_user))
     end
 

+    @tag capture_log: true

     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])
     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])


@@ -664,6 +931,18 @@ defmodule Pleroma.NotificationTest do
       User.follow(follower, old_user)
       User.follow(other_follower, old_user)
 
       User.follow(follower, old_user)
       User.follow(other_follower, old_user)
 

+      old_user_url = old_user.ap_id
+
+      body =
+        File.read!("test/fixtures/users_mock/localhost.json")
+        |> String.replace("{{nickname}}", old_user.nickname)
+        |> Jason.encode!()
+
+      Tesla.Mock.mock(fn
+        %{method: :get, url: ^old_user_url} ->
+          %Tesla.Env{status: 200, body: body}
+      end)
+

       Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
       ObanHelpers.perform_all()
 
       Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
       ObanHelpers.perform_all()
 


@@ -691,7 +970,7 @@ defmodule Pleroma.NotificationTest do
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted, false)
 
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted, false)
 

-      {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

 
       assert length(Notification.for_user(user)) == 1
     end
 
       assert length(Notification.for_user(user)) == 1
     end


@@ -701,7 +980,7 @@ defmodule Pleroma.NotificationTest do
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted)
 
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted)
 

-      {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

 
       assert Notification.for_user(user) == []
     end
 
       assert Notification.for_user(user) == []
     end


@@ -711,26 +990,38 @@ defmodule Pleroma.NotificationTest do
       blocked = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked)
 
       blocked = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked)
 

-      {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

 
       assert Notification.for_user(user) == []
     end
 
 
       assert Notification.for_user(user) == []
     end
 

-    test "it doesn't return notificatitons for blocked domain" do
+    test "it doesn't return notifications for domain-blocked non-followed user" do

       user = insert(:user)
       blocked = insert(:user, ap_id: "http://some-domain.com")
       {:ok, user} = User.block_domain(user, "some-domain.com")
 
       user = insert(:user)
       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}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

 
       assert Notification.for_user(user) == []
     end
 
 
       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" do
       user = insert(:user)
       another_user = insert(:user)
 
     test "it doesn't return notifications for muted thread" do
       user = insert(:user)
       another_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"})
+      {: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) == []
 
       {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
       assert Notification.for_user(user) == []


@@ -741,7 +1032,7 @@ defmodule Pleroma.NotificationTest do
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted)
 
       muted = insert(:user)
       {:ok, _user_relationships} = User.mute(user, muted)
 

-      {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(muted, %{status: "hey @#{user.nickname}"})

 
       assert length(Notification.for_user(user, %{with_muted: true})) == 1
     end
 
       assert length(Notification.for_user(user, %{with_muted: true})) == 1
     end


@@ -751,17 +1042,18 @@ defmodule Pleroma.NotificationTest do
       blocked = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked)
 
       blocked = insert(:user)
       {:ok, _user_relationship} = User.block(user, blocked)
 

-      {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

 
       assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
     end
 
 
       assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
     end
 

-    test "it doesn't return notifications from a domain-blocked user when with_muted is set" do
+    test "when with_muted is set, " <>
+           "it doesn't return notifications from a domain-blocked non-followed user" do

       user = insert(:user)
       blocked = insert(:user, ap_id: "http://some-domain.com")
       {:ok, user} = User.block_domain(user, "some-domain.com")
 
       user = insert(:user)
       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}"})
+      {:ok, _activity} = CommonAPI.post(blocked, %{status: "hey @#{user.nickname}"})

 
       assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
     end
 
       assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))
     end


@@ -770,7 +1062,7 @@ defmodule Pleroma.NotificationTest do
       user = insert(:user)
       another_user = insert(:user)
 
       user = insert(:user)
       another_user = insert(:user)
 

-      {:ok, activity} = CommonAPI.post(another_user, %{"status" => "hey @#{user.nickname}"})
+      {: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
 
       {:ok, _} = Pleroma.ThreadMute.add_mute(user.id, activity.data["context"])
       assert length(Notification.for_user(user, %{with_muted: true})) == 1