itsi 0.1.20 → 0.2.2

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

@@ -0,0 +1,50 @@
+require_relative "../helpers/test_helper"
+
+class TestRequestHeaders < Minitest::Test
+  def test_add_and_remove_static
+    server(
+      itsi_rb: lambda do
+        request_headers \
+          additions: { "X-Test" => ["hello"] },
+          removals:  ["X-Remove-Me"]
+        get("/foo") do |r|
+          r.ok r.header("X-Test").first + "|" + (r.header("X-Remove-Me").empty? ? "gone" : "here")
+        end
+      end
+    ) do
+      res = get_resp("/foo", { "X-Remove-Me" => "bye" })
+      assert_equal "200", res.code
+      assert_equal "hello|gone", res.body
+    end
+  end
+
+  def test_dynamic_string_rewrite
+    server(
+      itsi_rb: lambda do
+        request_headers \
+          additions: { "X-Path" => ["{path_and_query}"] },
+          removals:  []
+        get("/bar") { |r| r.ok r.header("X-Path").first }
+      end
+    ) do
+      res = get_resp("/bar?x=1")
+      assert_equal "200", res.code
+      assert_equal "/bar?x=1", res.body
+    end
+  end
+
+  def test_override_existing_header
+    server(
+      itsi_rb: lambda do
+        request_headers \
+          additions: { "User-Agent" => ["ItsiTester"] },
+          removals:  ["User-Agent"]
+        get("/u") { |r| r.ok r.header("User-Agent").first }
+      end
+    ) do
+      res = get_resp("/u", { "User-Agent" => "orig" })
+      assert_equal "200", res.code
+      assert_equal "ItsiTester", res.body
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require_relative "../helpers/test_helper"
+
+class TestResponseHeaders < Minitest::Test
+  def test_add_and_remove_static
+    server(
+      itsi_rb: lambda do
+        response_headers \
+          additions: { "X-Test" => ["world"] }
+          # removals:  ["X-Custom"]
+        get("/foo") { |r| r.ok "hi", {"X-Custom" => "value"} }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert_equal "200", res.code
+      assert_equal "world", res["X-Test"]
+      refute res.key?("X-Custom")
+    end
+  end
+
+  def test_dynamic_response_rewrite
+    server(
+      itsi_rb: lambda do
+        response_headers \
+          additions: { "X-Addr" => ["{addr}"] },
+          removals:  []
+        get("/addr") { |r| r.ok "12345" }
+      end
+    ) do
+      res = get_resp("/addr")
+      assert_equal "200", res.code
+      assert_equal "127.0.0.1", res["X-Addr"]
+    end
+  end
+
+  def test_override_multiple_values
+    server(
+      itsi_rb: lambda do
+        response_headers \
+          additions: { "Set-Cookie" => ["a=1", "b=2"] },
+          removals:  ["Set-Cookie"]
+        get("/cookie") { |r| r.ok "ok" }
+      end
+    ) do
+      res = get_resp("/cookie")
+      cookies = res.get_fields("Set-Cookie")
+      assert_includes cookies, "a=1"
+      assert_includes cookies, "b=2"
+    end
+  end
+end

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/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