1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Plugs.RateLimiterTest do
6 use ExUnit.Case, async: true
9 alias Pleroma.Plugs.RateLimiter
11 import Pleroma.Factory
13 # Note: each example must work with separate buckets in order to prevent concurrency issues
16 test "config is required for plug to work" do
17 limiter_name = :test_init
18 Pleroma.Config.put([:rate_limit, limiter_name], {1, 1})
19 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
21 assert %{limits: {1, 1}, name: :test_init, opts: [name: :test_init]} ==
22 RateLimiter.init(name: limiter_name)
24 assert nil == RateLimiter.init(name: :foo)
27 test "it is disabled for localhost" do
28 limiter_name = :test_init
29 Pleroma.Config.put([:rate_limit, limiter_name], {1, 1})
30 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {127, 0, 0, 1})
31 Pleroma.Config.put([Pleroma.Plugs.RemoteIp, :enabled], false)
33 assert RateLimiter.disabled?() == true
36 test "it is disabled for socket" do
37 limiter_name = :test_init
38 Pleroma.Config.put([:rate_limit, limiter_name], {1, 1})
39 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {:local, "/path/to/pleroma.sock"})
40 Pleroma.Config.put([Pleroma.Plugs.RemoteIp, :enabled], false)
42 assert RateLimiter.disabled?() == true
45 test "it is enabled for socket when remote ip is enabled" do
46 limiter_name = :test_init
47 Pleroma.Config.put([:rate_limit, limiter_name], {1, 1})
48 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {:local, "/path/to/pleroma.sock"})
49 Pleroma.Config.put([Pleroma.Plugs.RemoteIp, :enabled], true)
51 assert RateLimiter.disabled?() == false
54 test "it restricts based on config values" do
55 limiter_name = :test_opts
59 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
60 Pleroma.Config.put([:rate_limit, limiter_name], {scale, limit})
62 opts = RateLimiter.init(name: limiter_name)
63 conn = conn(:get, "/")
66 conn = RateLimiter.call(conn, opts)
67 assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
71 conn = RateLimiter.call(conn, opts)
72 assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
77 conn = conn(:get, "/")
79 conn = RateLimiter.call(conn, opts)
80 assert {1, 4} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
82 refute conn.status == Plug.Conn.Status.code(:too_many_requests)
89 test "`bucket_name` option overrides default bucket name" do
90 limiter_name = :test_bucket_name
92 Pleroma.Config.put([:rate_limit, limiter_name], {1000, 5})
93 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
95 base_bucket_name = "#{limiter_name}:group1"
96 opts = RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name)
98 conn = conn(:get, "/")
100 RateLimiter.call(conn, opts)
101 assert {1, 4} = RateLimiter.inspect_bucket(conn, base_bucket_name, opts)
102 assert {:err, :not_found} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
105 test "`params` option allows different queries to be tracked independently" do
106 limiter_name = :test_params
107 Pleroma.Config.put([:rate_limit, limiter_name], {1000, 5})
108 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
110 opts = RateLimiter.init(name: limiter_name, params: ["id"])
112 conn = conn(:get, "/?id=1")
113 conn = Plug.Conn.fetch_query_params(conn)
114 conn_2 = conn(:get, "/?id=2")
116 RateLimiter.call(conn, opts)
117 assert {1, 4} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
118 assert {0, 5} = RateLimiter.inspect_bucket(conn_2, limiter_name, opts)
121 test "it supports combination of options modifying bucket name" do
122 limiter_name = :test_options_combo
123 Pleroma.Config.put([:rate_limit, limiter_name], {1000, 5})
124 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
126 base_bucket_name = "#{limiter_name}:group1"
127 opts = RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name, params: ["id"])
130 conn = conn(:get, "/?id=#{id}")
131 conn = Plug.Conn.fetch_query_params(conn)
132 conn_2 = conn(:get, "/?id=#{101}")
134 RateLimiter.call(conn, opts)
135 assert {1, 4} = RateLimiter.inspect_bucket(conn, base_bucket_name, opts)
136 assert {0, 5} = RateLimiter.inspect_bucket(conn_2, base_bucket_name, opts)
140 describe "unauthenticated users" do
141 test "are restricted based on remote IP" do
142 limiter_name = :test_unauthenticated
143 Pleroma.Config.put([:rate_limit, limiter_name], [{1000, 5}, {1, 10}])
144 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
146 opts = RateLimiter.init(name: limiter_name)
148 conn = %{conn(:get, "/") | remote_ip: {127, 0, 0, 2}}
149 conn_2 = %{conn(:get, "/") | remote_ip: {127, 0, 0, 3}}
152 conn = RateLimiter.call(conn, opts)
153 assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
157 conn = RateLimiter.call(conn, opts)
159 assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
162 conn_2 = RateLimiter.call(conn_2, opts)
163 assert {1, 4} = RateLimiter.inspect_bucket(conn_2, limiter_name, opts)
165 refute conn_2.status == Plug.Conn.Status.code(:too_many_requests)
166 refute conn_2.resp_body
171 describe "authenticated users" do
173 Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)
178 test "can have limits seperate from unauthenticated connections" do
179 limiter_name = :test_authenticated
183 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
184 Pleroma.Config.put([:rate_limit, limiter_name], [{1000, 1}, {scale, limit}])
186 opts = RateLimiter.init(name: limiter_name)
189 conn = conn(:get, "/") |> assign(:user, user)
192 conn = RateLimiter.call(conn, opts)
193 assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
197 conn = RateLimiter.call(conn, opts)
199 assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
203 test "diffrerent users are counted independently" do
204 limiter_name = :test_authenticated
205 Pleroma.Config.put([:rate_limit, limiter_name], [{1, 10}, {1000, 5}])
206 Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
208 opts = RateLimiter.init(name: limiter_name)
211 conn = conn(:get, "/") |> assign(:user, user)
213 user_2 = insert(:user)
214 conn_2 = conn(:get, "/") |> assign(:user, user_2)
217 conn = RateLimiter.call(conn, opts)
218 assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
221 conn = RateLimiter.call(conn, opts)
222 assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
225 conn_2 = RateLimiter.call(conn_2, opts)
226 assert {1, 4} = RateLimiter.inspect_bucket(conn_2, limiter_name, opts)
227 refute conn_2.status == Plug.Conn.Status.code(:too_many_requests)
228 refute conn_2.resp_body