Merge branch 'split-masto-api/scheduled-statuses' into 'develop'

Extract scheduled statuses actions from `MastodonAPIController` to `ScheduledActivityController`

See merge request pleroma/pleroma!1728

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

@@ -19,7 +19,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   alias Pleroma.Pagination
   alias Pleroma.Plugs.RateLimiter
   alias Pleroma.Repo
-  alias Pleroma.ScheduledActivity
   alias Pleroma.Stats
   alias Pleroma.User
   alias Pleroma.Web
@@ -33,7 +32,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
   alias Pleroma.Web.MastodonAPI.MastodonAPI
   alias Pleroma.Web.MastodonAPI.MastodonView
   alias Pleroma.Web.MastodonAPI.ReportView
-  alias Pleroma.Web.MastodonAPI.ScheduledActivityView
   alias Pleroma.Web.MastodonAPI.StatusView
   alias Pleroma.Web.MediaProxy
   alias Pleroma.Web.OAuth.App
@@ -394,55 +392,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
     end
   end
 
-  def scheduled_statuses(%{assigns: %{user: user}} = conn, params) do
-    with scheduled_activities <- MastodonAPI.get_scheduled_activities(user, params) do
-      conn
-      |> add_link_headers(scheduled_activities)
-      |> put_view(ScheduledActivityView)
-      |> render("index.json", %{scheduled_activities: scheduled_activities})
-    end
-  end
-
-  def show_scheduled_status(%{assigns: %{user: user}} = conn, %{"id" => scheduled_activity_id}) do
-    with %ScheduledActivity{} = scheduled_activity <-
-           ScheduledActivity.get(user, scheduled_activity_id) do
-      conn
-      |> put_view(ScheduledActivityView)
-      |> render("show.json", %{scheduled_activity: scheduled_activity})
-    else
-      _ -> {:error, :not_found}
-    end
-  end
-
-  def update_scheduled_status(
-        %{assigns: %{user: user}} = conn,
-        %{"id" => scheduled_activity_id} = params
-      ) do
-    with %ScheduledActivity{} = scheduled_activity <-
-           ScheduledActivity.get(user, scheduled_activity_id),
-         {:ok, scheduled_activity} <- ScheduledActivity.update(scheduled_activity, params) do
-      conn
-      |> put_view(ScheduledActivityView)
-      |> render("show.json", %{scheduled_activity: scheduled_activity})
-    else
-      nil -> {:error, :not_found}
-      error -> error
-    end
-  end
-
-  def delete_scheduled_status(%{assigns: %{user: user}} = conn, %{"id" => scheduled_activity_id}) do
-    with %ScheduledActivity{} = scheduled_activity <-
-           ScheduledActivity.get(user, scheduled_activity_id),
-         {:ok, scheduled_activity} <- ScheduledActivity.delete(scheduled_activity) do
-      conn
-      |> put_view(ScheduledActivityView)
-      |> render("show.json", %{scheduled_activity: scheduled_activity})
-    else
-      nil -> {:error, :not_found}
-      error -> error
-    end
-  end
-
   def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
     id = List.wrap(id)
     q = from(u in User, where: u.id in ^id)

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

@@ -0,0 +1,51 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.MastodonAPI.ScheduledActivityController do
+  use Pleroma.Web, :controller
+
+  import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
+
+  alias Pleroma.ScheduledActivity
+  alias Pleroma.Web.MastodonAPI.MastodonAPI
+
+  plug(:assign_scheduled_activity when action != :index)
+
+  action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
+
+  @doc "GET /api/v1/scheduled_statuses"
+  def index(%{assigns: %{user: user}} = conn, params) do
+    with scheduled_activities <- MastodonAPI.get_scheduled_activities(user, params) do
+      conn
+      |> add_link_headers(scheduled_activities)
+      |> render("index.json", scheduled_activities: scheduled_activities)
+    end
+  end
+
+  @doc "GET /api/v1/scheduled_statuses/:id"
+  def show(%{assigns: %{scheduled_activity: scheduled_activity}} = conn, _params) do
+    render(conn, "show.json", scheduled_activity: scheduled_activity)
+  end
+
+  @doc "PUT /api/v1/scheduled_statuses/:id"
+  def update(%{assigns: %{scheduled_activity: scheduled_activity}} = conn, params) do
+    with {:ok, scheduled_activity} <- ScheduledActivity.update(scheduled_activity, params) do
+      render(conn, "show.json", scheduled_activity: scheduled_activity)
+    end
+  end
+
+  @doc "DELETE /api/v1/scheduled_statuses/:id"
+  def delete(%{assigns: %{scheduled_activity: scheduled_activity}} = conn, _params) do
+    with {:ok, scheduled_activity} <- ScheduledActivity.delete(scheduled_activity) do
+      render(conn, "show.json", scheduled_activity: scheduled_activity)
+    end
+  end
+
+  defp assign_scheduled_activity(%{assigns: %{user: user}, params: %{"id" => id}} = conn, _) do
+    case ScheduledActivity.get(user, id) do
+      %ScheduledActivity{} = activity -> assign(conn, :scheduled_activity, activity)
+      nil -> Pleroma.Web.MastodonAPI.FallbackController.call(conn, {:error, :not_found}) |> halt()
+    end
+  end
+end

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

@@ -7,11 +7,10 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityView do
 
   alias Pleroma.ScheduledActivity
   alias Pleroma.Web.CommonAPI
-  alias Pleroma.Web.MastodonAPI.ScheduledActivityView
   alias Pleroma.Web.MastodonAPI.StatusView
 
   def render("index.json", %{scheduled_activities: scheduled_activities}) do
-    render_many(scheduled_activities, ScheduledActivityView, "show.json")
+    render_many(scheduled_activities, __MODULE__, "show.json")
   end
 
   def render("show.json", %{scheduled_activity: %ScheduledActivity{} = scheduled_activity}) do
@@ -24,12 +23,8 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityView do
   end
 
   defp with_media_attachments(data, %{params: %{"media_attachments" => media_attachments}}) do
-    try do
-      attachments = render_many(media_attachments, StatusView, "attachment.json", as: :attachment)
-      Map.put(data, :media_attachments, attachments)
-    rescue
-      _ -> data
-    end
+    attachments = render_many(media_attachments, StatusView, "attachment.json", as: :attachment)
+    Map.put(data, :media_attachments, attachments)
   end
 
   defp with_media_attachments(data, _), do: data
@@ -45,13 +40,9 @@ defmodule Pleroma.Web.MastodonAPI.ScheduledActivityView do
       in_reply_to_id: params["in_reply_to_id"]
     }
 
-    data =
-      if media_ids = params["media_ids"] do
-        Map.put(data, :media_ids, media_ids)
-      else
-        data
-      end
-
-    data
+    case params["media_ids"] do
+      nil -> data
+      media_ids -> Map.put(data, :media_ids, media_ids)
+    end
   end
 end

lib/pleroma/web/router.ex

@@ -339,8 +339,8 @@ defmodule Pleroma.Web.Router do
       post("/notifications/dismiss", NotificationController, :dismiss)
       delete("/notifications/destroy_multiple", NotificationController, :destroy_multiple)
 
-      get("/scheduled_statuses", MastodonAPIController, :scheduled_statuses)
-      get("/scheduled_statuses/:id", MastodonAPIController, :show_scheduled_status)
+      get("/scheduled_statuses", ScheduledActivityController, :index)
+      get("/scheduled_statuses/:id", ScheduledActivityController, :show)
 
       get("/lists", ListController, :index)
       get("/lists/:id", ListController, :show)
@@ -377,8 +377,8 @@ defmodule Pleroma.Web.Router do
       post("/statuses/:id/mute", StatusController, :mute_conversation)
       post("/statuses/:id/unmute", StatusController, :unmute_conversation)
 
-      put("/scheduled_statuses/:id", MastodonAPIController, :update_scheduled_status)
-      delete("/scheduled_statuses/:id", MastodonAPIController, :delete_scheduled_status)
+      put("/scheduled_statuses/:id", ScheduledActivityController, :update)
+      delete("/scheduled_statuses/:id", ScheduledActivityController, :delete)
 
       post("/polls/:id/votes", MastodonAPIController, :poll_vote)
 

test/web/mastodon_api/controllers/scheduled_activity_controller_test.exs

@@ -0,0 +1,113 @@
+# Pleroma: A lightweight social networking server
+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: AGPL-3.0-only
+
+defmodule Pleroma.Web.MastodonAPI.ScheduledActivityControllerTest do
+  use Pleroma.Web.ConnCase, async: true
+
+  alias Pleroma.Repo
+  alias Pleroma.ScheduledActivity
+
+  import Pleroma.Factory
+
+  test "shows scheduled activities", %{conn: conn} do
+    user = insert(:user)
+    scheduled_activity_id1 = insert(:scheduled_activity, user: user).id |> to_string()
+    scheduled_activity_id2 = insert(:scheduled_activity, user: user).id |> to_string()
+    scheduled_activity_id3 = insert(:scheduled_activity, user: user).id |> to_string()
+    scheduled_activity_id4 = insert(:scheduled_activity, user: user).id |> to_string()
+
+    conn =
+      conn
+      |> assign(:user, user)
+
+    # min_id
+    conn_res =
+      conn
+      |> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")
+
+    result = json_response(conn_res, 200)
+    assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
+
+    # since_id
+    conn_res =
+      conn
+      |> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")
+
+    result = json_response(conn_res, 200)
+    assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result
+
+    # max_id
+    conn_res =
+      conn
+      |> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")
+
+    result = json_response(conn_res, 200)
+    assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
+  end
+
+  test "shows a scheduled activity", %{conn: conn} do
+    user = insert(:user)
+    scheduled_activity = insert(:scheduled_activity, user: user)
+
+    res_conn =
+      conn
+      |> assign(:user, user)
+      |> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
+
+    assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
+    assert scheduled_activity_id == scheduled_activity.id |> to_string()
+
+    res_conn =
+      conn
+      |> assign(:user, user)
+      |> get("/api/v1/scheduled_statuses/404")
+
+    assert %{"error" => "Record not found"} = json_response(res_conn, 404)
+  end
+
+  test "updates a scheduled activity", %{conn: conn} do
+    user = insert(:user)
+    scheduled_activity = insert(:scheduled_activity, user: user)
+
+    new_scheduled_at =
+      NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
+
+    res_conn =
+      conn
+      |> assign(:user, user)
+      |> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
+        scheduled_at: new_scheduled_at
+      })
+
+    assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
+    assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)
+
+    res_conn =
+      conn
+      |> assign(:user, user)
+      |> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})
+
+    assert %{"error" => "Record not found"} = json_response(res_conn, 404)
+  end
+
+  test "deletes a scheduled activity", %{conn: conn} do
+    user = insert(:user)
+    scheduled_activity = insert(:scheduled_activity, user: user)
+
+    res_conn =
+      conn
+      |> assign(:user, user)
+      |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
+
+    assert %{} = json_response(res_conn, 200)
+    assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)
+
+    res_conn =
+      conn
+      |> assign(:user, user)
+      |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
+
+    assert %{"error" => "Record not found"} = json_response(res_conn, 404)
+  end
+end

test/web/mastodon_api/controllers/status_controller_test.exs

@@ -9,7 +9,10 @@ defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
   alias Pleroma.ActivityExpiration
   alias Pleroma.Config
   alias Pleroma.Object
+  alias Pleroma.Repo
+  alias Pleroma.ScheduledActivity
   alias Pleroma.User
+  alias Pleroma.Web.ActivityPub.ActivityPub
   alias Pleroma.Web.CommonAPI
 
   import Pleroma.Factory
@@ -224,6 +227,115 @@ defmodule Pleroma.Web.MastodonAPI.StatusControllerTest do
     end
   end
 
+  describe "posting scheduled statuses" do
+    test "creates a scheduled activity", %{conn: conn} do
+      user = insert(:user)
+      scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/statuses", %{
+          "status" => "scheduled",
+          "scheduled_at" => scheduled_at
+        })
+
+      assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
+      assert expected_scheduled_at == CommonAPI.Utils.to_masto_date(scheduled_at)
+      assert [] == Repo.all(Activity)
+    end
+
+    test "creates a scheduled activity with a media attachment", %{conn: conn} do
+      user = insert(:user)
+      scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
+
+      file = %Plug.Upload{
+        content_type: "image/jpg",
+        path: Path.absname("test/fixtures/image.jpg"),
+        filename: "an_image.jpg"
+      }
+
+      {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/statuses", %{
+          "media_ids" => [to_string(upload.id)],
+          "status" => "scheduled",
+          "scheduled_at" => scheduled_at
+        })
+
+      assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
+      assert %{"type" => "image"} = media_attachment
+    end
+
+    test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
+         %{conn: conn} do
+      user = insert(:user)
+
+      scheduled_at =
+        NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/statuses", %{
+          "status" => "not scheduled",
+          "scheduled_at" => scheduled_at
+        })
+
+      assert %{"content" => "not scheduled"} = json_response(conn, 200)
+      assert [] == Repo.all(ScheduledActivity)
+    end
+
+    test "returns error when daily user limit is exceeded", %{conn: conn} do
+      user = insert(:user)
+
+      today =
+        NaiveDateTime.utc_now()
+        |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
+        |> NaiveDateTime.to_iso8601()
+
+      attrs = %{params: %{}, scheduled_at: today}
+      {:ok, _} = ScheduledActivity.create(user, attrs)
+      {:ok, _} = ScheduledActivity.create(user, attrs)
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
+
+      assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
+    end
+
+    test "returns error when total user limit is exceeded", %{conn: conn} do
+      user = insert(:user)
+
+      today =
+        NaiveDateTime.utc_now()
+        |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
+        |> NaiveDateTime.to_iso8601()
+
+      tomorrow =
+        NaiveDateTime.utc_now()
+        |> NaiveDateTime.add(:timer.hours(36), :millisecond)
+        |> NaiveDateTime.to_iso8601()
+
+      attrs = %{params: %{}, scheduled_at: today}
+      {:ok, _} = ScheduledActivity.create(user, attrs)
+      {:ok, _} = ScheduledActivity.create(user, attrs)
+      {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
+
+      conn =
+        conn
+        |> assign(:user, user)
+        |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
+
+      assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
+    end
+  end
+
   describe "posting polls" do
     test "posting a poll", %{conn: conn} do
       user = insert(:user)

test/web/mastodon_api/mastodon_api_controller_test.exs

@@ -6,12 +6,10 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
   use Pleroma.Web.ConnCase
 
   alias Ecto.Changeset
-  alias Pleroma.Activity
   alias Pleroma.Config
   alias Pleroma.Notification
   alias Pleroma.Object
   alias Pleroma.Repo
-  alias Pleroma.ScheduledActivity
   alias Pleroma.Tests.ObanHelpers
   alias Pleroma.User
   alias Pleroma.Web.ActivityPub.ActivityPub
@@ -1681,216 +1679,6 @@ defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
     end
   end
 
-  describe "scheduled activities" do
-    test "creates a scheduled activity", %{conn: conn} do
-      user = insert(:user)
-      scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/statuses", %{
-          "status" => "scheduled",
-          "scheduled_at" => scheduled_at
-        })
-
-      assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
-      assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(scheduled_at)
-      assert [] == Repo.all(Activity)
-    end
-
-    test "creates a scheduled activity with a media attachment", %{conn: conn} do
-      user = insert(:user)
-      scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
-
-      file = %Plug.Upload{
-        content_type: "image/jpg",
-        path: Path.absname("test/fixtures/image.jpg"),
-        filename: "an_image.jpg"
-      }
-
-      {:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/statuses", %{
-          "media_ids" => [to_string(upload.id)],
-          "status" => "scheduled",
-          "scheduled_at" => scheduled_at
-        })
-
-      assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
-      assert %{"type" => "image"} = media_attachment
-    end
-
-    test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
-         %{conn: conn} do
-      user = insert(:user)
-
-      scheduled_at =
-        NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/statuses", %{
-          "status" => "not scheduled",
-          "scheduled_at" => scheduled_at
-        })
-
-      assert %{"content" => "not scheduled"} = json_response(conn, 200)
-      assert [] == Repo.all(ScheduledActivity)
-    end
-
-    test "returns error when daily user limit is exceeded", %{conn: conn} do
-      user = insert(:user)
-
-      today =
-        NaiveDateTime.utc_now()
-        |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
-        |> NaiveDateTime.to_iso8601()
-
-      attrs = %{params: %{}, scheduled_at: today}
-      {:ok, _} = ScheduledActivity.create(user, attrs)
-      {:ok, _} = ScheduledActivity.create(user, attrs)
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})
-
-      assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
-    end
-
-    test "returns error when total user limit is exceeded", %{conn: conn} do
-      user = insert(:user)
-
-      today =
-        NaiveDateTime.utc_now()
-        |> NaiveDateTime.add(:timer.minutes(6), :millisecond)
-        |> NaiveDateTime.to_iso8601()
-
-      tomorrow =
-        NaiveDateTime.utc_now()
-        |> NaiveDateTime.add(:timer.hours(36), :millisecond)
-        |> NaiveDateTime.to_iso8601()
-
-      attrs = %{params: %{}, scheduled_at: today}
-      {:ok, _} = ScheduledActivity.create(user, attrs)
-      {:ok, _} = ScheduledActivity.create(user, attrs)
-      {:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})
-
-      conn =
-        conn
-        |> assign(:user, user)
-        |> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})
-
-      assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
-    end
-
-    test "shows scheduled activities", %{conn: conn} do
-      user = insert(:user)
-      scheduled_activity_id1 = insert(:scheduled_activity, user: user).id |> to_string()
-      scheduled_activity_id2 = insert(:scheduled_activity, user: user).id |> to_string()
-      scheduled_activity_id3 = insert(:scheduled_activity, user: user).id |> to_string()
-      scheduled_activity_id4 = insert(:scheduled_activity, user: user).id |> to_string()
-
-      conn =
-        conn
-        |> assign(:user, user)
-
-      # min_id
-      conn_res =
-        conn
-        |> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")
-
-      result = json_response(conn_res, 200)
-      assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
-
-      # since_id
-      conn_res =
-        conn
-        |> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")
-
-      result = json_response(conn_res, 200)
-      assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result
-
-      # max_id
-      conn_res =
-        conn
-        |> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")
-
-      result = json_response(conn_res, 200)
-      assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
-    end
-
-    test "shows a scheduled activity", %{conn: conn} do
-      user = insert(:user)
-      scheduled_activity = insert(:scheduled_activity, user: user)
-
-      res_conn =
-        conn
-        |> assign(:user, user)
-        |> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
-
-      assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
-      assert scheduled_activity_id == scheduled_activity.id |> to_string()
-
-      res_conn =
-        conn
-        |> assign(:user, user)
-        |> get("/api/v1/scheduled_statuses/404")
-
-      assert %{"error" => "Record not found"} = json_response(res_conn, 404)
-    end
-
-    test "updates a scheduled activity", %{conn: conn} do
-      user = insert(:user)
-      scheduled_activity = insert(:scheduled_activity, user: user)
-
-      new_scheduled_at =
-        NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)
-
-      res_conn =
-        conn
-        |> assign(:user, user)
-        |> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
-          scheduled_at: new_scheduled_at
-        })
-
-      assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
-      assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)
-
-      res_conn =
-        conn
-        |> assign(:user, user)
-        |> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})
-
-      assert %{"error" => "Record not found"} = json_response(res_conn, 404)
-    end
-
-    test "deletes a scheduled activity", %{conn: conn} do
-      user = insert(:user)
-      scheduled_activity = insert(:scheduled_activity, user: user)
-
-      res_conn =
-        conn
-        |> assign(:user, user)
-        |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
-
-      assert %{} = json_response(res_conn, 200)
-      assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)
-
-      res_conn =
-        conn
-        |> assign(:user, user)
-        |> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")
-
-      assert %{"error" => "Record not found"} = json_response(res_conn, 404)
-    end
-  end
-
   describe "create account by app" do
     test "Account registration via Application", %{conn: conn} do
       conn =