changelog.d/familiar-followers.add

@@ -1 +0,0 @@
-Implement `/api/v1/accounts/familiar_followers`

changelog.d/mark-read.fix

@@ -1 +0,0 @@
-The query for marking notifications as read has been simplified

changelog.d/missing-mrfs.add

@@ -1 +0,0 @@
-Startup detection for configured MRF modules that are missing or incorrectly defined

changelog.d/status-notification-type.add

@@ -1 +0,0 @@
-Add "status" notification type

changelog.d/strip-object-actor.fix

@@ -0,0 +1 @@
+Strip actor property from objects before federating

lib/pleroma/application_requirements.ex

@@ -28,7 +28,6 @@ def verify! do
     |> check_welcome_message_config!()
     |> check_rum!()
     |> check_repo_pool_size!()
-    |> check_mrfs()
     |> handle_result()
   end
 
@@ -235,25 +234,4 @@ defp check_filter(filter, command_required) do
       true
     end
   end
-
-  defp check_mrfs(:ok) do
-    mrfs = Config.get!([:mrf, :policies])
-
-    missing_mrfs =
-      Enum.reduce(mrfs, [], fn x, acc ->
-        if Code.ensure_compiled(x) do
-          acc
-        else
-          acc ++ [x]
-        end
-      end)
-
-    if Enum.empty?(missing_mrfs) do
-      :ok
-    else
-      {:error, "The following MRF modules are configured but missing: #{inspect(missing_mrfs)}"}
-    end
-  end
-
-  defp check_mrfs(result), do: result
 end

lib/pleroma/constants.ex

@@ -9,6 +9,7 @@ defmodule Pleroma.Constants do
 
   const(object_internal_fields,
     do: [
+      "actor",
       "reactions",
       "reaction_count",
       "likes",

lib/pleroma/notification.ex

@@ -73,7 +73,6 @@ def unread_notifications_count(%User{id: user_id}) do
     pleroma:report
     reblog
     poll
-    status
   }
 
   def changeset(%Notification{} = notification, attrs) do
@@ -281,10 +280,15 @@ def set_read_up_to(%{id: user_id} = user, id) do
         select: n.id
       )
 
-    Multi.new()
+    {:ok, %{ids: {_, notification_ids}}} =
-    |> Multi.update_all(:ids, query, set: [seen: true, updated_at: NaiveDateTime.utc_now()])
+      Multi.new()
-    |> Marker.multi_set_last_read_id(user, "notifications")
+      |> Multi.update_all(:ids, query, set: [seen: true, updated_at: NaiveDateTime.utc_now()])
-    |> Repo.transaction()
+      |> Marker.multi_set_last_read_id(user, "notifications")
+      |> Repo.transaction()
+
+    for_user_query(user)
+    |> where([n], n.id in ^notification_ids)
+    |> Repo.all()
   end
 
   @spec read_one(User.t(), String.t()) ::
@@ -295,6 +299,10 @@ def read_one(%User{} = user, notification_id) do
       |> Multi.update(:update, changeset(notification, %{seen: true}))
       |> Marker.multi_set_last_read_id(user, "notifications")
       |> Repo.transaction()
+      |> case do
+        {:ok, %{update: notification}} -> {:ok, notification}
+        {:error, :update, changeset, _} -> {:error, changeset}
+      end
     end
   end
 
@@ -376,15 +384,10 @@ def create_notifications(_), do: {:ok, []}
   defp do_create_notifications(%Activity{} = activity) do
     enabled_receivers = get_notified_from_activity(activity)
 
-    enabled_subscribers = get_notified_subscribers_from_activity(activity)
-
     notifications =
-      (Enum.map(enabled_receivers, fn user ->
+      Enum.map(enabled_receivers, fn user ->
-         create_notification(activity, user)
+        create_notification(activity, user)
-       end) ++
+      end)
-         Enum.map(enabled_subscribers -- enabled_receivers, fn user ->
-           create_notification(activity, user, type: "status")
-         end))
       |> Enum.reject(&is_nil/1)
 
     {:ok, notifications}
@@ -517,25 +520,7 @@ def get_notified_from_activity(%Activity{data: %{"type" => type}} = activity, lo
     Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
   end
 
-  def get_notified_from_activity(_, _local_only), do: []
+  def get_notified_from_activity(_, _local_only), do: {[], []}
-
-  def get_notified_subscribers_from_activity(activity, local_only \\ true)
-
-  def get_notified_subscribers_from_activity(
-        %Activity{data: %{"type" => "Create"}} = activity,
-        local_only
-      ) do
-    notification_enabled_ap_ids =
-      []
-      |> Utils.maybe_notify_subscribers(activity)
-
-    potential_receivers =
-      User.get_users_from_set(notification_enabled_ap_ids, local_only: local_only)
-
-    Enum.filter(potential_receivers, fn u -> u.ap_id in notification_enabled_ap_ids end)
-  end
-
-  def get_notified_subscribers_from_activity(_, _), do: []
 
   # For some activities, only notify the author of the object
   def get_potential_receiver_ap_ids(%{data: %{"type" => type, "object" => object_id}})
@@ -578,6 +563,7 @@ def get_potential_receiver_ap_ids(activity) do
     []
     |> Utils.maybe_notify_to_recipients(activity)
     |> Utils.maybe_notify_mentioned_recipients(activity)
+    |> Utils.maybe_notify_subscribers(activity)
     |> Utils.maybe_notify_followers(activity)
     |> Enum.uniq()
   end

lib/pleroma/signature.ex

@@ -17,7 +17,6 @@ def key_id_to_actor_id(key_id) do
       key_id
       |> URI.parse()
       |> Map.put(:fragment, nil)
-      |> remove_query()
       |> remove_suffix(@known_suffixes)
 
     maybe_ap_id = URI.to_string(uri)
@@ -34,23 +33,6 @@ def key_id_to_actor_id(key_id) do
     end
   end
 
-  defp remove_query(uri) do
-    if uri.query do
-      new_query =
-        URI.decode_query(uri.query)
-        |> Map.delete("operation")
-        |> URI.encode_query()
-        |> case do
-          "" -> nil
-          query -> query
-        end
-
-      Map.put(uri, :query, new_query)
-    else
-      uri
-    end
-  end
-
   defp remove_suffix(uri, [test | rest]) do
     if not is_nil(uri.path) and String.ends_with?(uri.path, test) do
       Map.put(uri, :path, String.replace(uri.path, test, ""))

lib/pleroma/user.ex

@@ -1404,40 +1404,6 @@ def get_friends_ids(%User{} = user, page \\ nil) do
     |> Repo.all()
   end
 
-  @spec get_familiar_followers_query(User.t(), User.t(), pos_integer() | nil) :: Ecto.Query.t()
-  def get_familiar_followers_query(%User{} = user, %User{} = current_user, nil) do
-    friends =
-      get_friends_query(current_user)
-      |> where([u], not u.hide_follows)
-      |> select([u], u.id)
-
-    User.Query.build(%{is_active: true})
-    |> where([u], u.id not in ^[user.id, current_user.id])
-    |> join(:inner, [u], r in FollowingRelationship,
-      as: :followers_relationships,
-      on: r.following_id == ^user.id and r.follower_id == u.id
-    )
-    |> where([followers_relationships: r], r.state == ^:follow_accept)
-    |> where([followers_relationships: r], r.follower_id in subquery(friends))
-  end
-
-  def get_familiar_followers_query(%User{} = user, %User{} = current_user, page) do
-    user
-    |> get_familiar_followers_query(current_user, nil)
-    |> User.Query.paginate(page, 20)
-  end
-
-  @spec get_familiar_followers_query(User.t(), User.t()) :: Ecto.Query.t()
-  def get_familiar_followers_query(%User{} = user, %User{} = current_user),
-    do: get_familiar_followers_query(user, current_user, nil)
-
-  @spec get_familiar_followers(User.t(), User.t(), pos_integer() | nil) :: {:ok, list(User.t())}
-  def get_familiar_followers(%User{} = user, %User{} = current_user, page \\ nil) do
-    user
-    |> get_familiar_followers_query(current_user, page)
-    |> Repo.all()
-  end
-
   def increase_note_count(%User{} = user) do
     User
     |> where(id: ^user.id)

lib/pleroma/web/api_spec/operations/account_operation.ex

@@ -11,7 +11,6 @@ defmodule Pleroma.Web.ApiSpec.AccountOperation do
   alias Pleroma.Web.ApiSpec.Schemas.ActorType
   alias Pleroma.Web.ApiSpec.Schemas.ApiError
   alias Pleroma.Web.ApiSpec.Schemas.BooleanLike
-  alias Pleroma.Web.ApiSpec.Schemas.FlakeID
   alias Pleroma.Web.ApiSpec.Schemas.List
   alias Pleroma.Web.ApiSpec.Schemas.Status
   alias Pleroma.Web.ApiSpec.Schemas.VisibilityScope
@@ -514,48 +513,6 @@ def identity_proofs_operation do
     }
   end
 
-  def familiar_followers_operation do
-    %Operation{
-      tags: ["Retrieve account information"],
-      summary: "Followers that you follow",
-      operationId: "AccountController.familiar_followers",
-      description:
-        "Obtain a list of all accounts that follow a given account, filtered for accounts you follow.",
-      security: [%{"oAuth" => ["read:follows"]}],
-      parameters: [
-        Operation.parameter(
-          :id,
-          :query,
-          %Schema{
-            oneOf: [%Schema{type: :array, items: %Schema{type: :string}}, %Schema{type: :string}]
-          },
-          "Account IDs",
-          example: "123"
-        )
-      ],
-      responses: %{
-        200 =>
-          Operation.response("Accounts", "application/json", %Schema{
-            title: "ArrayOfAccounts",
-            type: :array,
-            items: %Schema{
-              title: "Account",
-              type: :object,
-              properties: %{
-                id: FlakeID,
-                accounts: %Schema{
-                  title: "ArrayOfAccounts",
-                  type: :array,
-                  items: Account,
-                  example: [Account.schema().example]
-                }
-              }
-            }
-          })
-      }
-    }
-  end
-
   defp create_request do
     %Schema{
       title: "AccountCreateRequest",

lib/pleroma/web/api_spec/operations/notification_operation.ex

@@ -202,8 +202,7 @@ defp notification_type do
         "pleroma:report",
         "move",
         "follow_request",
-        "poll",
+        "poll"
-        "status"
       ],
       description: """
       The type of event that resulted in the notification.
@@ -217,7 +216,6 @@ defp notification_type do
       - `pleroma:emoji_reaction` - Someone reacted with emoji to your status
       - `pleroma:chat_mention` - Someone mentioned you in a chat message
       - `pleroma:report` - Someone was reported
-      - `status` - Someone you are subscribed to created a status
       """
     }
   end

lib/pleroma/web/api_spec/operations/pleroma_notification_operation.ex

@@ -5,6 +5,7 @@
 defmodule Pleroma.Web.ApiSpec.PleromaNotificationOperation do
   alias OpenApiSpex.Operation
   alias OpenApiSpex.Schema
+  alias Pleroma.Web.ApiSpec.NotificationOperation
   alias Pleroma.Web.ApiSpec.Schemas.ApiError
 
   import Pleroma.Web.ApiSpec.Helpers
@@ -34,7 +35,12 @@ def mark_as_read_operation do
           Operation.response(
             "A Notification or array of Notifications",
             "application/json",
-            %Schema{type: :string}
+            %Schema{
+              anyOf: [
+                %Schema{type: :array, items: NotificationOperation.notification()},
+                NotificationOperation.notification()
+              ]
+            }
           ),
         400 => Operation.response("Bad Request", "application/json", ApiError)
       }

lib/pleroma/web/mastodon_api/controllers/account_controller.ex

@@ -72,10 +72,7 @@ defmodule Pleroma.Web.MastodonAPI.AccountController do
     %{scopes: ["follow", "write:blocks"]} when action in [:block, :unblock]
   )
 
-  plug(
+  plug(OAuthScopesPlug, %{scopes: ["read:follows"]} when action == :relationships)
-    OAuthScopesPlug,
-    %{scopes: ["read:follows"]} when action in [:relationships, :familiar_followers]
-  )
 
   plug(
     OAuthScopesPlug,
@@ -632,35 +629,6 @@ def endorsements(%{assigns: %{user: user}} = conn, params) do
     )
   end
 
-  @doc "GET /api/v1/accounts/familiar_followers"
-  def familiar_followers(
-        %{assigns: %{user: user}, private: %{open_api_spex: %{params: %{id: id}}}} = conn,
-        _id
-      ) do
-    users =
-      User.get_all_by_ids(List.wrap(id))
-      |> Enum.map(&%{id: &1.id, accounts: get_familiar_followers(&1, user)})
-
-    conn
-    |> render("familiar_followers.json",
-      for: user,
-      users: users,
-      as: :user
-    )
-  end
-
-  defp get_familiar_followers(%{id: id} = user, %{id: id}) do
-    User.get_familiar_followers(user, user)
-  end
-
-  defp get_familiar_followers(%{hide_followers: true}, _current_user) do
-    []
-  end
-
-  defp get_familiar_followers(user, current_user) do
-    User.get_familiar_followers(user, current_user)
-  end
-
   @doc "GET /api/v1/identity_proofs"
   def identity_proofs(conn, params), do: MastodonAPIController.empty_array(conn, params)
 end

lib/pleroma/web/mastodon_api/controllers/notification_controller.ex

@@ -34,7 +34,6 @@ defmodule Pleroma.Web.MastodonAPI.NotificationController do
       pleroma:emoji_reaction
       poll
       update
-      status
     }
 
   # GET /api/v1/notifications

lib/pleroma/web/mastodon_api/views/account_view.ex

@@ -193,25 +193,6 @@ def render("relationships.json", %{user: user, targets: targets} = opts) do
     render_many(targets, AccountView, "relationship.json", render_opts)
   end
 
-  def render("familiar_followers.json", %{users: users} = opts) do
-    opts =
-      opts
-      |> Map.merge(%{as: :user})
-      |> Map.delete(:users)
-
-    users
-    |> render_many(AccountView, "familiar_followers.json", opts)
-  end
-
-  def render("familiar_followers.json", %{user: %{id: id, accounts: accounts}} = opts) do
-    accounts =
-      accounts
-      |> render_many(AccountView, "show.json", opts)
-      |> Enum.filter(&Enum.any?/1)
-
-    %{id: id, accounts: accounts}
-  end
-
   defp do_render("show.json", %{user: user} = opts) do
     self = opts[:for] == user
 

lib/pleroma/web/mastodon_api/views/notification_view.ex

@@ -108,9 +108,6 @@ def render(
       "mention" ->
         put_status(response, activity, reading_user, status_render_opts)
 
-      "status" ->
-        put_status(response, activity, reading_user, status_render_opts)
-
       "favourite" ->
         put_status(response, parent_activity_fn.(), reading_user, status_render_opts)
 

lib/pleroma/web/pleroma_api/controllers/notification_controller.ex

@@ -23,9 +23,8 @@ def mark_as_read(
         } = conn,
         _
       ) do
-    with {:ok, _} <- Notification.read_one(user, notification_id) do
+    with {:ok, notification} <- Notification.read_one(user, notification_id) do
-      conn
+      render(conn, "show.json", notification: notification, for: user)
-      |> json("ok")
     else
       {:error, message} ->
         conn
@@ -39,14 +38,11 @@ def mark_as_read(
           conn,
         _
       ) do
-    with {:ok, _} <- Notification.set_read_up_to(user, max_id) do
+    notifications =
-      conn
+      user
-      |> json("ok")
+      |> Notification.set_read_up_to(max_id)
-    else
+      |> Enum.take(80)
-      {:error, message} ->
+
-        conn
+    render(conn, "index.json", notifications: notifications, for: user)
-        |> put_status(:bad_request)
-        |> json(%{"error" => message})
-    end
   end
 end

lib/pleroma/web/push/impl.ex

@@ -192,7 +192,6 @@ def format_title(%{activity: %{data: %{"directMessage" => true}}}, _mastodon_typ
   def format_title(%{type: type}, mastodon_type) do
     case mastodon_type || type do
       "mention" -> "New Mention"
-      "status" -> "New Status"
       "follow" -> "New Follower"
       "follow_request" -> "New Follow Request"
       "reblog" -> "New Repeat"

lib/pleroma/web/router.ex

@@ -638,7 +638,6 @@ defmodule Pleroma.Web.Router do
     patch("/accounts/update_credentials", AccountController, :update_credentials)
 
     get("/accounts/relationships", AccountController, :relationships)
-    get("/accounts/familiar_followers", AccountController, :familiar_followers)
     get("/accounts/:id/lists", AccountController, :lists)
     get("/accounts/:id/identity_proofs", AccountController, :identity_proofs)
     get("/endorsements", AccountController, :endorsements)

priv/repo/migrations/20220319000000_add_status_to_notifications_enum.exs

@@ -1,51 +0,0 @@
-defmodule Pleroma.Repo.Migrations.AddStatusToNotificationsEnum do
-  use Ecto.Migration
-
-  @disable_ddl_transaction true
-
-  def up do
-    """
-    alter type notification_type add value 'status'
-    """
-    |> execute()
-  end
-
-  def down do
-    alter table(:notifications) do
-      modify(:type, :string)
-    end
-
-    """
-    delete from notifications where type = 'status'
-    """
-    |> execute()
-
-    """
-    drop type if exists notification_type
-    """
-    |> execute()
-
-    """
-    create type notification_type as enum (
-      'follow',
-      'follow_request',
-      'mention',
-      'move',
-      'pleroma:emoji_reaction',
-      'pleroma:chat_mention',
-      'reblog',
-      'favourite',
-      'pleroma:report',
-      'poll',
-      'update'
-    )
-    """
-    |> execute()
-
-    """
-    alter table notifications
-    alter column type type notification_type using (type::notification_type)
-    """
-    |> execute()
-  end
-end

test/fixtures/create-chat-message.json

@@ -1,10 +1,10 @@
 {
-  "actor": "http://2hu.gensokyo/users/raymoo",
+  "actor": "http://mastodon.example.org/users/admin",
-  "id": "http://2hu.gensokyo/objects/1",
+  "id": "http://mastodon.example.org/objects/1",
   "object": {
-    "attributedTo": "http://2hu.gensokyo/users/raymoo",
+    "attributedTo": "http://mastodon.example.org/users/admin",
     "content": "You expected a cute girl? Too bad. <script>alert('XSS')</script>",
-    "id": "http://2hu.gensokyo/objects/2",
+    "id": "http://mastodon.example.org/objects/2",
     "published": "2020-02-12T14:08:20Z",
     "to": [
       "http://2hu.gensokyo/users/marisa"

test/pleroma/notification_test.exs

@@ -112,7 +112,6 @@ test "it creates a notification for subscribed users" do
       {:ok, [notification]} = Notification.create_notifications(status)
 
       assert notification.user_id == subscriber.id
-      assert notification.type == "status"
     end
 
     test "does not create a notification for subscribed users if status is a reply" do
@@ -137,21 +136,6 @@ test "does not create a notification for subscribed users if status is a reply"
       assert Enum.empty?(subscriber_notifications)
     end
 
-    test "does not create subscriber notification if mentioned" do
-      user = insert(:user)
-      subscriber = insert(:user)
-
-      User.subscribe(subscriber, user)
-
-      {:ok, status} = CommonAPI.post(user, %{status: "mentioning @#{subscriber.nickname}"})
-      {:ok, [notification] = notifications} = Notification.create_notifications(status)
-
-      assert length(notifications) == 1
-
-      assert notification.user_id == subscriber.id
-      assert notification.type == "mention"
-    end
-
     test "it sends edited notifications to those who repeated a status" do
       user = insert(:user)
       repeated_user = insert(:user)
@@ -465,7 +449,9 @@ test "it sets all notifications as read up to a specified notification ID" do
           status: "hey yet again @#{other_user.nickname}!"
         })
 
-      Notification.set_read_up_to(other_user, n2.id)
+      [_, read_notification] = Notification.set_read_up_to(other_user, n2.id)
+
+      assert read_notification.activity.object
 
       [n3, n2, n1] = Notification.for_user(other_user)
 

test/pleroma/user/backup_test.exs

@@ -221,7 +221,6 @@ test "it creates a zip archive with user data" do
              "orderedItems" => [
                %{
                  "object" => %{
-                   "actor" => "http://cofe.io/users/cofe",
                    "content" => "status1",
                    "type" => "Note"
                  },
@@ -229,7 +228,6 @@ test "it creates a zip archive with user data" do
                },
                %{
                  "object" => %{
-                   "actor" => "http://cofe.io/users/cofe",
                    "content" => "status2"
                  }
                },

test/pleroma/user_test.exs

@@ -2894,20 +2894,6 @@ test "should report error on non-existing alias" do
     end
   end
 
-  describe "get_familiar_followers/3" do
-    test "returns familiar followers for a pair of users" do
-      user1 = insert(:user)
-      %{id: id2} = user2 = insert(:user)
-      user3 = insert(:user)
-      _user4 = insert(:user)
-
-      User.follow(user1, user2)
-      User.follow(user2, user3)
-
-      assert [%{id: ^id2}] = User.get_familiar_followers(user3, user1)
-    end
-  end
-
   describe "account endorsements" do
     test "it pins people" do
       user = insert(:user)

test/pleroma/web/activity_pub/transmogrifier/chat_message_test.exs

@@ -116,8 +116,6 @@ test "it fetches the actor if they aren't in our system" do
       data =
         File.read!("test/fixtures/create-chat-message.json")
         |> Jason.decode!()
-        |> Map.put("actor", "http://mastodon.example.org/users/admin")
-        |> put_in(["object", "actor"], "http://mastodon.example.org/users/admin")
 
       _recipient = insert(:user, ap_id: List.first(data["to"]), local: true)
 

test/pleroma/web/activity_pub/transmogrifier_test.exs

@@ -169,7 +169,7 @@ test "it inlines private announced objects" do
       {:ok, modified} = Transmogrifier.prepare_outgoing(announce_activity.data)
 
       assert modified["object"]["content"] == "hey"
-      assert modified["object"]["actor"] == modified["object"]["attributedTo"]
+      assert activity.actor == modified["object"]["attributedTo"]
     end
 
     test "it turns mentions into tags" do
@@ -220,7 +220,7 @@ test "it sets the 'attributedTo' property to the actor of the object if it doesn
       {:ok, activity} = CommonAPI.post(user, %{status: "hey"})
       {:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
 
-      assert modified["object"]["actor"] == modified["object"]["attributedTo"]
+      assert activity.actor == modified["object"]["attributedTo"]
     end
 
     test "it strips internal hashtag data" do
@@ -266,6 +266,7 @@ test "it strips internal fields" do
       assert is_nil(modified["object"]["announcements"])
       assert is_nil(modified["object"]["announcement_count"])
       assert is_nil(modified["object"]["generator"])
+      assert is_nil(modified["object"]["actor"])
     end
 
     test "it strips internal fields of article" do

test/pleroma/web/mastodon_api/controllers/account_controller_test.exs

@@ -2172,55 +2172,6 @@ test "max pinned accounts", %{user: user, conn: conn} do
     end
   end
 
-  describe "familiar followers" do
-    setup do: oauth_access(["read:follows"])
-
-    test "fetch user familiar followers", %{user: user, conn: conn} do
-      %{id: id1} = other_user1 = insert(:user)
-      %{id: id2} = other_user2 = insert(:user)
-      _ = insert(:user)
-
-      User.follow(user, other_user1)
-      User.follow(other_user1, other_user2)
-
-      assert [%{"accounts" => [%{"id" => ^id1}], "id" => ^id2}] =
-               conn
-               |> put_req_header("content-type", "application/json")
-               |> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
-               |> json_response_and_validate_schema(200)
-    end
-
-    test "returns empty array if followers are hidden", %{user: user, conn: conn} do
-      other_user1 = insert(:user, hide_follows: true)
-      %{id: id2} = other_user2 = insert(:user)
-      _ = insert(:user)
-
-      User.follow(user, other_user1)
-      User.follow(other_user1, other_user2)
-
-      assert [%{"accounts" => [], "id" => ^id2}] =
-               conn
-               |> put_req_header("content-type", "application/json")
-               |> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
-               |> json_response_and_validate_schema(200)
-    end
-
-    test "it respects hide_followers", %{user: user, conn: conn} do
-      other_user1 = insert(:user)
-      %{id: id2} = other_user2 = insert(:user, hide_followers: true)
-      _ = insert(:user)
-
-      User.follow(user, other_user1)
-      User.follow(other_user1, other_user2)
-
-      assert [%{"accounts" => [], "id" => ^id2}] =
-               conn
-               |> put_req_header("content-type", "application/json")
-               |> get("/api/v1/accounts/familiar_followers?id[]=#{id2}")
-               |> json_response_and_validate_schema(200)
-    end
-  end
-
   describe "remove from followers" do
     setup do: oauth_access(["follow"])
 

test/pleroma/web/mastodon_api/views/notification_view_test.exs

@@ -331,31 +331,4 @@ test "muted notification" do
 
     test_notifications_rendering([notification], user, [expected])
   end
-
-  test "Subscribed status notification" do
-    user = insert(:user)
-    subscriber = insert(:user)
-
-    User.subscribe(subscriber, user)
-
-    {:ok, activity} = CommonAPI.post(user, %{status: "hi"})
-    {:ok, [notification]} = Notification.create_notifications(activity)
-
-    user = User.get_cached_by_id(user.id)
-
-    expected = %{
-      id: to_string(notification.id),
-      pleroma: %{is_seen: false, is_muted: false},
-      type: "status",
-      account:
-        AccountView.render("show.json", %{
-          user: user,
-          for: subscriber
-        }),
-      status: StatusView.render("show.json", %{activity: activity, for: subscriber}),
-      created_at: Utils.to_masto_date(notification.inserted_at)
-    }
-
-    test_notifications_rendering([notification], subscriber, [expected])
-  end
 end

test/pleroma/web/pleroma_api/controllers/notification_controller_test.exs

@@ -21,11 +21,13 @@ test "it marks a single notification as read", %{user: user1, conn: conn} do
       {:ok, [notification1]} = Notification.create_notifications(activity1)
       {:ok, [notification2]} = Notification.create_notifications(activity2)
 
-      conn
+      response =
-      |> put_req_header("content-type", "application/json")
+        conn
-      |> post("/api/v1/pleroma/notifications/read", %{id: notification1.id})
+        |> put_req_header("content-type", "application/json")
-      |> json_response_and_validate_schema(:ok)
+        |> post("/api/v1/pleroma/notifications/read", %{id: notification1.id})
+        |> json_response_and_validate_schema(:ok)
 
+      assert %{"pleroma" => %{"is_seen" => true}} = response
       assert Repo.get(Notification, notification1.id).seen
       refute Repo.get(Notification, notification2.id).seen
     end
@@ -38,17 +40,14 @@ test "it marks multiple notifications as read", %{user: user1, conn: conn} do
 
       [notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})
 
-      refute Repo.get(Notification, notification1.id).seen
+      [response1, response2] =
-      refute Repo.get(Notification, notification2.id).seen
+        conn
-      refute Repo.get(Notification, notification3.id).seen
+        |> put_req_header("content-type", "application/json")
-
+        |> post("/api/v1/pleroma/notifications/read", %{max_id: notification2.id})
-      conn
+        |> json_response_and_validate_schema(:ok)
-      |> put_req_header("content-type", "application/json")
-      |> post("/api/v1/pleroma/notifications/read", %{max_id: notification2.id})
-      |> json_response_and_validate_schema(:ok)
-
-      [notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})
 
+      assert %{"pleroma" => %{"is_seen" => true}} = response1
+      assert %{"pleroma" => %{"is_seen" => true}} = response2
       assert Repo.get(Notification, notification1.id).seen
       assert Repo.get(Notification, notification2.id).seen
       refute Repo.get(Notification, notification3.id).seen