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-2020 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)
  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   @tag capture_log: true
 148   test "Move notification" do
 149     old_user = insert(:user)
 150     new_user = insert(:user, also_known_as: [old_user.ap_id])
 151     follower = insert(:user)
 152
 153     old_user_url = old_user.ap_id
 154
 155     body =
 156       File.read!("test/fixtures/users_mock/localhost.json")
 157       |> String.replace("{{nickname}}", old_user.nickname)
 158       |> Jason.encode!()
 159
 160     Tesla.Mock.mock(fn
 161       %{method: :get, url: ^old_user_url} ->
 162         %Tesla.Env{status: 200, body: body}
 163     end)
 164
 165     User.follow(follower, old_user)
 166     Pleroma.Web.ActivityPub.ActivityPub.move(old_user, new_user)
 167     Pleroma.Tests.ObanHelpers.perform_all()
 168
 169     old_user = refresh_record(old_user)
 170     new_user = refresh_record(new_user)
 171
 172     [notification] = Notification.for_user(follower)
 173
 174     expected = %{
 175       id: to_string(notification.id),
 176       pleroma: %{is_seen: false, is_muted: false},
 177       type: "move",
 178       account: AccountView.render("show.json", %{user: old_user, for: follower}),
 179       target: AccountView.render("show.json", %{user: new_user, for: follower}),
 180       created_at: Utils.to_masto_date(notification.inserted_at)
 181     }
 182
 183     test_notifications_rendering([notification], follower, [expected])
 184   end
 185
 186   test "EmojiReact notification" do
 187     user = insert(:user)
 188     other_user = insert(:user)
 189
 190     {:ok, activity} = CommonAPI.post(user, %{status: "#cofe"})
 191     {:ok, _activity} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")
 192
 193     activity = Repo.get(Activity, activity.id)
 194
 195     [notification] = Notification.for_user(user)
 196
 197     assert notification
 198
 199     expected = %{
 200       id: to_string(notification.id),
 201       pleroma: %{is_seen: false, is_muted: false},
 202       type: "pleroma:emoji_reaction",
 203       emoji: "☕",
 204       account: AccountView.render("show.json", %{user: other_user, for: user}),
 205       status: StatusView.render("show.json", %{activity: activity, for: user}),
 206       created_at: Utils.to_masto_date(notification.inserted_at)
 207     }
 208
 209     test_notifications_rendering([notification], user, [expected])
 210   end
 211
 212   test "Report notification" do
 213     reporting_user = insert(:user)
 214     reported_user = insert(:user)
 215     {:ok, moderator_user} = insert(:user) |> User.admin_api_update(%{is_moderator: true})
 216
 217     {:ok, activity} = CommonAPI.report(reporting_user, %{account_id: reported_user.id})
 218     {:ok, [notification]} = Notification.create_notifications(activity)
 219
 220     expected = %{
 221       id: to_string(notification.id),
 222       pleroma: %{is_seen: false, is_muted: false},
 223       type: "pleroma:report",
 224       account: AccountView.render("show.json", %{user: reporting_user, for: moderator_user}),
 225       created_at: Utils.to_masto_date(notification.inserted_at),
 226       report: ReportView.render("show.json", Report.extract_report_info(activity))
 227     }
 228
 229     test_notifications_rendering([notification], moderator_user, [expected])
 230   end
 231
 232   test "muted notification" do
 233     user = insert(:user)
 234     another_user = insert(:user)
 235
 236     {:ok, _} = Pleroma.UserRelationship.create_mute(user, another_user)
 237     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 238     {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
 239     {:ok, [notification]} = Notification.create_notifications(favorite_activity)
 240     create_activity = Activity.get_by_id(create_activity.id)
 241
 242     expected = %{
 243       id: to_string(notification.id),
 244       pleroma: %{is_seen: true, is_muted: true},
 245       type: "favourite",
 246       account: AccountView.render("show.json", %{user: another_user, for: user}),
 247       status: StatusView.render("show.json", %{activity: create_activity, for: user}),
 248       created_at: Utils.to_masto_date(notification.inserted_at)
 249     }
 250
 251     test_notifications_rendering([notification], user, [expected])
 252   end
 253 end