git.squeep.com Git - akkoma/blob - test/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.CommonAPI
  16   alias Pleroma.Web.CommonAPI.Utils
  17   alias Pleroma.Web.MastodonAPI.AccountView
  18   alias Pleroma.Web.MastodonAPI.NotificationView
  19   alias Pleroma.Web.MastodonAPI.StatusView
  20   alias Pleroma.Web.PleromaAPI.Chat.MessageReferenceView
  21   import Pleroma.Factory
  22
  23   defp test_notifications_rendering(notifications, user, expected_result) do
  24     result = NotificationView.render("index.json", %{notifications: notifications, for: user})
  25
  26     assert expected_result == result
  27
  28     result =
  29       NotificationView.render("index.json", %{
  30         notifications: notifications,
  31         for: user,
  32         relationships: nil
  33       })
  34
  35     assert expected_result == result
  36   end
  37
  38   test "ChatMessage notification" do
  39     user = insert(:user)
  40     recipient = insert(:user)
  41     {:ok, activity} = CommonAPI.post_chat_message(user, recipient, "what's up my dude")
  42
  43     {:ok, [notification]} = Notification.create_notifications(activity)
  44
  45     object = Object.normalize(activity)
  46     chat = Chat.get(recipient.id, user.ap_id)
  47
  48     cm_ref = MessageReference.for_chat_and_object(chat, object)
  49
  50     expected = %{
  51       id: to_string(notification.id),
  52       pleroma: %{is_seen: false},
  53       type: "pleroma:chat_mention",
  54       account: AccountView.render("show.json", %{user: user, for: recipient}),
  55       chat_message: MessageReferenceView.render("show.json", %{chat_message_reference: cm_ref}),
  56       created_at: Utils.to_masto_date(notification.inserted_at)
  57     }
  58
  59     test_notifications_rendering([notification], recipient, [expected])
  60   end
  61
  62   test "Mention notification" do
  63     user = insert(:user)
  64     mentioned_user = insert(:user)
  65     {:ok, activity} = CommonAPI.post(user, %{status: "hey @#{mentioned_user.nickname}"})
  66     {:ok, [notification]} = Notification.create_notifications(activity)
  67     user = User.get_cached_by_id(user.id)
  68
  69     expected = %{
  70       id: to_string(notification.id),
  71       pleroma: %{is_seen: false},
  72       type: "mention",
  73       account:
  74         AccountView.render("show.json", %{
  75           user: user,
  76           for: mentioned_user
  77         }),
  78       status: StatusView.render("show.json", %{activity: activity, for: mentioned_user}),
  79       created_at: Utils.to_masto_date(notification.inserted_at)
  80     }
  81
  82     test_notifications_rendering([notification], mentioned_user, [expected])
  83   end
  84
  85   test "Favourite notification" do
  86     user = insert(:user)
  87     another_user = insert(:user)
  88     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
  89     {:ok, favorite_activity} = CommonAPI.favorite(another_user, create_activity.id)
  90     {:ok, [notification]} = Notification.create_notifications(favorite_activity)
  91     create_activity = Activity.get_by_id(create_activity.id)
  92
  93     expected = %{
  94       id: to_string(notification.id),
  95       pleroma: %{is_seen: false},
  96       type: "favourite",
  97       account: AccountView.render("show.json", %{user: another_user, for: user}),
  98       status: StatusView.render("show.json", %{activity: create_activity, for: user}),
  99       created_at: Utils.to_masto_date(notification.inserted_at)
 100     }
 101
 102     test_notifications_rendering([notification], user, [expected])
 103   end
 104
 105   test "Reblog notification" do
 106     user = insert(:user)
 107     another_user = insert(:user)
 108     {:ok, create_activity} = CommonAPI.post(user, %{status: "hey"})
 109     {:ok, reblog_activity} = CommonAPI.repeat(create_activity.id, another_user)
 110     {:ok, [notification]} = Notification.create_notifications(reblog_activity)
 111     reblog_activity = Activity.get_by_id(create_activity.id)
 112
 113     expected = %{
 114       id: to_string(notification.id),
 115       pleroma: %{is_seen: false},
 116       type: "reblog",
 117       account: AccountView.render("show.json", %{user: another_user, for: user}),
 118       status: StatusView.render("show.json", %{activity: reblog_activity, for: user}),
 119       created_at: Utils.to_masto_date(notification.inserted_at)
 120     }
 121
 122     test_notifications_rendering([notification], user, [expected])
 123   end
 124
 125   test "Follow notification" do
 126     follower = insert(:user)
 127     followed = insert(:user)
 128     {:ok, follower, followed, _activity} = CommonAPI.follow(follower, followed)
 129     notification = Notification |> Repo.one() |> Repo.preload(:activity)
 130
 131     expected = %{
 132       id: to_string(notification.id),
 133       pleroma: %{is_seen: false},
 134       type: "follow",
 135       account: AccountView.render("show.json", %{user: follower, for: followed}),
 136       created_at: Utils.to_masto_date(notification.inserted_at)
 137     }
 138
 139     test_notifications_rendering([notification], followed, [expected])
 140
 141     User.perform(:delete, follower)
 142     notification = Notification |> Repo.one() |> Repo.preload(:activity)
 143
 144     test_notifications_rendering([notification], followed, [])
 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},
 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},
 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 end