1 defmodule Pleroma.LoadTesting.Generator do
2 use Pleroma.LoadTesting.Helper
3 alias Pleroma.Web.CommonAPI
5 def generate_like_activities(user, posts) do
6 count_likes = Kernel.trunc(length(posts) / 4)
7 IO.puts("Starting generating #{count_likes} like activities...")
12 Enum.take_random(posts, count_likes),
13 fn post -> {:ok, _, _} = CommonAPI.favorite(post.id, user) end,
20 IO.puts("Inserting like activities take #{to_sec(time)} sec.\n")
23 def generate_users(opts) do
24 IO.puts("Starting generating #{opts[:users_max]} users...")
25 {time, users} = :timer.tc(fn -> do_generate_users(opts) end)
27 IO.puts("Inserting users take #{to_sec(time)} sec.\n")
31 defp do_generate_users(opts) do
32 max = Keyword.get(opts, :users_max)
36 &generate_user_data(&1),
43 defp generate_user_data(i) do
44 remote = Enum.random([true, false])
47 name: "Test ใในใ User #{i}",
48 email: "user#{i}@example.com",
51 "$pbkdf2-sha512$160000$bU.OSFI7H/yqWb5DPEqyjw$uKp/2rmXw12QqnRRTqTtuk2DTwZfF8VR4MYW2xMeIlqPR/UX1nT1CEKVUx2CowFMZ5JON8aDvURrZpJjSgqXrg",
52 bio: "Tester Number #{i}",
59 Enum.random(["https://domain1.com", "https://domain2.com", "https://domain3.com"])
61 ap_id = "#{base_url}/users/#{user.nickname}"
65 follower_address: ap_id <> "/followers",
66 following_address: ap_id <> "/following"
70 ap_id: User.ap_id(user),
71 follower_address: User.ap_followers(user),
72 following_address: User.ap_following(user)
76 user = Map.merge(user, user_urls)
81 def generate_activities(user, users) do
82 do_generate_activities(user, users)
85 defp do_generate_activities(user, users) do
86 IO.puts("Starting generating 20000 common activities...")
93 do_generate_activity([user | users])
101 IO.puts("Inserting common activities take #{to_sec(time)} sec.\n")
103 IO.puts("Starting generating 20000 activities with mentions...")
110 do_generate_activity_with_mention(user, users)
118 IO.puts("Inserting activities with menthions take #{to_sec(time)} sec.\n")
120 IO.puts("Starting generating 10000 activities with threads...")
127 do_generate_threads([user | users])
135 IO.puts("Inserting activities with threads take #{to_sec(time)} sec.\n")
138 defp do_generate_activity(users) do
140 "status" => "Some status without mention with random user"
143 CommonAPI.post(Enum.random(users), post)
146 def generate_power_intervals(opts \\ []) do
147 count = Keyword.get(opts, :count, 20)
148 power = Keyword.get(opts, :power, 2)
149 IO.puts("Generating #{count} intervals for a power #{power} series...")
150 counts = Enum.map(1..count, fn n -> :math.pow(n, power) end)
151 sum = Enum.sum(counts)
154 Enum.map(counts, fn c ->
159 |> Enum.reduce(0, fn density, acc ->
163 [{_, lower} | _] = acc
164 [{lower, lower + density} | acc]
170 def generate_tagged_activities(opts \\ []) do
171 tag_count = Keyword.get(opts, :tag_count, 20)
172 users = Keyword.get(opts, :users, Repo.all(User))
173 activity_count = Keyword.get(opts, :count, 200_000)
175 intervals = generate_power_intervals(count: tag_count)
178 "Generating #{activity_count} activities using #{tag_count} different tags of format `tag_n`, starting at tag_0"
181 Enum.each(1..activity_count, fn _ ->
182 random = :rand.uniform()
183 i = Enum.find_index(intervals, fn {lower, upper} -> lower <= random && upper > random end)
184 CommonAPI.post(Enum.random(users), %{"status" => "a post with the tag #tag_#{i}"})
188 defp do_generate_activity_with_mention(user, users) do
189 mentions_cnt = Enum.random([2, 3, 4, 5])
190 with_user = Enum.random([true, false])
191 users = Enum.shuffle(users)
192 mentions_users = Enum.take(users, mentions_cnt)
193 mentions_users = if with_user, do: [user | mentions_users], else: mentions_users
196 Enum.map(mentions_users, fn user -> "@" <> user.nickname end) |> Enum.join(", ")
199 "status" => mentions_str <> "some status with mentions random users"
202 CommonAPI.post(Enum.random(users), post)
205 defp do_generate_threads(users) do
206 thread_length = Enum.random([2, 3, 4, 5])
207 actor = Enum.random(users)
210 "status" => "Start of the thread"
213 {:ok, activity} = CommonAPI.post(actor, post)
215 Enum.each(1..thread_length, fn _ ->
216 user = Enum.random(users)
219 "status" => "@#{actor.nickname} reply to thread",
220 "in_reply_to_status_id" => activity.id
223 CommonAPI.post(user, post)
227 def generate_remote_activities(user, users) do
228 do_generate_remote_activities(user, users)
231 defp do_generate_remote_activities(user, users) do
232 IO.puts("Starting generating 10000 remote activities...")
239 do_generate_remote_activity(i, user, users)
247 IO.puts("Inserting remote activities take #{to_sec(time)} sec.\n")
250 defp do_generate_remote_activity(i, user, users) do
251 actor = Enum.random(users)
252 %{host: host} = URI.parse(actor.ap_id)
253 date = Date.utc_today()
254 datetime = DateTime.utc_now()
257 "actor" => actor.ap_id,
258 "cc" => [actor.follower_address, user.ap_id],
259 "context" => "tag:mastodon.example.org,#{date}:objectId=#{i}:objectType=Conversation",
260 "id" => actor.ap_id <> "/statuses/#{i}/activity",
262 "actor" => actor.ap_id,
263 "atomUri" => actor.ap_id <> "/statuses/#{i}",
265 "attributedTo" => actor.ap_id,
268 "cc" => [actor.follower_address, user.ap_id],
270 "<p><span class=\"h-card\"><a href=\"" <>
272 "\" class=\"u-url mention\">@<span>" <> user.nickname <> "</span></a></span></p>",
273 "context" => "tag:mastodon.example.org,#{date}:objectId=#{i}:objectType=Conversation",
275 "tag:mastodon.example.org,#{date}:objectId=#{i}:objectType=Conversation",
277 "id" => actor.ap_id <> "/statuses/#{i}",
279 "inReplyToAtomUri" => nil,
280 "published" => datetime,
285 "href" => user.ap_id,
286 "name" => "@#{user.nickname}@#{host}",
290 "to" => ["https://www.w3.org/ns/activitystreams#Public"],
292 "url" => "http://#{host}/@#{actor.nickname}/#{i}"
294 "published" => datetime,
295 "to" => ["https://www.w3.org/ns/activitystreams#Public"],
299 Pleroma.Web.ActivityPub.ActivityPub.insert(map, false)
302 def generate_dms(user, users, opts) do
303 IO.puts("Starting generating #{opts[:dms_max]} DMs")
304 {time, _} = :timer.tc(fn -> do_generate_dms(user, users, opts) end)
305 IO.puts("Inserting dms take #{to_sec(time)} sec.\n")
308 defp do_generate_dms(user, users, opts) do
312 do_generate_dm(user, users)
320 defp do_generate_dm(user, users) do
322 "status" => "@#{user.nickname} some direct message",
323 "visibility" => "direct"
326 CommonAPI.post(Enum.random(users), post)
329 def generate_long_thread(user, users, opts) do
330 IO.puts("Starting generating long thread with #{opts[:thread_length]} replies")
331 {time, activity} = :timer.tc(fn -> do_generate_long_thread(user, users, opts) end)
332 IO.puts("Inserting long thread replies take #{to_sec(time)} sec.\n")
336 defp do_generate_long_thread(user, users, opts) do
337 {:ok, %{id: id} = activity} = CommonAPI.post(user, %{"status" => "Start of long thread"})
340 1..opts[:thread_length],
341 fn _ -> do_generate_thread(users, id) end,
350 defp do_generate_thread(users, activity_id) do
351 CommonAPI.post(Enum.random(users), %{
352 "status" => "reply to main post",
353 "in_reply_to_status_id" => activity_id
357 def generate_non_visible_message(user, users) do
358 IO.puts("Starting generating 1000 non visible posts")
362 do_generate_non_visible_posts(user, users)
365 IO.puts("Inserting non visible posts take #{to_sec(time)} sec.\n")
368 defp do_generate_non_visible_posts(user, users) do
369 [not_friend | users] = users
371 make_friends(user, users)
373 Task.async_stream(1..1000, fn _ -> do_generate_non_visible_post(not_friend, users) end,
380 defp make_friends(_user, []), do: nil
382 defp make_friends(user, [friend | users]) do
383 {:ok, _} = User.follow(user, friend)
384 {:ok, _} = User.follow(friend, user)
385 make_friends(user, users)
388 defp do_generate_non_visible_post(not_friend, users) do
390 "status" => "some non visible post",
391 "visibility" => "private"
394 {:ok, activity} = CommonAPI.post(not_friend, post)
396 thread_length = Enum.random([2, 3, 4, 5])
398 Enum.each(1..thread_length, fn _ ->
399 user = Enum.random(users)
402 "status" => "@#{not_friend.nickname} reply to non visible post",
403 "in_reply_to_status_id" => activity.id,
404 "visibility" => "private"
407 CommonAPI.post(user, post)