git.squeep.com Git - akkoma/blob - test/pleroma/web/mastodon_api/views/notification_view_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.MastodonAPI.NotificationViewTest do
   6   use Pleroma.DataCase
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Chat
  10   alias Pleroma.Chat.MessageReference
  11   alias Pleroma.Notification
  12   alias Pleroma.Object
  13   alias Pleroma.Repo
  14   alias Pleroma.User
  15   alias Pleroma.Web.AdminAPI.Report
  16   alias Pleroma.Web.AdminAPI.ReportView
  17   alias Pleroma.Web.CommonAPI
  18   alias Pleroma.Web.CommonAPI.Utils
  19   alias Pleroma.Web.MastodonAPI.AccountView
  20   alias Pleroma.Web.MastodonAPI.NotificationView
  21   alias Pleroma.Web.MastodonAPI.StatusView
  22   alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
  23   import Pleroma.Factory
  24
  25   defp test_notifications_rendering(notifications, user, expected_result) do
  26     result = NotificationView.render("index.json", %{notifications: notifications, for: user})
  27
  28     assert expected_result == result
  29
  30     result =
  31       NotificationView.render("index.json", %{
  32         notifications: notifications,
  33         for: user,
  34         relationships: nil
  35       })
  36
  37     assert expected_result == result
  38   end
  39
  40   test "ChatMessage notification" do
  41     user = insert(:user)
  42     recipient = insert(:user)
  43     {:ok, activity} = CommonAPI.post_chat_message(user, recipient, "what's up my dude")
  44
  45     {:ok, [notification]} = Notification.create_notifications(activity)
  46
  47     object = Object.normalize(activity, fetch: false)
  48     chat = Chat.get(recipient.id, user.ap_id)
  49
  50     cm_ref = MessageReference.for_chat_and_object(chat, object)
  51
  52     expected = %{
  53       id: to_string(notification.id),
  54       pleroma: %{is_seen: false, is_muted: false},
  55       type: "pleroma:chat_mention",
  56       account: AccountView.render("show.json", %{user: user, for: recipient}),
  57       chat_message: MessageReferenceView.render("show.json", %{chat_message_reference: cm_ref}),
  58       created_at: Utils.to_masto_date(notification.inserted_at)
  59     }
  60
  61     test_notifications_rendering([notification], recipient, [expected])
  62   end
  63
  64   test "Mention notification" do
  65     user = insert(:user)
  66     mentioned_user = insert(:user)
  67     {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
  68     {:ok, [notification]} = Notification.create_notifications(activity)
  69     user = User.get_cached_by_id(user.id)
  70
  71     expected = %{
  72       id: to_string(notification.id),
  73       pleroma: %{is_seen: false, is_muted: false},
  74       type: "mention",
  75       account:
  76         AccountView.render("show.json", %{
  77           user: user,
  78           for: mentioned_user
  79         }),
  80       status: StatusView.render("show.json", %{activity: activity, for: mentioned_user}),
  81       created_at: Utils.to_masto_date(notification.inserted_at)
  82     }
  83
  84     test_notifications_rendering([notification], mentioned_user, [expected])
  85   end
  86
  87   test "Favourite notification" do
  88     user = insert(:user)
  89     another_user = insert(:user)
  90     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
  91     {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
  92     {:ok, [notification]} = Notification.create_notifications(favorite_activity)
  93     create_activity = Activity.get_by_id(create_activity.id)
  94
  95     expected = %{
  96       id: to_string(notification.id),
  97       pleroma: %{is_seen: false, is_muted: false},
  98       type: "favourite",
  99       account: AccountView.render("show.json", %{user: another_user, for: user}),
 100       status: StatusView.render("show.json", %{activity: create_activity, for: user}),
 101       created_at: Utils.to_masto_date(notification.inserted_at)
 102     }
 103
 104     test_notifications_rendering([notification], user, [expected])
 105   end
 106
 107   test "Reblog notification" do
 108     user = insert(:user)
 109     another_user = insert(:user)
 110     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 111     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, another_user)
 112     {:ok, [notification]} = Notification.create_notifications(reblog_activity)
 113     reblog_activity = Activity.get_by_id(create_activity.id)
 114
 115     expected = %{
 116       id: to_string(notification.id),
 117       pleroma: %{is_seen: false, is_muted: false},
 118       type: "reblog",
 119       account: AccountView.render("show.json", %{user: another_user, for: user}),
 120       status: StatusView.render("show.json", %{activity: reblog_activity, for: user}),
 121       created_at: Utils.to_masto_date(notification.inserted_at)
 122     }
 123
 124     test_notifications_rendering([notification], user, [expected])
 125   end
 126
 127   test "Follow notification" do
 128     follower = insert(:user)
 129     followed = insert(:user)
 130     {:ok, follower, followed, _activity} = CommonAPI.follow(follower, followed)
 131     notification = Notification |> Repo.one() |> Repo.preload(:activity)
 132
 133     expected = %{
 134       id: to_string(notification.id),
 135       pleroma: %{is_seen: false, is_muted: false},
 136       type: "follow",
 137       account: AccountView.render("show.json", %{user: follower, for: followed}),
 138       created_at: Utils.to_masto_date(notification.inserted_at)
 139     }
 140
 141     test_notifications_rendering([notification], followed, [expected])
 142
 143     User.perform(:delete, follower)
 144     refute Repo.one(Notification)
 145   end
 146
 147   test "Move notification" do
 148     old_user = insert(:user)
 149     new_user = insert(:user, also_known_as: [old_user.ap_id])
 150     follower = insert(:user)
 151
 152     User.follow(follower, old_user)
 153     Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
 154     Pleroma.Tests.ObanHelpers.perform_all()
 155
 156     old_user = refresh_record(old_user)
 157     new_user = refresh_record(new_user)
 158
 159     [notification] = Notification.for_user(follower)
 160
 161     expected = %{
 162       id: to_string(notification.id),
 163       pleroma: %{is_seen: false, is_muted: false},
 164       type: "move",
 165       account: AccountView.render("show.json", %{user: old_user, for: follower}),
 166       target: AccountView.render("show.json", %{user: new_user, for: follower}),
 167       created_at: Utils.to_masto_date(notification.inserted_at)
 168     }
 169
 170     test_notifications_rendering([notification], follower, [expected])
 171   end
 172
 173   test "EmojiReact notification" do
 174     user = insert(:user)
 175     other_user = insert(:user)
 176
 177     {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
 178     {:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
 179
 180     activity = Repo.get(Activity, activity.id)
 181
 182     [notification] = Notification.for_user(user)
 183
 184     assert notification
 185
 186     expected = %{
 187       id: to_string(notification.id),
 188       pleroma: %{is_seen: false, is_muted: false},
 189       type: "pleroma:emoji_reaction",
 190       emoji: "☕",
 191       account: AccountView.render("show.json", %{user: other_user, for: user}),
 192       status: StatusView.render("show.json", %{activity: activity, for: user}),
 193       created_at: Utils.to_masto_date(notification.inserted_at)
 194     }
 195
 196     test_notifications_rendering([notification], user, [expected])
 197   end
 198
 199   test "Report notification" do
 200     reporting_user = insert(:user)
 201     reported_user = insert(:user)
 202     {:ok, moderator_user} = insert(:user) |> User.admin_api_update(%{is_moderator: true})
 203
 204     {:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
 205     {:ok, [notification]} = Notification.create_notifications(activity)
 206
 207     expected = %{
 208       id: to_string(notification.id),
 209       pleroma: %{is_seen: false, is_muted: false},
 210       type: "pleroma:report",
 211       account: AccountView.render("show.json", %{user: reporting_user, for: moderator_user}),
 212       created_at: Utils.to_masto_date(notification.inserted_at),
 213       report: ReportView.render("show.json", Report.extract_report_info(activity))
 214     }
 215
 216     test_notifications_rendering([notification], moderator_user, [expected])
 217   end
 218
 219   test "muted notification" do
 220     user = insert(:user)
 221     another_user = insert(:user)
 222
 223     {:ok, _} = Pleroma.UserRelationship.create_mute(user, another_user)
 224     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 225     {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
 226     {:ok, [notification]} = Notification.create_notifications(favorite_activity)
 227     create_activity = Activity.get_by_id(create_activity.id)
 228
 229     expected = %{
 230       id: to_string(notification.id),
 231       pleroma: %{is_seen: true, is_muted: true},
 232       type: "favourite",
 233       account: AccountView.render("show.json", %{user: another_user, for: user}),
 234       status: StatusView.render("show.json", %{activity: create_activity, for: user}),
 235       created_at: Utils.to_masto_date(notification.inserted_at)
 236     }
 237
 238     test_notifications_rendering([notification], user, [expected])
 239   end
 240 end