summaryrefslogtreecommitdiff
path: root/test/plugs/rate_limiter_test.exs
diff options
context:
space:
mode:
Diffstat (limited to 'test/plugs/rate_limiter_test.exs')
-rw-r--r--test/plugs/rate_limiter_test.exs263
1 files changed, 0 insertions, 263 deletions
diff --git a/test/plugs/rate_limiter_test.exs b/test/plugs/rate_limiter_test.exs
deleted file mode 100644
index 4d3d694f4..000000000
--- a/test/plugs/rate_limiter_test.exs
+++ /dev/null
@@ -1,263 +0,0 @@
-# Pleroma: A lightweight social networking server
-# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
-# SPDX-License-Identifier: AGPL-3.0-only
-
-defmodule Pleroma.Plugs.RateLimiterTest do
- use Pleroma.Web.ConnCase
-
- alias Phoenix.ConnTest
- alias Pleroma.Config
- alias Pleroma.Plugs.RateLimiter
- alias Plug.Conn
-
- import Pleroma.Factory
- import Pleroma.Tests.Helpers, only: [clear_config: 1, clear_config: 2]
-
- # Note: each example must work with separate buckets in order to prevent concurrency issues
- setup do: clear_config([Pleroma.Web.Endpoint, :http, :ip])
- setup do: clear_config(:rate_limit)
-
- describe "config" do
- @limiter_name :test_init
- setup do: clear_config([Pleroma.Plugs.RemoteIp, :enabled])
-
- test "config is required for plug to work" do
- Config.put([:rate_limit, @limiter_name], {1, 1})
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-
- assert %{limits: {1, 1}, name: :test_init, opts: [name: :test_init]} ==
- [name: @limiter_name]
- |> RateLimiter.init()
- |> RateLimiter.action_settings()
-
- assert nil ==
- [name: :nonexisting_limiter]
- |> RateLimiter.init()
- |> RateLimiter.action_settings()
- end
- end
-
- test "it is disabled if it remote ip plug is enabled but no remote ip is found" do
- assert RateLimiter.disabled?(Conn.assign(build_conn(), :remote_ip_found, false))
- end
-
- test "it is enabled if remote ip found" do
- refute RateLimiter.disabled?(Conn.assign(build_conn(), :remote_ip_found, true))
- end
-
- test "it is enabled if remote_ip_found flag doesn't exist" do
- refute RateLimiter.disabled?(build_conn())
- end
-
- test "it restricts based on config values" do
- limiter_name = :test_plug_opts
- scale = 80
- limit = 5
-
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
- Config.put([:rate_limit, limiter_name], {scale, limit})
-
- plug_opts = RateLimiter.init(name: limiter_name)
- conn = build_conn(:get, "/")
-
- for i <- 1..5 do
- conn = RateLimiter.call(conn, plug_opts)
- assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, plug_opts)
- Process.sleep(10)
- end
-
- conn = RateLimiter.call(conn, plug_opts)
- assert %{"error" => "Throttled"} = ConnTest.json_response(conn, :too_many_requests)
- assert conn.halted
-
- Process.sleep(50)
-
- conn = build_conn(:get, "/")
-
- conn = RateLimiter.call(conn, plug_opts)
- assert {1, 4} = RateLimiter.inspect_bucket(conn, limiter_name, plug_opts)
-
- refute conn.status == Conn.Status.code(:too_many_requests)
- refute conn.resp_body
- refute conn.halted
- end
-
- describe "options" do
- test "`bucket_name` option overrides default bucket name" do
- limiter_name = :test_bucket_name
-
- Config.put([:rate_limit, limiter_name], {1000, 5})
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-
- base_bucket_name = "#{limiter_name}:group1"
- plug_opts = RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name)
-
- conn = build_conn(:get, "/")
-
- RateLimiter.call(conn, plug_opts)
- assert {1, 4} = RateLimiter.inspect_bucket(conn, base_bucket_name, plug_opts)
- assert {:error, :not_found} = RateLimiter.inspect_bucket(conn, limiter_name, plug_opts)
- end
-
- test "`params` option allows different queries to be tracked independently" do
- limiter_name = :test_params
- Config.put([:rate_limit, limiter_name], {1000, 5})
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-
- plug_opts = RateLimiter.init(name: limiter_name, params: ["id"])
-
- conn = build_conn(:get, "/?id=1")
- conn = Conn.fetch_query_params(conn)
- conn_2 = build_conn(:get, "/?id=2")
-
- RateLimiter.call(conn, plug_opts)
- assert {1, 4} = RateLimiter.inspect_bucket(conn, limiter_name, plug_opts)
- assert {0, 5} = RateLimiter.inspect_bucket(conn_2, limiter_name, plug_opts)
- end
-
- test "it supports combination of options modifying bucket name" do
- limiter_name = :test_options_combo
- Config.put([:rate_limit, limiter_name], {1000, 5})
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-
- base_bucket_name = "#{limiter_name}:group1"
-
- plug_opts =
- RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name, params: ["id"])
-
- id = "100"
-
- conn = build_conn(:get, "/?id=#{id}")
- conn = Conn.fetch_query_params(conn)
- conn_2 = build_conn(:get, "/?id=#{101}")
-
- RateLimiter.call(conn, plug_opts)
- assert {1, 4} = RateLimiter.inspect_bucket(conn, base_bucket_name, plug_opts)
- assert {0, 5} = RateLimiter.inspect_bucket(conn_2, base_bucket_name, plug_opts)
- end
- end
-
- describe "unauthenticated users" do
- test "are restricted based on remote IP" do
- limiter_name = :test_unauthenticated
- Config.put([:rate_limit, limiter_name], [{1000, 5}, {1, 10}])
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-
- plug_opts = RateLimiter.init(name: limiter_name)
-
- conn = %{build_conn(:get, "/") | remote_ip: {127, 0, 0, 2}}
- conn_2 = %{build_conn(:get, "/") | remote_ip: {127, 0, 0, 3}}
-
- for i <- 1..5 do
- conn = RateLimiter.call(conn, plug_opts)
- assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, plug_opts)
- refute conn.halted
- end
-
- conn = RateLimiter.call(conn, plug_opts)
-
- assert %{"error" => "Throttled"} = ConnTest.json_response(conn, :too_many_requests)
- assert conn.halted
-
- conn_2 = RateLimiter.call(conn_2, plug_opts)
- assert {1, 4} = RateLimiter.inspect_bucket(conn_2, limiter_name, plug_opts)
-
- refute conn_2.status == Conn.Status.code(:too_many_requests)
- refute conn_2.resp_body
- refute conn_2.halted
- end
- end
-
- describe "authenticated users" do
- setup do
- Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)
-
- :ok
- end
-
- test "can have limits separate from unauthenticated connections" do
- limiter_name = :test_authenticated1
-
- scale = 50
- limit = 5
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
- Config.put([:rate_limit, limiter_name], [{1000, 1}, {scale, limit}])
-
- plug_opts = RateLimiter.init(name: limiter_name)
-
- user = insert(:user)
- conn = build_conn(:get, "/") |> assign(:user, user)
-
- for i <- 1..5 do
- conn = RateLimiter.call(conn, plug_opts)
- assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, plug_opts)
- refute conn.halted
- end
-
- conn = RateLimiter.call(conn, plug_opts)
-
- assert %{"error" => "Throttled"} = ConnTest.json_response(conn, :too_many_requests)
- assert conn.halted
- end
-
- test "different users are counted independently" do
- limiter_name = :test_authenticated2
- Config.put([:rate_limit, limiter_name], [{1, 10}, {1000, 5}])
- Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-
- plug_opts = RateLimiter.init(name: limiter_name)
-
- user = insert(:user)
- conn = build_conn(:get, "/") |> assign(:user, user)
-
- user_2 = insert(:user)
- conn_2 = build_conn(:get, "/") |> assign(:user, user_2)
-
- for i <- 1..5 do
- conn = RateLimiter.call(conn, plug_opts)
- assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, plug_opts)
- end
-
- conn = RateLimiter.call(conn, plug_opts)
- assert %{"error" => "Throttled"} = ConnTest.json_response(conn, :too_many_requests)
- assert conn.halted
-
- conn_2 = RateLimiter.call(conn_2, plug_opts)
- assert {1, 4} = RateLimiter.inspect_bucket(conn_2, limiter_name, plug_opts)
- refute conn_2.status == Conn.Status.code(:too_many_requests)
- refute conn_2.resp_body
- refute conn_2.halted
- end
- end
-
- test "doesn't crash due to a race condition when multiple requests are made at the same time and the bucket is not yet initialized" do
- limiter_name = :test_race_condition
- Pleroma.Config.put([:rate_limit, limiter_name], {1000, 5})
- Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
-
- opts = RateLimiter.init(name: limiter_name)
-
- conn = build_conn(:get, "/")
- conn_2 = build_conn(:get, "/")
-
- %Task{pid: pid1} =
- task1 =
- Task.async(fn ->
- receive do
- :process2_up ->
- RateLimiter.call(conn, opts)
- end
- end)
-
- task2 =
- Task.async(fn ->
- send(pid1, :process2_up)
- RateLimiter.call(conn_2, opts)
- end)
-
- Task.await(task1)
- Task.await(task2)
-
- refute {:err, :not_found} == RateLimiter.inspect_bucket(conn, limiter_name, opts)
- end
-end
generated by cgit v1.2.3 (git 2.44.0) at 2024-04-24 19:03:26 +0000