Add tests for LRU cache behavior in RouteHandler, ensuring eviction and caching logic works as expected

Author: sdogruyol

spec/route_handler_spec.cr

@@ -179,4 +179,114 @@ describe "Kemal::RouteHandler" do
     client_response.body.should eq("home page")
     client_response.headers.has_key?("Location").should eq(true)
   end
+
+  context "LRU cache" do
+    it "evicts least recently used entries instead of clearing entirely" do
+      # Use a small capacity to make the test fast and deterministic
+      small_capacity = 8
+      # Replace the cache instance with a smaller-capacity LRU for this test
+      Kemal::RouteHandler::INSTANCE.cached_routes = Kemal::LRUCache(String, Radix::Result(Kemal::Route)).new(small_capacity)
+
+      # Define more routes than capacity
+      0.upto(15) do |i|
+        get "/lru_eviction_#{i}" do
+          "ok"
+        end
+      end
+
+      # Access the first `small_capacity` routes to fill the cache
+      0.upto(small_capacity - 1) do |i|
+        Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_eviction_#{i}")
+      end
+
+      Kemal::RouteHandler::INSTANCE.cached_routes.size.should eq small_capacity
+
+      # Access some new routes to trigger eviction
+      small_capacity.upto(small_capacity + 3) do |i|
+        Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_eviction_#{i}")
+      end
+
+      # Cache should still be capped at capacity
+      Kemal::RouteHandler::INSTANCE.cached_routes.size.should eq small_capacity
+    end
+
+    it "retains recently used keys and evicts the least recently used" do
+      small_capacity = 4
+      Kemal::RouteHandler::INSTANCE.cached_routes = Kemal::LRUCache(String, Radix::Result(Kemal::Route)).new(small_capacity)
+
+      0.upto(5) do |i|
+        get "/lru_recency_#{i}" do
+          "ok"
+        end
+      end
+
+      # Fill cache with 0..3
+      0.upto(3) do |i|
+        Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_recency_#{i}")
+      end
+
+      # Touch 0 and 1 to make them most recent
+      [0, 1].each do |i|
+        Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_recency_#{i}")
+      end
+
+      # Insert 4 -> should evict least recent among {2,3}
+      Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_recency_4")
+
+      # Insert 5 -> should evict the other of {2,3}
+      Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_recency_5")
+
+      # Now 0 and 1 must still resolve from cache, and size is capped
+      Kemal::RouteHandler::INSTANCE.cached_routes.size.should eq small_capacity
+
+      # A fresh lookup for 0 and 1 should be cache hits and not raise
+      Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_recency_0").found?.should be_true
+      Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_recency_1").found?.should be_true
+    end
+
+    it "caches HEAD fallback GET lookups without growing beyond 1 for same path" do
+      cap = 16
+      Kemal::RouteHandler::INSTANCE.cached_routes = Kemal::LRUCache(String, Radix::Result(Kemal::Route)).new(cap)
+
+      get "/head_fallback" do
+        "ok"
+      end
+
+      # First HEAD should fallback to GET and cache one entry keyed by HEAD+path
+      Kemal::RouteHandler::INSTANCE.lookup_route("HEAD", "/head_fallback").found?.should be_true
+      Kemal::RouteHandler::INSTANCE.cached_routes.size.should eq 1
+
+      # Second HEAD lookup should be a cache hit; size must remain 1
+      Kemal::RouteHandler::INSTANCE.lookup_route("HEAD", "/head_fallback").found?.should be_true
+      Kemal::RouteHandler::INSTANCE.cached_routes.size.should eq 1
+    end
+
+    it "keeps size capped under heavy churn with large capacity" do
+      large_capacity = 4096
+      Kemal::RouteHandler::INSTANCE.cached_routes = Kemal::LRUCache(String, Radix::Result(Kemal::Route)).new(large_capacity)
+
+      0.upto(12000) do |i|
+        get "/lru_heavy_#{i}" do
+          "ok"
+        end
+      end
+
+      # Fill and churn beyond capacity
+      0.upto(11999) do |i|
+        Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_heavy_#{i}")
+      end
+
+      Kemal::RouteHandler::INSTANCE.cached_routes.size.should eq large_capacity
+
+      # Additional churn should not increase size
+      12000.upto(14000) do |i|
+        get "/lru_heavy_more_#{i}" do
+          "ok"
+        end
+        Kemal::RouteHandler::INSTANCE.lookup_route("GET", "/lru_heavy_more_#{i}")
+      end
+
+      Kemal::RouteHandler::INSTANCE.cached_routes.size.should eq large_capacity
+    end
+  end
 end

spec/spec_helper.cr

@@ -93,6 +93,6 @@ Spec.after_each do
   Kemal.config.clear
   Kemal::FilterHandler::INSTANCE.tree = Radix::Tree(Array(Kemal::FilterHandler::FilterBlock)).new
   Kemal::RouteHandler::INSTANCE.routes = Radix::Tree(Route).new
-  Kemal::RouteHandler::INSTANCE.cached_routes = Hash(String, Radix::Result(Route)).new
+  Kemal::RouteHandler::INSTANCE.cached_routes = Kemal::LRUCache(String, Radix::Result(Kemal::Route)).new(1024)
   Kemal::WebSocketHandler::INSTANCE.routes = Radix::Tree(WebSocket).new
 end