itsi 0.1.19 → 0.2.2

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

@@ -0,0 +1,374 @@
+require_relative "../helpers/test_helper"
+require "tmpdir"
+
+class TestStaticAssets < Minitest::Test
+    # Test serving an existing file via GET.
+  def test_serving_existing_file
+    Dir.mktmpdir do |dir|
+      file_path = File.join(dir, "test.txt")
+      File.write(file_path, "Hello world")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            headers: { "Cache-Control" => "max-age=3600" },
+            allowed_extensions: ["txt"]
+
+          get("/test.txt") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/test.txt")
+        assert_equal "200", res.code, "Expected 200 OK for an existing file"
+        assert_equal "Hello world", res.body
+        assert_match /max-age=3600/, res["Cache-Control"]
+      end
+    end
+  end
+
+  # Test HEAD request returns headers with no body.
+  def test_head_request
+    Dir.mktmpdir do |dir|
+      file_path = File.join(dir, "test.txt")
+      File.write(file_path, "Hello world")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            allowed_extensions: ["txt"]
+
+          get("/test.txt") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = head("/test.txt")
+        assert_equal "200", res.code, "Expected 200 OK for HEAD request"
+        assert(res.body.nil? || res.body.empty?, "Expected empty body for HEAD request")
+      end
+    end
+  end
+
+  # Test that non-GET/HEAD requests are not handled by static asset middleware.
+  def test_non_get_head_request_passes_through
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "test.txt"), "Hello world")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            allowed_extensions: ["txt"]
+
+          endpoint { |r| r.ok "fallback" }
+        end
+      ) do
+        res = post("/test.txt","")
+        # Since POST is not handled by static assets, expect the fallback.
+        assert_equal "200", res.code, "Expected fallback response for non-GET/HEAD request"
+        assert_equal "fallback", res.body
+      end
+    end
+  end
+
+  # Test try_html_extension: If "test.html" exists, a request to "/test" returns its content.
+  def test_try_html_extension
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "test.html"), "HTML content")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            try_html_extension: true,
+            allowed_extensions: ["html"]
+
+          get("/test") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/test")
+        assert_equal "200", res.code, "Expected 200 OK with try_html_extension"
+        assert_equal "HTML content", res.body
+      end
+    end
+  end
+
+  # Test a Range request for partial content.
+  def test_range_request
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "test.txt"), "Hello world")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            allowed_extensions: ["txt"]
+
+          get("/test.txt") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/test.txt", { "Range" => "bytes=0-4" })
+        # Expecting 206 Partial Content with "Hello" as the body.
+        assert_equal "206", res.code, "Expected 206 Partial Content for valid Range request"
+        assert_equal "Hello", res.body
+      end
+    end
+  end
+
+  # Test that a non-existent file passes through to the fallback handler.
+  def test_file_not_found_passes_through
+    Dir.mktmpdir do |dir|
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            allowed_extensions: ["txt"]
+
+          get("/nonexistent") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/nonexistent")
+        assert_equal "200", res.code, "Expected fallback response for non-existent file"
+        assert_equal "fallback", res.body
+      end
+    end
+  end
+  def test_relative_path_true
+    Dir.mktmpdir do |dir|
+      # Create file "test.txt" in root_dir.
+      dir = FileUtils.mkdir_p(File.join(dir, "foo", "bar", "baz")).first
+      file_path = File.join(dir, "test.txt")
+      File.write(file_path, "relative true")
+      server(
+        itsi_rb: lambda do
+          location "foo/bar/baz" do
+            static_assets \
+              root_dir: "#{dir}",
+              not_found_behavior: "fallthrough",
+              allowed_extensions: ["txt"],
+              relative_path: true
+
+            get("/foo/bar/baz/test.txt") { |r| r.ok "fallback" }
+          end
+        end
+      ) do
+        res = get_resp("/foo/bar/baz/test.txt")
+        assert_equal "200", res.code, "Expected 200 OK with relative_path: true"
+        assert_equal "relative true", res.body
+      end
+    end
+  end
+
+  def test_relative_path_false
+    Dir.mktmpdir do |dir|
+      # Create file "test.txt" in root_dir.
+      child_dir = FileUtils.mkdir_p(File.join(dir, "foo", "bar", "baz")).first
+      file_path = File.join(child_dir, "test.txt")
+
+      File.write(file_path, "relative false")
+      server(
+        itsi_rb: lambda do
+
+          location "/foo/bar/baz/" do
+            static_assets \
+              root_dir: "#{dir}",
+              not_found_behavior: "fallthrough",
+              allowed_extensions: ["txt"],
+              relative_path: false
+
+            get("/foo/bar/baz/test.txt") { |r| r.ok "fallback" }
+          end
+        end
+      ) do
+        res = get_resp("/foo/bar/baz/test.txt")
+
+        assert_equal "200", res.code, "Expected 200 OK with relative_path: false"
+        assert_equal "relative false", res.body
+      end
+    end
+  end
+
+  # 2. Allowed Extensions Test
+  def test_file_not_in_allowed_extensions
+    Dir.mktmpdir do |dir|
+      file_path = File.join(dir, "file.xyz")
+      File.write(file_path, "not allowed")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            allowed_extensions: ["txt"]
+          get("/file.xyz") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/file.xyz")
+        assert_equal "200", res.code, "Expected fallback when file extension is not allowed"
+        assert_equal "fallback", res.body
+      end
+    end
+  end
+
+  def test_hidden_files_not_served_when_disabled
+    Dir.mktmpdir do |dir|
+      file_path = File.join(dir, ".secret.txt")
+      File.write(file_path, "hidden content")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough"
+          endpoint { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/.secret.txt")
+
+        assert_equal "200", res.code, "Expected fallback when hidden files are disabled"
+        assert_equal "fallback", res.body
+      end
+    end
+  end
+
+  def test_hidden_files_served_when_enabled
+    Dir.mktmpdir do |dir|
+      file_path = File.join(dir, ".secret.txt")
+      File.write(file_path, "hidden content")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            allowed_extensions: ["txt"],
+            serve_hidden_files: true
+          get("/.secret.txt") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/.secret.txt")
+        assert_equal "200", res.code, "Expected 200 OK when hidden files are enabled"
+        assert_equal "hidden content", res.body
+      end
+    end
+  end
+
+  # 4. Auto Index Tests
+  def test_auto_index_json
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "file1.txt"), "content1")
+      File.write(File.join(dir, "file2.txt"), "content2")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            auto_index: true,
+            allowed_extensions: []
+          get("/") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/", { "Accept" => "application/json" })
+
+        assert_equal "200", res.code, "Expected 200 OK for JSON auto index"
+        assert_includes res.body, "[", "Expected JSON listing in auto index"
+      end
+    end
+  end
+
+  def test_auto_index_html
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, "file1.txt"), "content1")
+      File.write(File.join(dir, "file2.txt"), "content2")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: "fallthrough",
+            auto_index: true,
+            allowed_extensions: []
+          get("/") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/", { "Accept" => "text/html" })
+        assert_equal "200", res.code, "Expected 200 OK for HTML auto index"
+        assert_includes res.body.downcase, "<html", "Expected HTML structure in auto index"
+      end
+    end
+  end
+
+  # 5. Not Found Behavior Tests
+  def test_not_found_behavior_index
+    Dir.mktmpdir do |dir|
+      # Create an index file to be used as fallback.
+      File.write(File.join(dir, "index.html"), "SPA Index")
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: { index: "index.html" },
+            allowed_extensions: ["html"]
+          get("/nonexistent") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/nonexistent")
+        assert_equal "200", res.code, "Expected index to be served for index not found behaviour"
+        assert_equal "SPA Index", res.body
+      end
+    end
+  end
+
+  def test_not_found_behavior_redirect
+    Dir.mktmpdir do |dir|
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: { redirect: { to: "https://example.com", type: "permanent" } }
+          get("/nonexistent") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/nonexistent")
+        assert_equal "308", res.code, "Expected 308 for redirect not found behaviour"
+        assert_equal "https://example.com", res["Location"]
+      end
+    end
+  end
+
+  def test_not_found_behavior_error_builtin
+    Dir.mktmpdir do |dir|
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: {error: "not_found"}
+          get("/nonexistent") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/nonexistent")
+        assert_equal "404", res.code, "Expected 404 for built-in not_found behaviour"
+      end
+    end
+  end
+
+  def test_not_found_behavior_custom_error
+    Dir.mktmpdir do |dir|
+      server(
+        itsi_rb: lambda do
+          static_assets \
+            root_dir: "#{dir}",
+            not_found_behavior: {
+              error: {
+                code: 404,
+                plaintext: { inline: "Not Found" },
+                html: { inline: "<h1>Not Found</h1>" },
+                default: "plaintext"
+              },
+            }
+          get("/nonexistent") { |r| r.ok "fallback" }
+        end
+      ) do
+        res = get_resp("/nonexistent")
+        assert_equal "404", res.code, "Expected 404 for custom not_found behaviour"
+        assert_equal "Not Found", res.body
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# test_static_response.rb
+require_relative "../helpers/test_helper"
+
+class TestStaticResponse < Minitest::Test
+  def test_basic_response_code_and_body
+    server(
+      itsi_rb: lambda do
+        static_response \
+          code: 204,
+          headers: [],
+          body: ""
+      end
+    ) do
+      res = get_resp("/any")
+      assert_equal "204", res.code
+      assert_nil   res.body   # 204 should have no body
+    end
+  end
+
+  def test_custom_headers_and_body
+    server(
+      itsi_rb: lambda do
+        static_response \
+          code: 418,
+          headers: [
+            ["Content-Type","text/teapot"],
+            ["X-Test","value"]
+          ],
+          body:    "I'm a teapot"
+      end
+    ) do
+      res = get_resp("/brew")
+      assert_equal "418", res.code
+      assert_equal "text/teapot", res["Content-Type"]
+      assert_equal "value",        res["X-Test"]
+      assert_equal "I'm a teapot", res.body
+    end
+  end
+
+  def test_binary_body
+    data = [0x00,0xFF,0x7F]
+    server(
+      itsi_rb: lambda do
+        static_response \
+          code: 200,
+          headers: [["Content-Type","application/octet-stream"]],
+          body:    data.pack("C*")
+      end
+    ) do
+      res = get_resp("/bin")
+      # Ensure raw bytes round‑trip
+      assert_equal data.pack("C*"), res.body
+      assert_equal "application/octet-stream", res["Content-Type"]
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+require_relative "../helpers/test_helper"
+
+class TestStringRewrite < Minitest::Test
+
+  def test_interpolates_method
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://example.com/{method}/redirect", type: "temporary"
+        get("/foo") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert_equal "307", res.code, "Expected status 307 for temporary redirect"
+      assert_equal "https://example.com/GET/redirect", res["Location"]
+    end
+  end
+
+  def test_interpolates_path
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://example.com{path}", type: "found"
+        get("/bar") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/bar")
+      assert_equal "302", res.code, "Expected status 302 for found redirect"
+      assert_equal "https://example.com/bar", res["Location"]
+    end
+  end
+
+  def test_interpolates_addr
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://{addr}/redirect", type: "moved_permanently"
+        get("/foo") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert_equal "301", res.code, "Expected status 301 for moved permanently redirect"
+      # In tests, the context's address is typically set to "127.0.0.1"
+      assert_equal "https://127.0.0.1/redirect", res["Location"]
+    end
+  end
+
+  def test_interpolates_host
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://{host}/", type: "permanent"
+        get("/foo") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert_equal "308", res.code, "Expected status 308 for permanent redirect"
+      # When no host is explicitly specified in the URL, it defaults to "localhost"
+      assert_equal "https://localhost/", res["Location"]
+    end
+  end
+
+  def test_interpolates_path_and_query
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://example.com{path_and_query}", type: "temporary"
+        get("/foo") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo?bar=baz")
+      assert_equal "307", res.code, "Expected status 307 for temporary redirect"
+      assert_equal "https://example.com/foo?bar=baz", res["Location"]
+    end
+  end
+
+  def test_interpolates_query
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://example.com{query}", type: "found"
+        get("/foo?x=y") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo?x=y")
+      assert_equal "302", res.code, "Expected status 302 for found redirect"
+      assert_equal "https://example.com?x=y", res["Location"]
+    end
+  end
+
+  def test_interpolates_port
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://example.com:{port}/", type: "moved_permanently"
+        # We assume that if no port is provided in the request URI, it defaults to "80"
+        get("/foo") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert_equal "301", res.code, "Expected status 301 for moved permanently redirect"
+      assert_equal "https://example.com:80/", res["Location"]
+    end
+  end
+
+  def test_unknown_placeholder_remains_unmodified
+    server(
+      itsi_rb: lambda do
+        redirect to: "https://example.com/{unknown}", type: "permanent"
+        get("/foo") { |r| r.ok "should not get here" }
+      end
+    ) do
+      res = get_resp("/foo")
+      # The unknown placeholder is not substituted and remains as '{unknown}'.
+      assert_equal "308", res.code, "Expected status 308 for permanent redirect"
+      assert_equal "https://example.com/{unknown}", res["Location"]
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+require_relative "../helpers/test_helper"
+
+class TestLogRequests < Minitest::Test
+
+  def test_it_supports_logging_before_requests
+
+  end
+
+  def test_it_supports_logging_after_requests
+
+  end
+
+  def test_it_supports_configuring_log_level
+
+  end
+
+end

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

@@ -0,0 +1,47 @@
+require_relative "../helpers/test_helper"
+
+class TestBind < Minitest::Test
+  def test_http
+    server(
+      app: lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, ["Hello, World!"]]
+    end) do
+      assert_equal "Hello, World!", get("/")
+    end
+  end
+
+
+  def test_https
+    server(app: lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, ["Hello, HTTPS!"]]
+    end, protocol: "https") do |uri|
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true,
+                                                          verify_mode: OpenSSL::SSL::VERIFY_NONE) do |http|
+        http.request(Net::HTTP::Get.new("/"))
+      end
+      assert_equal "200", response.code
+      assert_equal "Hello, HTTPS!", response.body
+    end
+  end
+
+  def test_unix_socket_http
+    server(
+      bind: free_bind("http", unix_socket: true),
+      app: lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, ["Hello, World!"]]
+    end) do
+      assert_equal "Hello, World!", get("/")
+    end
+  end
+
+  def test_unix_socket_https
+    server(
+      bind: free_bind("http", unix_socket: true),
+      app: lambda do |env|
+      [200, { "Content-Type" => "text/plain" }, ["Hello, World!"]]
+    end) do
+      assert_equal "Hello, World!", get("/")
+    end
+  end
+
+end

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

@@ -0,0 +1,23 @@
+require_relative "../helpers/test_helper"
+
+class TestHeaderReadTimeout < Minitest::Test
+  def test_header_timeout_enforced
+    server(
+      itsi_rb: lambda do
+        header_read_timeout 0.1
+        get("/") { |r| r.ok "hi" }
+      end
+    ) do
+      socket = TCPSocket.new("127.0.0.1", @uri.port)
+      socket.write("GET / HTTP/1.1\r\nHost: localhost\r\n") # don’t send \r\n\r\n
+
+      sleep 0.2 # exceed header timeout
+      socket.write("\r\n\r\n")
+      response = socket.read
+    rescue StandardError => e
+      assert_equal e.class, Errno::ECONNRESET
+    ensure
+      socket&.close
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require_relative "../helpers/test_helper"
+
+class TestRequestTimeout < Minitest::Test
+  def test_request_timeout_applies
+    server(
+      itsi_rb: lambda do
+        workers 3
+        request_timeout 0.1
+        get("/") { |r| sleep 0.2; r.ok "late" }
+      end
+    ) do
+      res = get_resp("/")
+      assert_equal "504", res.code
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require_relative "../helpers/test_helper"
+
+class TestThreads < Minitest::Test
+
+  def test_it_can_run_multiple_threads
+    thread_count = 4
+    server(
+      itsi_rb: lambda do
+        threads thread_count
+        get("/foo"){|r| r.ok Thread.current.object_id}
+      end) do
+        assert_equal thread_count, 30.times.map { |i| get("/foo") }.uniq.size
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require_relative "../helpers/test_helper"
+
+class TestWorkers < Minitest::Test
+
+  def test_it_can_run_multiple_workers
+    worker_count = 3
+
+    server(
+      itsi_rb: lambda do
+        workers worker_count
+        get("/foo"){|r| r.ok Process.pid}
+      end) do
+        assert_equal worker_count, 50.times.map { |i| get("/foo") }.uniq.size
+    end
+  end
+end