Merge branch 'develop' into issue/1276

[akkoma] / test / notification_test.exs

diff --git a/test/notification_test.exs b/test/notification_test.exs
index d68d4485fa21cb883df0b396d874b95773ea08c4..c3d70c51febd92ef719e066f004d4ca3a016f4dc 100644 (file)
--- a/test/notification_test.exs
+++ b/test/notification_test.exs
@@ -1,19 +1,34 @@
 # Pleroma: A lightweight social networking server
 # Pleroma: A lightweight social networking server

-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>

 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.NotificationTest do
   use Pleroma.DataCase
 
   import Pleroma.Factory
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Pleroma.NotificationTest do
   use Pleroma.DataCase
 
   import Pleroma.Factory

+  import Mock

 
   alias Pleroma.Notification
 
   alias Pleroma.Notification

+  alias Pleroma.Tests.ObanHelpers

   alias Pleroma.User
   alias Pleroma.Web.ActivityPub.Transmogrifier
   alias Pleroma.Web.CommonAPI
   alias Pleroma.User
   alias Pleroma.Web.ActivityPub.Transmogrifier
   alias Pleroma.Web.CommonAPI

+  alias Pleroma.Web.Push

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

+    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, _object} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
+
+      {:ok, [notification]} = Notification.create_notifications(activity)
+
+      assert notification.user_id == user.id
+    end
+

     test "notifies someone when they are directly addressed" do
       user = insert(:user)
       other_user = insert(:user)
     test "notifies someone when they are directly addressed" do
       user = insert(:user)
       other_user = insert(:user)


@@ -30,6 +45,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


@@ -67,6 +85,80 @@ 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
   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


@@ -92,12 +184,12 @@ defmodule Pleroma.NotificationTest do
       activity = insert(:note_activity)
       author = User.get_cached_by_ap_id(activity.data["actor"])
       user = insert(:user)
       activity = insert(:note_activity)
       author = User.get_cached_by_ap_id(activity.data["actor"])
       user = insert(:user)

-      {:ok, user} = User.block(user, author)
+      {:ok, _user_relationship} = User.block(user, author)

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

-    test "it creates a notificatin for the user if the user mutes the activity author" do
+    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 = insert(:user)
       muted = insert(:user)
       {:ok, _} = User.mute(muter, muted)


@@ -111,7 +203,7 @@ defmodule Pleroma.NotificationTest do
       muter = insert(:user)
       muted = insert(:user)
 
       muter = insert(:user)
       muted = insert(:user)
 

-      {:ok, muter} = 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}"})
 


@@ -135,7 +227,10 @@ defmodule Pleroma.NotificationTest do
 
     test "it disables notifications from followers" do
       follower = insert(:user)
 
     test "it disables notifications from followers" do
       follower = insert(:user)

-      followed = insert(:user, info: %{notification_settings: %{"followers" => false}})
+
+      followed =
+        insert(:user, notification_settings: %Pleroma.User.NotificationSetting{followers: false})
+

       User.follow(follower, followed)
       {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
       refute Notification.create_notification(activity, followed)
       User.follow(follower, followed)
       {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
       refute Notification.create_notification(activity, followed)


@@ -143,13 +238,20 @@ defmodule Pleroma.NotificationTest do
 
     test "it disables notifications from non-followers" do
       follower = insert(:user)
 
     test "it disables notifications from non-followers" do
       follower = insert(:user)

-      followed = insert(:user, info: %{notification_settings: %{"non_followers" => false}})
+
+      followed =
+        insert(:user,
+          notification_settings: %Pleroma.User.NotificationSetting{non_followers: false}
+        )
+

       {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
       refute Notification.create_notification(activity, followed)
     end
 
     test "it disables notifications from people the user follows" do
       {:ok, activity} = CommonAPI.post(follower, %{"status" => "hey @#{followed.nickname}"})
       refute Notification.create_notification(activity, followed)
     end
 
     test "it disables notifications from people the user follows" do

-      follower = insert(:user, info: %{notification_settings: %{"follows" => false}})
+      follower =
+        insert(:user, notification_settings: %Pleroma.User.NotificationSetting{follows: false})
+

       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)


@@ -158,7 +260,9 @@ defmodule Pleroma.NotificationTest do
     end
 
     test "it disables notifications from people the user does not follow" do
     end
 
     test "it disables notifications from people the user does not follow" do

-      follower = insert(:user, info: %{notification_settings: %{"non_follows" => false}})
+      follower =
+        insert(:user, notification_settings: %Pleroma.User.NotificationSetting{non_follows: false})
+

       followed = insert(:user)
       {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
       refute Notification.create_notification(activity, follower)
       followed = insert(:user)
       {:ok, activity} = CommonAPI.post(followed, %{"status" => "hey @#{follower.nickname}"})
       refute Notification.create_notification(activity, follower)


@@ -309,6 +413,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
 


@@ -357,7 +471,7 @@ 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)
     test "it sends notifications to addressed users in new messages" do
       user = insert(:user)
       other_user = insert(:user)


@@ -367,7 +481,9 @@ defmodule Pleroma.NotificationTest do
           "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


@@ -395,7 +511,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


@@ -417,7 +535,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


@@ -432,7 +552,10 @@ defmodule Pleroma.NotificationTest do
 
       {:ok, activity_two, _} = CommonAPI.favorite(activity_one.id, third_user)
 
 
       {:ok, activity_two, _} = CommonAPI.favorite(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 does not send notification to mentioned users in announces" do
     end
 
     test "it does not send notification to mentioned users in announces" do


@@ -447,7 +570,57 @@ defmodule Pleroma.NotificationTest do
 
       {: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
   end
 
     end
   end
 


@@ -579,7 +752,8 @@ defmodule Pleroma.NotificationTest do
 
       refute Enum.empty?(Notification.for_user(other_user))
 
 
       refute Enum.empty?(Notification.for_user(other_user))
 

-      User.delete(user)
+      {:ok, job} = User.delete(user)
+      ObanHelpers.perform(job)

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


@@ -623,17 +797,67 @@ 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)
       {:ok, _delete_activity} = Transmogrifier.handle_incoming(delete_user_message)

+      ObanHelpers.perform_all()

 
       assert Enum.empty?(Notification.for_user(local_user))
     end
 
       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])
+      follower = insert(:user)
+      other_follower = insert(:user, %{allow_following_move: false})
+
+      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()
+
+      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
     test "it returns notifications for muted user without notifications" do
       user = insert(:user)
       muted = insert(:user)
   end
 
   describe "for_user" do
     test "it returns notifications for muted user without notifications" do
       user = insert(:user)
       muted = insert(:user)

-      {:ok, user} = User.mute(user, muted, false)
+      {: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}"})
 


@@ -643,7 +867,7 @@ defmodule Pleroma.NotificationTest do
     test "it doesn't return notifications for muted user with notifications" do
       user = insert(:user)
       muted = insert(:user)
     test "it doesn't return notifications for muted user with notifications" do
       user = insert(:user)
       muted = insert(:user)

-      {:ok, user} = User.mute(user, muted)
+      {: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}"})
 


@@ -653,14 +877,14 @@ defmodule Pleroma.NotificationTest do
     test "it doesn't return notifications for blocked user" do
       user = insert(:user)
       blocked = insert(:user)
     test "it doesn't return notifications for blocked user" do
       user = insert(:user)
       blocked = insert(:user)

-      {:ok, user} = User.block(user, blocked)
+      {:ok, _user_relationship} = User.block(user, blocked)

 
       {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
 
       assert Notification.for_user(user) == []
     end
 
 
       {:ok, _activity} = CommonAPI.post(blocked, %{"status" => "hey @#{user.nickname}"})
 
       assert Notification.for_user(user) == []
     end
 

-    test "it doesn't return notificatitons for blocked domain" do
+    test "it doesn't return notifications for blocked domain" 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")


@@ -680,37 +904,37 @@ defmodule Pleroma.NotificationTest do
       assert Notification.for_user(user) == []
     end
 
       assert Notification.for_user(user) == []
     end
 

-    test "it returns notifications for muted user with notifications and with_muted parameter" do
+    test "it returns notifications from a muted user when with_muted is set" do

       user = insert(:user)
       muted = insert(:user)
       user = insert(:user)
       muted = insert(:user)

-      {:ok, user} = User.mute(user, muted)
+      {: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
 
 
       {:ok, _activity} = CommonAPI.post(muted, %{"status" => "hey @#{user.nickname}"})
 
       assert length(Notification.for_user(user, %{with_muted: true})) == 1
     end
 

-    test "it returns notifications for blocked user and with_muted parameter" do
+    test "it doesn't return notifications from a blocked user when with_muted is set" do

       user = insert(:user)
       blocked = insert(:user)
       user = insert(:user)
       blocked = insert(:user)

-      {:ok, user} = User.block(user, blocked)
+      {: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 length(Notification.for_user(user, %{with_muted: true})) == 1
+      assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))

     end
 
     end
 

-    test "it returns notificatitons for blocked domain and with_muted parameter" do
+    test "it doesn't return notifications from a domain-blocked user when with_muted is set" do

       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}"})
 
       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}"})
 

-      assert length(Notification.for_user(user, %{with_muted: true})) == 1
+      assert Enum.empty?(Notification.for_user(user, %{with_muted: true}))

     end
 
     end
 

-    test "it returns notifications for muted thread with_muted parameter" do
+    test "it returns notifications from muted threads when with_muted is set" do

       user = insert(:user)
       another_user = insert(:user)
 
       user = insert(:user)
       another_user = insert(:user)