itsi 0.1.19 → 0.2.2

data/gems/server/test/middleware/location.rb

@@ -0,0 +1,220 @@
+require_relative "../helpers/test_helper"
+
+class TestNestedLocation < Minitest::Test
+  # Tests that a nested block takes precedence over its parent block
+  def test_basic_nested_route
+    server(
+      itsi_rb: lambda do
+        # The outer location "/" applies to all routes.
+        location "/" do
+          # A nested location matching "/foo" with its own GET handler.
+          location "/foo" do
+            get("/bar") { |r| r.respond("From nested /foo/bar") }
+          end
+          # This GET handler is only hit if no nested location applies.
+          get("/bar") { |r| r.respond("From root /bar") }
+        end
+      end
+    ) do
+      res_nested = get_resp("/foo/bar")
+      assert_equal "From nested /foo/bar", res_nested.body
+
+      res_root = get_resp("/bar")
+      assert_equal "From root /bar", res_root.body
+    end
+  end
+
+  # Tests deep nesting where dynamic segments are used
+  def test_deeply_nested_route
+    server(
+      itsi_rb: lambda do
+        location "/v1" do
+          location "/users" do
+            # A nested capture for user id.
+            location "/:user_id" do
+              get("/profile") { |r, params| r.respond("User profile for v1/users/#{params[:user_id]}") }
+            end
+          end
+        end
+      end
+    ) do
+      res = get_resp("/v1/users/123/profile")
+      assert_equal "User profile for v1/users/123", res.body
+    end
+  end
+
+  # Tests that ordering of nested location blocks is honored. Only the first matching block should execute.
+  def test_nested_route_ordering
+    server(
+      itsi_rb: lambda do
+        location "/" do
+          location "/alpha" do
+            # This is the first nested match for "/alpha/beta"
+            location "/beta" do
+              get("/gamma") { |r| r.respond("Response from first nested /alpha/beta/gamma") }
+            end
+            # Though this block also matches "/alpha/beta", it should never be reached.
+            location "/beta" do
+              get("/gamma") { |r| r.respond("Response from second nested /alpha/beta/gamma") }
+            end
+          end
+          # This handler is defined on the outer level and is a fallback.
+          get("/alpha/beta/gamma") { |r| r.respond("Response from outer /alpha/beta/gamma") }
+        end
+      end
+    ) do
+      res = get_resp("/alpha/beta/gamma")
+      # According to the recursive matching rules, the first matching child (/alpha then /beta) is used.
+      assert_equal "Response from first nested /alpha/beta/gamma", res.body
+    end
+  end
+
+  # Tests multiple nested levels under a common outer location.
+  def test_multiple_nested_options
+    server(
+      itsi_rb: lambda do
+        location "/api" do
+          get("/status") { |r| r.respond("API Status from /api") }
+          location "/users" do
+            get("/list") { |r| r.respond("User List from /api/users") }
+            location "/:user_id" do
+              get("/details") { |r| r.respond("User Details from /api/users/:user_id") }
+            end
+          end
+        end
+      end
+    ) do
+      res_status = get_resp("/api/status")
+      assert_equal "API Status from /api", res_status.body
+
+      res_list = get_resp("/api/users/list")
+      assert_equal "User List from /api/users", res_list.body
+
+      res_details = get_resp("/api/users/42/details")
+      assert_equal "User Details from /api/users/:user_id", res_details.body
+    end
+  end
+
+  def test_dynamic_vs_wildcard_precedence
+     server(
+       itsi_rb: lambda do
+         location "/products" do
+           # This nested block should match when a numeric id is provided.
+           location "/:id([0-9]+)" do
+             get("/details") { |r| r.respond("Product details for numeric id") }
+           end
+           # Fallback handler for when the numeric match does not occur.
+           get("/details") { |r| r.respond("General product details") }
+         end
+       end
+     ) do
+       res_dynamic = get_resp("/products/123/details")
+       assert_equal "Product details for numeric id", res_dynamic.body
+
+       res_fallback = get_resp("/products/details")
+       assert_equal "General product details", res_fallback.body
+     end
+   end
+
+   # Test deep nesting with multiple dynamic segments (year, month, slug) versus a fallback archive route.
+   def test_multiple_dynamic_segments
+     server(
+       itsi_rb: lambda do
+         location "/blog" do
+           # Nested dynamic segments for a blog post.
+           location "/:year([0-9]{4})" do
+             location "/:month([0-9]{1,2})" do
+               location "/:slug" do
+                 get { |r, params| r.respond("Blog post: #{params[:year]}/#{params[:month]}/#{params[:slug]}") }
+               end
+             end
+           end
+           # Fallback route for blog archive.
+           get("/archive") { |r| r.respond("Blog archive") }
+         end
+       end
+     ) do
+       res_post = get_resp("/blog/2021/9/challenge-post")
+       assert_equal "Blog post: 2021/9/challenge-post", res_post.body
+
+       res_archive = get_resp("/blog/archive")
+       assert_equal "Blog archive", res_archive.body
+     end
+   end
+
+   # Test mixed static and dynamic segments. The static route should override the dynamic one for an exact match.
+   def test_static_vs_dynamic_precedence
+     server(
+       itsi_rb: lambda do
+         location "/dashboard" do
+           # Static route for settings.
+           location "/settings" do
+             get { |r| r.respond("Dashboard settings") }
+           end
+           # Dynamic route for other sections.
+           location "/:section" do
+             get { |r, params| r.respond("Dashboard section: #{params[:section]}") }
+           end
+         end
+       end
+     ) do
+       res_static = get_resp("/dashboard/settings")
+       assert_equal "Dashboard settings", res_static.body
+
+       res_dynamic = get_resp("/dashboard/stats")
+       assert_equal "Dashboard section: stats", res_dynamic.body
+     end
+   end
+
+   # Test overlapping regex-based routing versus a fallback dynamic match.
+   def test_overlapping_regex_and_fallback
+     server(
+       itsi_rb: lambda do
+         location "/files" do
+           # This nested location will match when the filename ends with .txt.
+           location "/:filename([a-z]+\.txt)" do
+             get { |r, params| r.respond("Text file: #{params[:filename]}") }
+           end
+           # Fallback for any file that doesn't match the above regex.
+           location "/:filename" do
+             get { |r, params| r.respond("Other file: #{params[:filename]}") }
+           end
+         end
+       end
+     ) do
+       res_txt = get_resp("/files/readme.txt")
+       assert_equal "Text file: readme.txt", res_txt.body
+
+       res_other = get_resp("/files/readme.pdf")
+       assert_equal "Other file: readme.pdf", res_other.body
+     end
+   end
+
+   # Test a deeper nested structure that mimics a versioned API with sub-resources.
+   def test_complex_nested_structure
+     server(
+       itsi_rb: lambda do
+         location "/api" do
+           location "/v1" do
+             location "/users" do
+               location "/:user_id" do
+                 location "/profile" do
+                   get("/") { |r, params| r.respond("User Profile for #{r.params[:user_id]}") }
+                 end
+                 location "/orders" do
+                   get("/") { |r, params| r.respond("User Orders for #{r.params[:user_id]}") }
+                 end
+               end
+             end
+           end
+         end
+       end
+     ) do
+       res_profile = get_resp("/api/v1/users/42/profile")
+       assert_equal "User Profile for 42", res_profile.body
+
+       res_orders = get_resp("/api/v1/users/42/orders")
+       assert_equal "User Orders for 42", res_orders.body
+     end
+   end
+end

data/gems/server/test/middleware/max_body.rb

@@ -0,0 +1,20 @@
+require_relative "../helpers/test_helper"
+
+class TestMaxBody < Minitest::Test
+  def test_max_body_enforced
+    server(
+      itsi_rb: lambda do
+        max_body limit_bytes: 20
+        post("/") { |r|
+          r.ok "OK"
+        }
+      end
+    ) do
+      small = "a" * 10
+      large = "b" * 100
+
+      assert_equal "200", post("/", small).code
+      assert_equal "413", post("/", large).code
+    end
+  end
+end

data/gems/server/test/middleware/proxy.rb

@@ -0,0 +1,415 @@
+require_relative "../helpers/test_helper"
+
+class TestProxy < Minitest::Test
+
+  def test_successful_forwarding
+
+    backend_bind = free_bind
+    server(
+      itsi_rb: lambda do
+        log_requests before: { format: "GET {path_and_query}", level: "INFO"}
+        get("/foo") { |r|
+          r.ok "backend success. #{r.query_params["bar"]}"
+        }
+      end,
+      bind: backend_bind
+    ) do
+      server(
+        itsi_rb: lambda do
+          proxy \
+            to: "#{backend_bind}{path_and_query}",
+            backends: ["#{backend_bind}"],
+            backend_priority: "round_robin",
+            headers: {},
+            verify_ssl: false,
+            timeout: 30,
+            tls_sni: false,
+            error_response: "internal_server_error"
+          get("/foo") { |r|
+            r.ok "should not get here"
+          }
+        end
+      ) do
+        res = get_resp("/foo?bar=baz")
+        # Expect that the proxy forwards the request to the backend.
+        assert_equal "200", res.code, "Expected success status from backend"
+        assert_equal "backend success. baz", res.body
+      end
+    end
+  end
+
+  # Test that an invalid target URL (i.e. an unparseable URL) yields an error response.
+  def test_invalid_target_url_returns_error
+    server(
+      itsi_rb: lambda do
+        proxy \
+          to: "not_a_valid_url",
+          backends: ["127.0.0.1:3001"],
+          backend_priority: "round_robin",
+          headers: {},
+          verify_ssl: false,
+          timeout: 30,
+          tls_sni: false,
+          error_response: "bad_gateway"
+        get("/foo") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert_equal "502", res.code, "Expected error response code 502 for invalid URL"
+    end
+  end
+
+  def test_overriding_headers
+
+    backend_bind = free_bind
+    server(
+      itsi_rb: lambda do
+        log_requests before: { format: "GET {path_and_query}", level: "INFO"}
+        get("/header-test") do |r|
+          # Return the incoming header value.
+          r.ok r.header("X-Forwarded-For").first
+        end
+      end,
+      bind: backend_bind
+    ) do
+
+      # Start proxy server.
+      server(
+        itsi_rb: lambda do
+          proxy \
+            to: "#{backend_bind}{path}{query}",
+            backends: ["#{backend_bind}"],
+            backend_priority: "round_robin",
+            headers: { "X-Forwarded-For" => "{addr}" },
+            verify_ssl: false,
+            timeout: 30,
+            tls_sni: false,
+            error_response: "internal_server_error"
+          get("/header-test") { |r| r.ok "should not get here" }
+        end
+      ) do
+        res = get_resp("/header-test")
+        # Expect that the overriding header "X-Forwarded-For" is set to the client’s address.
+        assert_equal "127.0.0.1", res.body, "Expected the header to be set to the client address"
+      end
+    end
+  end
+
+  def test_proxy_with_static_to_only
+     backend_bind = free_bind
+     server(
+       itsi_rb: lambda do
+         get("/static") { |r| r.ok "static response" }
+       end,
+       bind: backend_bind
+     ) do
+       server(
+         itsi_rb: lambda do
+           proxy \
+             to: "#{backend_bind}{path}{query}",
+             backend_priority: "round_robin",
+             headers: {},
+             verify_ssl: false,
+             timeout: 30,
+             tls_sni: false,
+             error_response: "internal_server_error"
+           get("/static") { |r| r.ok "should not get here" }
+         end
+       ) do
+         res = get_resp("/static")
+         assert_equal "200", res.code, "Expected success status from static 'to' URL"
+         assert_equal "static response", res.body
+       end
+     end
+   end
+
+   def test_proxy_with_backend_host_override
+     backend_bind1 = free_bind
+     backend_bind2 = free_bind
+     # Start two dummy backends that respond with their Host header.
+     thread1 = Thread.new do
+       server(
+         itsi_rb: lambda do
+           get("/host-test") { |r| r.ok r.header("Host").first }
+         end,
+         bind: backend_bind1
+       ){ sleep 1 }
+     end
+     thread2 = Thread.new do
+       server(
+         itsi_rb: lambda do
+           get("/host-test") { |r| r.ok r.header("Host").first }
+         end,
+         bind: backend_bind2
+       ){ sleep 1 }
+     end
+
+     sleep 0.1
+
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "#{backend_bind1}{path}{query}",
+           backends: ["#{backend_bind1}", "#{backend_bind2}"],
+           backend_priority: "round_robin",
+           headers: { "Host" => "custom.backend.example.com" },
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: true,
+           error_response: "internal_server_error"
+         get("/host-test") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/host-test")
+       assert_equal "200", res.code, "Expected successful response with host override"
+       assert_equal "custom.backend.example.com", res.body, "Expected the Host header to be overridden"
+     end
+
+     thread1.kill
+     thread2.kill
+   end
+
+   def test_proxy_timeout
+     backend_bind = free_bind
+     # Start a backend server that sleeps for 1 second before responding.
+     server(
+       itsi_rb: lambda do
+         get("/slow") do |r|
+           sleep 1
+           r.ok "delayed response"
+         end
+       end,
+       bind: backend_bind
+     ) do
+       server(
+         itsi_rb: lambda do
+           # Set a very short timeout (0 seconds) to force a timeout.
+           proxy \
+             to: "#{backend_bind}{path}{query}",
+             backends: ["#{backend_bind}"],
+             backend_priority: "round_robin",
+             headers: {},
+             verify_ssl: false,
+             timeout: 0,
+             tls_sni: false,
+             error_response: "gateway_timeout"
+           get("/slow") { |r| r.ok "should not get here" }
+         end
+       ) do
+         res = get_resp("/slow")
+         assert_equal "504", res.code, "Expected 504 Gateway Timeout when backend response exceeds timeout"
+       end
+     end
+   end
+
+   def test_error_response_internal_server_error
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "internal_server_error"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "500", res.code, "Expected error response code 500 for internal_server_error"
+     end
+   end
+
+   def test_error_response_not_found
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "not_found"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "404", res.code, "Expected error response code 404 for not_found"
+     end
+   end
+
+   def test_error_response_unauthorized
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "unauthorized"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "401", res.code, "Expected error response code 401 for unauthorized"
+     end
+   end
+
+   def test_error_response_forbidden
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "forbidden"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "403", res.code, "Expected error response code 403 for forbidden"
+     end
+   end
+
+   def test_error_response_payload_too_large
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "payload_too_large"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "413", res.code, "Expected error response code 413 for payload_too_large"
+     end
+   end
+
+   def test_error_response_too_many_requests
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "too_many_requests"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "429", res.code, "Expected error response code 429 for too_many_requests"
+     end
+   end
+
+   def test_error_response_service_unavailable
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "service_unavailable"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "503", res.code, "Expected error response code 503 for service_unavailable"
+     end
+   end
+
+   def test_error_response_gateway_timeout
+     server(
+       itsi_rb: lambda do
+         proxy \
+           to: "invalid_url",
+           backends: ["127.0.0.1:3001"],
+           backend_priority: "round_robin",
+           headers: {},
+           verify_ssl: false,
+           timeout: 30,
+           tls_sni: false,
+           error_response: "gateway_timeout"
+         get("/foo") { |r| r.ok "should not get here" }
+       end
+     ) do
+       res = get_resp("/foo")
+       assert_equal "504", res.code, "Expected error response code 504 for gateway_timeout"
+    end
+  end
+
+  def test_failover_behavior
+    # Obtain two free bind addresses for backend servers.
+    backend1_bind = free_bind
+    backend2_bind = free_bind
+
+    backend2_server = Itsi::Server.start_in_background_thread(binds: [backend2_bind]) do
+      get("/failover") { |r| r.ok "backend2" }
+    end
+
+    # backend2_server.stop
+
+    # # Allow the backend servers to start.
+    sleep 0.2
+
+
+    # Start the proxy server with an ordered backend selection.
+    server(
+      cleanup: false,
+      itsi_rb: lambda do
+        proxy \
+          to: "http://proxied_host.com{path}{query}",
+          backends:  [backend1_bind[/\/\/(.*)/,1], backend2_bind[/\/\/(.*)/,1]],
+          backend_priority: "ordered",
+          headers: {},
+          verify_ssl: false,
+          timeout: 30,
+          tls_sni: false,
+          error_response: "internal_server_error"
+        get("/failover") { |r| r.ok "should not get here" }
+      end
+    ) do
+
+
+      res = get_resp("/failover")
+      assert_equal "200", res.code, "Expected success when fallback backend is available"
+      assert_equal "backend2", res.body, "Expected response from backend2"
+
+      backend1_server = Itsi::Server.start_in_background_thread(binds: [backend1_bind]) do
+        get("/failover") { |r| r.ok "backend1" }
+      end
+
+      sleep 1
+
+      res = get_resp("/failover")
+      assert_equal "200", res.code, "Expected reversion when primary becomes available"
+      assert_equal "backend1", res.body, "Expected response from backend1 with ordered priority"
+    end
+
+    Itsi::Server.stop_background_threads
+  end
+end