git.squeep.com Git - akkoma/blob - benchmarks/load_testing/fetcher.ex

   1 defmodule Pleroma.LoadTesting.Fetcher do
   2   use Pleroma.LoadTesting.Helper
   3
   4   def fetch_user(user) do
   5     Benchee.run(%{
   6       "By id" => fn -> Repo.get_by(User, id: user.id) end,
   7       "By ap_id" => fn -> Repo.get_by(User, ap_id: user.ap_id) end,
   8       "By email" => fn -> Repo.get_by(User, email: user.email) end,
   9       "By nickname" => fn -> Repo.get_by(User, nickname: user.nickname) end
  10     })
  11   end
  12
  13   def query_timelines(user) do
  14     home_timeline_params = %{
  15       "count" => 20,
  16       "with_muted" => true,
  17       "type" => ["Create", "Announce"],
  18       "blocking_user" => user,
  19       "muting_user" => user,
  20       "user" => user
  21     }
  22
  23     mastodon_public_timeline_params = %{
  24       "count" => 20,
  25       "local_only" => true,
  26       "only_media" => "false",
  27       "type" => ["Create", "Announce"],
  28       "with_muted" => "true",
  29       "blocking_user" => user,
  30       "muting_user" => user
  31     }
  32
  33     mastodon_federated_timeline_params = %{
  34       "count" => 20,
  35       "only_media" => "false",
  36       "type" => ["Create", "Announce"],
  37       "with_muted" => "true",
  38       "blocking_user" => user,
  39       "muting_user" => user
  40     }
  41
  42     following = User.following(user)
  43
  44     Benchee.run(%{
  45       "User home timeline" => fn ->
  46         Pleroma.Web.ActivityPub.ActivityPub.fetch_activities(
  47           following,
  48           home_timeline_params
  49         )
  50       end,
  51       "User mastodon public timeline" => fn ->
  52         Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities(
  53           mastodon_public_timeline_params
  54         )
  55       end,
  56       "User mastodon federated public timeline" => fn ->
  57         Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities(
  58           mastodon_federated_timeline_params
  59         )
  60       end
  61     })
  62
  63     home_activities =
  64       Pleroma.Web.ActivityPub.ActivityPub.fetch_activities(
  65         following,
  66         home_timeline_params
  67       )
  68
  69     public_activities =
  70       Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities(mastodon_public_timeline_params)
  71
  72     public_federated_activities =
  73       Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities(
  74         mastodon_federated_timeline_params
  75       )
  76
  77     Benchee.run(%{
  78       "Rendering home timeline" => fn ->
  79         Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
  80           activities: home_activities,
  81           for: user,
  82           as: :activity
  83         })
  84       end,
  85       "Rendering public timeline" => fn ->
  86         Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
  87           activities: public_activities,
  88           for: user,
  89           as: :activity
  90         })
  91       end,
  92       "Rendering public federated timeline" => fn ->
  93         Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
  94           activities: public_federated_activities,
  95           for: user,
  96           as: :activity
  97         })
  98       end,
  99       "Rendering favorites timeline" => fn ->
 100         conn = Phoenix.ConnTest.build_conn(:get, "http://localhost:4001/api/v1/favourites", nil)
 101         Pleroma.Web.MastodonAPI.StatusController.favourites(
 102           %Plug.Conn{conn |
 103                      assigns: %{user: user},
 104                      query_params:  %{"limit" => "0"},
 105                      body_params: %{},
 106                      cookies: %{},
 107                      params: %{},
 108                      path_params: %{},
 109                      private: %{
 110                        Pleroma.Web.Router => {[], %{}},
 111                        phoenix_router: Pleroma.Web.Router,
 112                        phoenix_action: :favourites,
 113                        phoenix_controller: Pleroma.Web.MastodonAPI.StatusController,
 114                        phoenix_endpoint: Pleroma.Web.Endpoint,
 115                        phoenix_format: "json",
 116                        phoenix_layout: {Pleroma.Web.LayoutView, "app.html"},
 117                        phoenix_recycled: true,
 118
 119                        phoenix_view: Pleroma.Web.MastodonAPI.StatusView,
 120                        plug_session: %{"user_id" => user.id},
 121                        plug_session_fetch: :done,
 122                        plug_session_info: :write,
 123                        plug_skip_csrf_protection: true
 124                      }
 125           },
 126           %{})
 127       end,
 128     })
 129   end
 130
 131   def query_notifications(user) do
 132     without_muted_params = %{"count" => "20", "with_muted" => "false"}
 133     with_muted_params = %{"count" => "20", "with_muted" => "true"}
 134
 135     Benchee.run(%{
 136       "Notifications without muted" => fn ->
 137         Pleroma.Web.MastodonAPI.MastodonAPI.get_notifications(user, without_muted_params)
 138       end,
 139       "Notifications with muted" => fn ->
 140         Pleroma.Web.MastodonAPI.MastodonAPI.get_notifications(user, with_muted_params)
 141       end
 142     })
 143
 144     without_muted_notifications =
 145       Pleroma.Web.MastodonAPI.MastodonAPI.get_notifications(user, without_muted_params)
 146
 147     with_muted_notifications =
 148       Pleroma.Web.MastodonAPI.MastodonAPI.get_notifications(user, with_muted_params)
 149
 150     Benchee.run(%{
 151       "Render notifications without muted" => fn ->
 152         Pleroma.Web.MastodonAPI.NotificationView.render("index.json", %{
 153           notifications: without_muted_notifications,
 154           for: user
 155         })
 156       end,
 157       "Render notifications with muted" => fn ->
 158         Pleroma.Web.MastodonAPI.NotificationView.render("index.json", %{
 159           notifications: with_muted_notifications,
 160           for: user
 161         })
 162       end
 163     })
 164   end
 165
 166   def query_dms(user) do
 167     params = %{
 168       "count" => "20",
 169       "with_muted" => "true",
 170       "type" => "Create",
 171       "blocking_user" => user,
 172       "user" => user,
 173       visibility: "direct"
 174     }
 175
 176     Benchee.run(%{
 177       "Direct messages with muted" => fn ->
 178         Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_query([user.ap_id], params)
 179         |> Pleroma.Pagination.fetch_paginated(params)
 180       end,
 181       "Direct messages without muted" => fn ->
 182         Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_query([user.ap_id], params)
 183         |> Pleroma.Pagination.fetch_paginated(Map.put(params, "with_muted", false))
 184       end
 185     })
 186
 187     dms_with_muted =
 188       Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_query([user.ap_id], params)
 189       |> Pleroma.Pagination.fetch_paginated(params)
 190
 191     dms_without_muted =
 192       Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_query([user.ap_id], params)
 193       |> Pleroma.Pagination.fetch_paginated(Map.put(params, "with_muted", false))
 194
 195     Benchee.run(%{
 196       "Rendering dms with muted" => fn ->
 197         Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
 198           activities: dms_with_muted,
 199           for: user,
 200           as: :activity
 201         })
 202       end,
 203       "Rendering dms without muted" => fn ->
 204         Pleroma.Web.MastodonAPI.StatusView.render("index.json", %{
 205           activities: dms_without_muted,
 206           for: user,
 207           as: :activity
 208         })
 209       end
 210     })
 211   end
 212
 213   def query_long_thread(user, activity) do
 214     Benchee.run(%{
 215       "Fetch main post" => fn ->
 216         Pleroma.Activity.get_by_id_with_object(activity.id)
 217       end,
 218       "Fetch context of main post" => fn ->
 219         Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_for_context(
 220           activity.data["context"],
 221           %{
 222             "blocking_user" => user,
 223             "user" => user,
 224             "exclude_id" => activity.id
 225           }
 226         )
 227       end
 228     })
 229
 230     activity = Pleroma.Activity.get_by_id_with_object(activity.id)
 231
 232     context =
 233       Pleroma.Web.ActivityPub.ActivityPub.fetch_activities_for_context(
 234         activity.data["context"],
 235         %{
 236           "blocking_user" => user,
 237           "user" => user,
 238           "exclude_id" => activity.id
 239         }
 240       )
 241
 242     Benchee.run(%{
 243       "Render status" => fn ->
 244         Pleroma.Web.MastodonAPI.StatusView.render("show.json", %{
 245           activity: activity,
 246           for: user
 247         })
 248       end,
 249       "Render context" => fn ->
 250         Pleroma.Web.MastodonAPI.StatusView.render(
 251           "index.json",
 252           for: user,
 253           activities: context,
 254           as: :activity
 255         )
 256         |> Enum.reverse()
 257       end
 258     })
 259   end
 260 end