itsi 0.2.15 → 0.2.17

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

@@ -1,16 +1,14 @@
 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|
+        log_requests before: { format: "GET {path_and_query}", level: "INFO" }
+        get("/foo") do |r|
           r.ok "backend success. #{r.query_params["bar"]}"
-        }
+        end
       end,
       bind: backend_bind
     ) do
@@ -25,9 +23,9 @@ class TestProxy < Minitest::Test
             timeout: 30,
             tls_sni: false,
             error_response: "internal_server_error"
-          get("/foo") { |r|
+          get("/foo") do |r|
             r.ok "should not get here"
-          }
+          end
         end
       ) do
         res = get_resp("/foo?bar=baz")
@@ -60,11 +58,10 @@ class TestProxy < Minitest::Test
   end
 
   def test_overriding_headers
-
     backend_bind = free_bind
     server(
       itsi_rb: lambda do
-        log_requests before: { format: "GET {path_and_query}", level: "INFO"}
+        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
@@ -72,7 +69,6 @@ class TestProxy < Minitest::Test
       end,
       bind: backend_bind
     ) do
-
       # Start proxy server.
       server(
         itsi_rb: lambda do
@@ -96,278 +92,279 @@ class TestProxy < Minitest::Test
   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
+    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
+  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
+    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
+    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
+    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_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_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_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_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_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_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_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_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"
+  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
+  def test_failover_behavior # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
     # 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
+    Itsi::Server.start_in_background_thread(binds: [backend2_bind]) do
+      workers 1
       get("/failover") { |r| r.ok "backend2" }
     end
 
@@ -376,14 +373,13 @@ class TestProxy < Minitest::Test
     # # 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]],
+          backends: [backend1_bind[%r{//(.*)}, 1], backend2_bind[%r{//(.*)}, 1]],
           backend_priority: "ordered",
           headers: {},
           verify_ssl: false,
@@ -393,18 +389,16 @@ class TestProxy < Minitest::Test
         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
+      Itsi::Server.start_in_background_thread(binds: [backend1_bind]) do
+        workers 1
         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"

data/gems/server/test/options/ruby_thread_request_backlog_size.rb

@@ -12,9 +12,8 @@ class TestRubyThreadRequestBacklogSize < Minitest::Test
       end) do
       responses = 10.times.map{ Thread.new{ get_resp("/foo") } }.map(&:value)
 
-      assert_equal "ok", responses.first.body
-      assert_equal "200", responses.first.code
-      assert_equal "503", responses.last.code
+      assert responses.map(&:code).include?("200")
+      assert responses.map(&:code).include?("503")
     end
   end
 

data/lib/itsi/version.rb

@@ -1,3 +1,3 @@
 module Itsi
-  VERSION = '0.2.15'
+  VERSION = '0.2.17'
 end