Test failing on eventual consistency

4 out of 10 (40%) left to reach consistency:
DeltaCrdt.get(config.crdt_name, {"project2", "#{Node.self()}"}) #=> {4, 1746007259}

Author: jyeshe

lib/lightning/rate_limiters.ex

@@ -25,11 +25,9 @@ defmodule Lightning.RateLimiters do
   defmodule Webhook do
     @moduledoc false
 
-    # Use ReplicatedRateLimiter instead
-    use Hammer,
-      backend: Hammer.ETS,
-      algorithm: :leaky_bucket,
-      table: :webhook_limiter
+    use ReplicatedRateLimiter,
+      default_capacity: 10,
+      default_refill: 2
   end
 
   @spec hit({:failure_email, String.t(), String.t()}) :: Mail.hit_result()
@@ -51,7 +49,9 @@ defmodule Lightning.RateLimiters do
     # 10 requests for a second, then 2 requests per second
     # Over a long enough period of time, this will allow 2 requests per second.
     # allow?("webhook_#{project_id}", 10, 2)
-    Webhook.hit(project_id, 2, 10)
+    # capacity and refill is by design a module attribute
+    # TODO: passing it here might eliminate the need for macro for easier maintainance
+    Webhook.allow?("webhook_#{project_id}")
   end
 
   def child_spec(opts) do

test/replicated_rate_limiter_test.exs

@@ -4,8 +4,8 @@ defmodule ReplicatedRateLimiterTest do
 
   defmodule CrdtEts do
     use ReplicatedRateLimiter,
-      default_capacity: 1_000,
-      default_refill: 200
+      default_capacity: 10,
+      default_refill: 2
   end
 
   defmodule AnotherRateLimiter do
@@ -17,50 +17,56 @@ defmodule ReplicatedRateLimiterTest do
 
     config = CrdtEts.config() |> Map.new()
 
-    # Test using the main module's allow? function
-    result = CrdtEts.allow?("test_key")
-    assert match?({:allow, 999}, result)
+    # Check one time (default cost is 1)
+    assert match?({:allow, 9}, CrdtEts.allow?("project1"))
 
     before = System.system_time(:second)
 
-    # Make several calls to hit the limit
-    Enum.each(1..10, fn _ -> CrdtEts.allow?("test_key_2", 5, 1) end)
+    # Make several calls to hit the limit (default capacity is 10)
+    Enum.each(1..9, fn _ -> CrdtEts.allow?("project2") end)
 
-    assert {0, last_updated} =
-             DeltaCrdt.get(config.crdt_name, {"test_key_2", "#{Node.self()}"}),
-           "CRDT should have 0 tokens"
+    assert_eventually(
+      DeltaCrdt.get(config.crdt_name, {"project2", "#{Node.self()}"}) |> dbg |> elem(0) == 0,
+      1_000
+    )
 
-    assert {0, ^last_updated} =
-             CrdtEts.to_list("test_key_2"),
+    assert {0, last_updated} =
+             CrdtEts.to_list("project2"),
            "ETS should be the same as CRDT"
 
     assert before <= last_updated
 
     # This should be denied since we consumed all tokens
-    assert {:deny, 1000} = CrdtEts.allow?("test_key_2", 5, 1)
+    assert {:deny, 1000} = CrdtEts.allow?("project2", 10, 2)
 
-    # Another node enters the dungeon
+    # Node2 enters the dungeon
     {:ok, test_crdt} =
       DeltaCrdt.start_link(DeltaCrdt.AWLWWMap)
 
     DeltaCrdt.set_neighbours(config.crdt_name, [test_crdt])
     DeltaCrdt.set_neighbours(test_crdt, [config.crdt_name])
 
-    # and updates the bucket
+    # a time has passed and the bucket is refilled by Node2
     DeltaCrdt.put(
       test_crdt,
-      {"test_key_2", "another_node"},
-      {10, System.system_time(:second) + 1}
+      {"project2", "another_node"},
+      {10, System.system_time(:second)}
     )
 
+    # Node2 consumes all the credits except one
+    Enum.each(1..9, fn i ->
+      DeltaCrdt.put(
+        test_crdt,
+        {"project2", "another_node"},
+        {10-i, System.system_time(:second)})
+    end)
+
     # Wait for the bucket to be updated
     assert_eventually(
-      CrdtEts.to_list("test_key_2")
-      |> Tuple.to_list()
-      |> List.first() == 10
+      CrdtEts.to_list("project2") |> elem(0) == 1
     )
 
-    assert {:allow, 4} = CrdtEts.allow?("test_key_2", 5, 1)
+    assert {:allow, 4} = CrdtEts.allow?("project2", 10, 2)
   end
 
   test "can start multiple rate limiters" do