git.squeep.com Git - akkoma/blob - test/plugs/rate_limiter_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Plugs.RateLimiterTest do
   6   use ExUnit.Case, async: true
   7   use Plug.Test
   8
   9   alias Pleroma.Plugs.RateLimiter
  10
  11   import Pleroma.Factory
  12
  13   # Note: each example must work with separate buckets in order to prevent concurrency issues
  14
  15   describe "config" do
  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})
  20
  21       assert %{limits: {1, 1}, name: :test_init, opts: [name: :test_init]} ==
  22                RateLimiter.init(name: limiter_name)
  23
  24       assert nil == RateLimiter.init(name: :foo)
  25     end
  26
  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)
  32
  33       assert RateLimiter.disabled?() == true
  34     end
  35
  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)
  41
  42       assert RateLimiter.disabled?() == true
  43     end
  44
  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)
  50
  51       assert RateLimiter.disabled?() == false
  52     end
  53
  54     test "it restricts based on config values" do
  55       limiter_name = :test_opts
  56       scale = 80
  57       limit = 5
  58
  59       Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
  60       Pleroma.Config.put([:rate_limit, limiter_name], {scale, limit})
  61
  62       opts = RateLimiter.init(name: limiter_name)
  63       conn = conn(:get, "/")
  64
  65       for i <- 1..5 do
  66         conn = RateLimiter.call(conn, opts)
  67         assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
  68         Process.sleep(10)
  69       end
  70
  71       conn = RateLimiter.call(conn, opts)
  72       assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
  73       assert conn.halted
  74
  75       Process.sleep(50)
  76
  77       conn = conn(:get, "/")
  78
  79       conn = RateLimiter.call(conn, opts)
  80       assert {1, 4} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
  81
  82       refute conn.status == Plug.Conn.Status.code(:too_many_requests)
  83       refute conn.resp_body
  84       refute conn.halted
  85     end
  86   end
  87
  88   describe "options" do
  89     test "`bucket_name` option overrides default bucket name" do
  90       limiter_name = :test_bucket_name
  91
  92       Pleroma.Config.put([:rate_limit, limiter_name], {1000, 5})
  93       Pleroma.Config.put([Pleroma.Web.Endpoint, :http, :ip], {8, 8, 8, 8})
  94
  95       base_bucket_name = "#{limiter_name}:group1"
  96       opts = RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name)
  97
  98       conn = conn(:get, "/")
  99
 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)
 103     end
 104
 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})
 109
 110       opts = RateLimiter.init(name: limiter_name, params: ["id"])
 111
 112       conn = conn(:get, "/?id=1")
 113       conn = Plug.Conn.fetch_query_params(conn)
 114       conn_2 = conn(:get, "/?id=2")
 115
 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)
 119     end
 120
 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})
 125
 126       base_bucket_name = "#{limiter_name}:group1"
 127       opts = RateLimiter.init(name: limiter_name, bucket_name: base_bucket_name, params: ["id"])
 128       id = "100"
 129
 130       conn = conn(:get, "/?id=#{id}")
 131       conn = Plug.Conn.fetch_query_params(conn)
 132       conn_2 = conn(:get, "/?id=#{101}")
 133
 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)
 137     end
 138   end
 139
 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})
 145
 146       opts = RateLimiter.init(name: limiter_name)
 147
 148       conn = %{conn(:get, "/") | remote_ip: {127, 0, 0, 2}}
 149       conn_2 = %{conn(:get, "/") | remote_ip: {127, 0, 0, 3}}
 150
 151       for i <- 1..5 do
 152         conn = RateLimiter.call(conn, opts)
 153         assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
 154         refute conn.halted
 155       end
 156
 157       conn = RateLimiter.call(conn, opts)
 158
 159       assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
 160       assert conn.halted
 161
 162       conn_2 = RateLimiter.call(conn_2, opts)
 163       assert {1, 4} = RateLimiter.inspect_bucket(conn_2, limiter_name, opts)
 164
 165       refute conn_2.status == Plug.Conn.Status.code(:too_many_requests)
 166       refute conn_2.resp_body
 167       refute conn_2.halted
 168     end
 169   end
 170
 171   describe "authenticated users" do
 172     setup do
 173       Ecto.Adapters.SQL.Sandbox.checkout(Pleroma.Repo)
 174
 175       :ok
 176     end
 177
 178     test "can have limits seperate from unauthenticated connections" do
 179       limiter_name = :test_authenticated
 180
 181       scale = 50
 182       limit = 5
 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}])
 185
 186       opts = RateLimiter.init(name: limiter_name)
 187
 188       user = insert(:user)
 189       conn = conn(:get, "/") |> assign(:user, user)
 190
 191       for i <- 1..5 do
 192         conn = RateLimiter.call(conn, opts)
 193         assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
 194         refute conn.halted
 195       end
 196
 197       conn = RateLimiter.call(conn, opts)
 198
 199       assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
 200       assert conn.halted
 201     end
 202
 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})
 207
 208       opts = RateLimiter.init(name: limiter_name)
 209
 210       user = insert(:user)
 211       conn = conn(:get, "/") |> assign(:user, user)
 212
 213       user_2 = insert(:user)
 214       conn_2 = conn(:get, "/") |> assign(:user, user_2)
 215
 216       for i <- 1..5 do
 217         conn = RateLimiter.call(conn, opts)
 218         assert {^i, _} = RateLimiter.inspect_bucket(conn, limiter_name, opts)
 219       end
 220
 221       conn = RateLimiter.call(conn, opts)
 222       assert %{"error" => "Throttled"} = Phoenix.ConnTest.json_response(conn, :too_many_requests)
 223       assert conn.halted
 224
 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
 229       refute conn_2.halted
 230     end
 231   end
 232 end