itsi 0.1.20 → 0.2.2

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

@@ -0,0 +1,131 @@
+# test_deny_list.rb
+require_relative "../helpers/test_helper"
+
+class TestDenyList < Minitest::Test
+  # 1. Single‐pattern: localhost is denied
+  def test_single_pattern_denies_and_allows
+    server(
+      itsi_rb: lambda do
+        deny_list denied_patterns: ["^127\\.0\\.0\\.1$"]
+        get("/foo") { |r| r.ok "ok" }
+      end
+    ) do
+      # Client from 127.0.0.1 is denied
+      res1 = get_resp("/foo")
+      assert_equal "403", res1.code
+
+      # If we change the pattern to something else, localhost is allowed
+      server(
+        itsi_rb: lambda do
+          deny_list denied_patterns: ["^10\\."]
+          get("/foo") { |r| r.ok "allowed" }
+        end
+      ) do
+        res2 = get_resp("/foo")
+        assert_equal "200", res2.code
+        assert_equal "allowed", res2.body
+      end
+    end
+  end
+
+  # 2. Multiple‐pattern: deny localhost or 172.16.x.x
+  def test_multiple_patterns
+    server(
+      itsi_rb: lambda do
+        deny_list denied_patterns: ["^127\\.0\\.0\\.1$", "^172\\.16\\."]
+        get("/h") { |r| r.ok "h" }
+      end
+    ) do
+      # localhost matches first pattern → denied
+      res1 = get_resp("/h")
+      assert_equal "403", res1.code
+
+      # If we restrict only to 172.16.*, localhost becomes allowed
+      server(
+        itsi_rb: lambda do
+          deny_list denied_patterns: ["^172\\.16\\."]
+          get("/h") { |r| r.ok "ok" }
+        end
+      ) do
+        res2 = get_resp("/h")
+        assert_equal "200", res2.code
+        assert_equal "ok",   res2.body
+      end
+    end
+  end
+
+  # 3. Custom error_response
+  def test_custom_error_response
+    server(
+      itsi_rb: lambda do
+        deny_list \
+          denied_patterns: ["^127\\.0\\.0\\.1$"],
+          error_response: {
+            code: 403,
+            plaintext: { inline: "Blocked by IP" },
+            default: "plaintext"
+          }
+        get("/z") { |r| r.ok "never" }
+      end
+    ) do
+      res = get_resp("/z")
+      assert_equal "403", res.code
+      assert_equal "Blocked by IP", res.body
+    end
+  end
+
+  # 4. Trusted proxies: extract client IP from header if proxy is trusted
+  def test_trusted_proxy_denies_based_on_header
+    server(
+      itsi_rb: lambda do
+        deny_list \
+          denied_patterns: ["^198\\.51\\.100\\.9$"],
+          trusted_proxies: {
+            "127.0.0.1" => { header: { name: "X-Forwarded-For" } }
+          }
+        get("/deny") { |r| r.ok "shouldn't see" }
+      end
+    ) do
+      # Header says user is 198.51.100.9, which is denied
+      res = get_resp("/deny", { "X-Forwarded-For" => "198.51.100.9" })
+      assert_equal "403", res.code
+    end
+  end
+
+  def test_trusted_proxy_allows_if_forwarded_ip_not_denied
+    server(
+      itsi_rb: lambda do
+        deny_list \
+          denied_patterns: ["^198\\.51\\.100\\.9$"],  # deny this IP
+          trusted_proxies: {
+            "127.0.0.1" => { header: { name: "X-Forwarded-For" } }
+          }
+        get("/deny") { |r| r.ok "welcome" }
+      end
+    ) do
+      # Header says user is 198.51.100.10, which is not denied
+      res = get_resp("/deny", { "X-Forwarded-For" => "198.51.100.10" })
+      assert_equal "200", res.code
+      assert_equal "welcome", res.body
+    end
+  end
+
+  def test_untrusted_proxy_ignores_forwarded_ip
+    server(
+      itsi_rb: lambda do
+        deny_list \
+          denied_patterns: ["^198\\.51\\.100\\.9$"],
+          trusted_proxies: {
+            "10.0.0.1" => { header: { name: "X-Forwarded-For" } } # current sender not trusted
+          }
+        get("/deny") { |r| r.ok "should be denied by socket IP" }
+      end
+    ) do
+      # Because 127.0.0.1 is not trusted, header is ignored and socket IP (which matches ^127) is not denied
+      # But 127.0.0.1 isn't in the denied_patterns, so it's allowed
+      res = get_resp("/deny", { "X-Forwarded-For" => "198.51.100.9" })
+      assert_equal "200", res.code
+      assert_equal "should be denied by socket IP", res.body
+    end
+  end
+end

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

@@ -0,0 +1,300 @@
+require_relative "../helpers/test_helper"
+require "json"
+
+MySchema = { _required: %i[name], name: String }
+PingSchema = { _required: %i[status], status: String }
+
+
+class TestEndpoint < Minitest::Test
+  # 1. Basic inline GET endpoint
+  def test_basic_get
+    server(itsi_rb: lambda do
+      endpoint "/hello" do |req|
+        req.ok "world"
+      end
+    end) do
+      res = get_resp("/hello")
+      assert_equal "200", res.code
+      assert_equal "world", res.body
+    end
+  end
+
+  # 2. GET-only wrapper rejects POST
+  def test_get_wrapper_rejects_post
+    server(itsi_rb: lambda do
+      get "/onlyget" do |req|
+        req.ok "got"
+      end
+    end) do
+      assert_equal "got", get("/onlyget")
+      post_res = post("/onlyget", "")
+      refute_equal post_res.body, "got"
+    end
+  end
+
+  # 3. Trailing slash handling: both /path and /path/ map
+  def test_trailing_slash_equivalence
+    server(itsi_rb: lambda do
+      endpoint "/users" do |req|
+        req.ok req.path
+      end
+    end) do
+      res1 = get_resp("/users")
+      assert_equal "200", res1.code
+      assert_equal "/users", res1.body
+
+      res2 = get_resp("/users/")
+      assert_equal "200", res2.code
+      assert_equal "/users/", res2.body
+    end
+  end
+
+  # 4. Empty‑path endpoint: wildcard match all paths
+  def test_empty_path_wildcard
+    server(itsi_rb: lambda do
+      endpoint do |req|
+        req.ok req.path
+      end
+    end) do
+      %w[/ /foo /foo/bar].each do |path|
+        res = get_resp(path)
+        assert_equal "200", res.code
+        assert_equal path, res.body
+      end
+    end
+  end
+
+  # 5. JSON body parsing into params
+  def test_json_body_parsing
+    server(itsi_rb: lambda do
+      endpoint "/echo_json" do |req, params|
+        req.ok JSON.generate(params)
+      end
+    end) do
+      payload = { "a" => 1, "b" => 2 }
+      res = post(
+        "/echo_json",
+        JSON.generate(payload),
+        "Content-Type" => "application/json"
+      )
+      assert_equal "200", res.code
+      assert_equal payload, JSON.parse(res.body)
+    end
+  end
+
+  # 6. Form‑encoded body parsing
+  def test_form_urlencoded_parsing
+    server(itsi_rb: lambda do
+      endpoint "/echo_form" do |req, params|
+        req.ok "#{params['x']}-#{params['y']}"
+      end
+    end) do
+      res = post(
+        "/echo_form",
+        "x=foo&y=bar",
+        "Content-Type" => "application/x-www-form-urlencoded"
+      )
+      assert_equal "200", res.code
+      assert_equal "foo-bar", res.body
+    end
+  end
+
+  # 7. Streaming via low‑level response object
+  def test_streaming_response
+    server(itsi_rb: lambda do
+      endpoint "/stream" do |req|
+        stream = req.response
+        stream << "A"
+        stream << "B"
+        stream << "C"
+        stream.close
+      end
+    end) do
+      res = get_resp("/stream")
+      assert_equal "200", res.code
+      assert_equal "ABC", res.body
+    end
+  end
+
+  # 8. Exceptions inside handler produce 500
+  def test_internal_error_returns_500
+    server(itsi_rb: lambda do
+      endpoint "/boom" do |_req|
+        raise "test crash"
+      end
+    end) do
+      res = get_resp("/boom")
+      assert_equal "500", res.code
+    end
+  end
+
+  # 9. Controller method dispatch via symbol
+  def test_controller_symbol_dispatch
+    server(itsi_rb: lambda do
+      # define handler method in top‑level scope
+      def foo_handler(req)
+        req.ok "from_symbol"
+      end
+      endpoint "/sym", :foo_handler
+    end) do
+      res = get_resp("/sym")
+      assert_equal "200", res.code
+      assert_equal "from_symbol", res.body
+    end
+  end
+
+  # 10. Schema enforcement rejects bad JSON
+  def test_schema_validation_failure
+    server(itsi_rb: lambda do
+      # declare a schema and use typed params
+      endpoint "/typed" do |req, params: MySchema|
+        req.ok params["name"]
+      end
+    end) do
+      # missing "name"
+      res = post(
+        "/typed",
+        "{}",
+        "Content-Type" => "application/json"
+      )
+      assert_equal "400", res.code
+      assert_match /Validation failed/, res.body
+    end
+  end
+
+  # 11. Response‑format schema enforcement
+  def test_response_schema_enforcement
+    server(itsi_rb: lambda do
+      endpoint "/ping" do |req, _params, response_format: PingSchema|
+        req.ok json: { "wrong" => 123 }, as: response_format
+      end
+    end) do
+      res = get_resp("/ping")
+      assert_equal "400", res.code
+      assert_match /Validation failed/, res.body
+    end
+  end
+
+  # 12. Unrestricted HTTP method on endpoint (no wrapper)
+  def test_unrestricted_endpoint_all_methods
+    server(itsi_rb: lambda do
+      endpoint "/all" do |req|
+        req.ok req.request_method
+      end
+    end) do
+      %w[POST PUT PATCH DELETE].each do |m|
+        resp = send(m.downcase, "/all")
+        assert_equal "200", resp.code
+        assert_equal m, resp.body
+      end
+      resp = get_resp("/all")
+      assert_equal "200", resp.code
+      assert_equal "GET", resp.body
+    end
+  end
+
+  def test_head_on_get_wrapper
+    server(itsi_rb: lambda do
+      get "/resource" do |req|
+        req.respond body: "payload", status: 200, headers: { "X-Foo" => "bar" }
+      end
+    end) do
+      res = head("/resource")
+      assert_equal "200", res.code
+      assert_equal "bar", res["X-Foo"]
+      assert_empty res.body.to_s
+    end
+  end
+
+  # 14. POST wrapper accepts POST only
+  def test_post_wrapper
+    server(itsi_rb: lambda do
+      post "/submit" do |req|
+        req.ok "posted"
+      end
+      endpoint do |req|
+        req.not_found ""
+      end
+    end) do
+      assert_equal "posted", post("/submit", "").body
+      assert_equal "404", get_resp("/submit").code
+      assert_equal "404", head("/submit").code
+      assert_equal "404", options("/submit").code
+    end
+  end
+
+  # 15. PUT, PATCH, DELETE wrappers
+  %w[put patch delete].each do |verb|
+    define_method("test_#{verb}_wrapper") do
+      server(itsi_rb: lambda do
+        send(verb, "/thing") do |req|
+          req.ok req.request_method
+        end
+        endpoint do |req|
+          req.not_found ""
+        end
+      end) do
+        # correct method
+        send("#{verb}", "/thing")
+        # mismatched methods
+        %w[POST OPTIONS HEAD].each do |bad|
+          res = send("#{bad.downcase}", "/thing")
+          assert_equal "404", res.code, "#{verb.upcase} wrapper should 404 on #{bad}"
+        end
+      end
+    end
+  end
+
+  # 16. OPTIONS on unrestricted endpoint yields 200
+  def test_options_on_unrestricted
+    server(itsi_rb: lambda do
+      endpoint "/open" do |req|
+        req.ok "ok"
+      end
+    end) do
+      res = options("/open")
+      assert_equal "200", res.code
+      assert_equal "ok", res.body
+    end
+  end
+
+  # 17. HEAD on streaming endpoint
+  def test_head_on_streaming_endpoint
+    server(itsi_rb: lambda do
+      endpoint "/stream" do |req|
+        s = req.response
+        s << "XYZ"
+        s.close
+      end
+    end) do
+      res = head("/stream")
+      assert_equal "200", res.code
+      assert_empty res.body.to_s
+    end
+  end
+
+  # 18. Wildcard segment matching
+  def test_wildcard_endpoint
+    server(itsi_rb: lambda do
+      endpoint "/api/*" do |req|
+        req.ok req.path
+      end
+    end) do
+      ["/api/foo", "/api/foo/bar", "/api/"].each do |path|
+        res = get_resp(path)
+        assert_equal path, res.body
+      end
+    end
+  end
+
+  # 19. Multiple endpoints same path, different verbs
+  def test_same_path_different_verb
+    server(itsi_rb: lambda do
+      get "/duo" do |req| req.ok "g" end
+      post "/duo" do |req| req.ok "p" end
+    end) do
+      assert_equal "g", get("/duo")
+      assert_equal "p", post("/duo", "").body
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require_relative "../helpers/test_helper"
+
+class TestETag < Minitest::Test
+  def test_strong_etag_added
+    server(
+      itsi_rb: lambda do
+        etag type: "strong", algorithm: "sha256", min_body_size: 0, handle_if_none_match: false
+        get("/foo") { |r| r.ok "etag-body" }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert res["ETag"].start_with?("\"")
+      refute res["ETag"].start_with?("W/")
+    end
+  end
+
+  def test_weak_etag_added_with_md5
+    server(
+      itsi_rb: lambda do
+        etag type: "weak", algorithm: "md5", min_body_size: 0, handle_if_none_match: false
+        get("/foo") { |r| r.ok "etag-weak-md5" }
+      end
+    ) do
+      res = get_resp("/foo")
+      assert res["ETag"].start_with?("W/\"")
+    end
+  end
+
+  def test_etag_not_added_below_min_body_size
+    server(
+      itsi_rb: lambda do
+        etag min_body_size: 50
+        get("/foo") { |r| r.ok "short" }
+      end
+    ) do
+      res = get_resp("/foo")
+      refute res.key?("ETag")
+    end
+  end
+
+  def test_etag_responds_with_304_if_none_match
+    body = "etag-content"
+    server(
+      itsi_rb: lambda do
+        etag type: "strong", min_body_size: 0, handle_if_none_match: true
+        get("/foo") { |r| r.ok body }
+      end
+    ) do
+      first = get_resp("/foo")
+      etag = first["ETag"]
+      assert etag
+
+      second = get_resp("/foo", { "If-None-Match" => etag })
+      assert_equal "304", second.code
+      refute second.body && second.body.size > 0
+    end
+  end
+
+  def test_etag_ignored_for_streaming_body
+    server(
+      itsi_rb: lambda do
+        etag min_body_size: 0
+        get("/stream") do |req|
+          r = req.response
+          r << "streaming-1"
+          r << "streaming-2"
+          r.close
+        end
+      end
+    ) do
+      res = get_resp("/stream")
+      refute res.key?("ETag")
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+require_relative "../../helpers/test_helper"
+require_relative "test_service_impl"
+
+class TestGrpc < Minitest::Test
+  Stub = Test::TestService::Stub
+
+  def new_stub(uri)
+    address = uri.to_s[/\/\/(.*)/,1]    # e.g. "127.0.0.1:12345"
+    channel = GRPC::Core::Channel.new(address,
+                                      {},              # channel_args hash
+                                      :this_channel_is_insecure,
+    )
+    stub = Stub.new(nil,
+                                 nil,
+                                 channel_override: channel)
+  end
+
+  def test_unary_echo
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      stub = new_stub(@uri)
+      req = Test::EchoRequest.new(message: "hello")
+      res = stub.unary_echo(req)
+      assert_equal "hello", res.message
+    end
+  end
+
+  def test_client_stream
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      stub = new_stub(@uri)
+      # send a few messages in one stream
+      requests = %w[a b c].map { |m| Test::StreamRequest.new(message: m) }
+      res = stub.client_stream(requests.each)
+      assert_equal %w[a b c], res.messages
+    end
+  end
+
+  def test_server_stream
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      stub = new_stub(@uri)
+      req = Test::EchoRequest.new(message: "xy")
+      # expect two StreamResponse frames, one per character
+      chars = stub.server_stream(req).map(&:messages).flatten
+      assert_equal ["x", "y"], chars
+    end
+  end
+
+  def test_bidi_stream
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      stub = new_stub(@uri)
+      inputs = %w[test1 test2].map { |m| Test::EchoRequest.new(message: m) }
+      # each response uppercases its incoming message
+      results = stub.bidi_stream(inputs.each).map(&:message)
+      assert_equal ["TEST1", "TEST2"], results
+    end
+  end
+
+  def test_empty_streams
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      stub = new_stub(@uri)
+
+      # empty client‐streaming
+      res = stub.client_stream([].each)
+      assert_equal [], res.messages
+
+      # empty server‐streaming
+      empty_server = stub.server_stream(Test::EchoRequest.new(message: "")).to_a
+      assert empty_server.empty?
+
+      # empty bidi‐streaming
+      empty_bidi = stub.bidi_stream([].each).to_a
+      assert empty_bidi.empty?
+    end
+  end
+
+
+  def test_unary_echo_json
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      payload = { "message" => "hello" }.to_json
+      res = post("test.TestService/UnaryEcho", payload, { "Content-Type" => "application/json" })
+      json = JSON.parse(res.body)
+      assert_equal 200, res.code.to_i
+      assert_equal "hello", json["message"]
+    end
+  end
+
+  def test_client_stream_json
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      input = [{"message" => "a"}, {"message" => "b"}, {"message" => "c"}]
+      res = post("test.TestService/ClientStream", input.to_json, { "Content-Type" => "application/json" })
+      json = JSON.parse(res.body)
+      assert_equal 200, res.code.to_i
+      assert_equal %w[a b c], json["messages"]
+    end
+  end
+
+  def test_server_stream_json
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      payload = { "message" => "xy" }.to_json
+      res = post("test.TestService/ServerStream", payload, { "Content-Type" => "application/json" })
+      arr = JSON.parse(res.body)
+      # service streams back one JSON object per character
+      messages = arr.flat_map { |frame| frame["messages"] }
+      assert_equal 200, res.code.to_i
+      assert_equal ["x","y"], messages
+    end
+  end
+
+  def test_bidi_stream_json
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      inputs = [{"message":"foo"}, {"message":"Bar"}]
+      res = post("test.TestService/BidiStream", inputs.to_json, { "Content-Type" => "application/json" })
+      arr = JSON.parse(res.body)
+      # bidi uppercases each incoming message
+      results = arr.map { |frame| frame["message"] }
+      assert_equal 200, res.code.to_i
+      assert_equal ["FOO","BAR"], results
+    end
+  end
+
+  def test_empty_streams_json
+    server(itsi_rb: lambda do
+      grpc TestServiceImpl.new
+    end) do
+      # empty client-stream → still JSON object with empty messages
+      res1 = post("test.TestService/ClientStream", "[]", { "Content-Type" => "application/json" })
+      json1 = JSON.parse(res1.body)
+      assert_nil json1["messages"]
+
+      # empty server-stream
+      res2 = post("test.TestService/ServerStream", { "message" => "" }.to_json, { "Content-Type" => "application/json" })
+      arr2 = JSON.parse(res2.body)
+      assert arr2.empty?
+
+      # empty bidi-stream
+      res3 = post("test.TestService/BidiStream", "[]", { "Content-Type" => "application/json" })
+      arr3 = JSON.parse(res3.body)
+      assert arr3.empty?
+    end
+  end
+end

data/gems/server/test/middleware/grpc/test_service.proto

@@ -0,0 +1,32 @@
+syntax = "proto3";
+
+package test;
+
+// A service with one of each RPC type  [oai_citation_attribution:0‡Википедия — свободная энциклопедия](https://ru.wikipedia.org/wiki/GRPC?utm_source=chatgpt.com)
+service TestService {
+  // Unary RPC
+  rpc UnaryEcho (EchoRequest) returns (EchoResponse) {}
+
+  // Client‑streaming RPC
+  rpc ClientStream (stream StreamRequest) returns (StreamResponse) {}
+
+  // Server‑streaming RPC
+  rpc ServerStream (EchoRequest) returns (stream StreamResponse) {}
+
+  // Bidirectional streaming RPC
+  rpc BidiStream (stream EchoRequest) returns (stream EchoResponse) {}
+}
+
+message EchoRequest {
+  string message = 1;
+}
+message EchoResponse {
+  string message = 1;
+}
+
+message StreamRequest {
+  string message = 1;
+}
+message StreamResponse {
+  repeated string messages = 1;
+}