tp2 0.16 → 0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b39e332d3140ec95dee3edc265fec814873208d8b17797fccd5513b843b614b
-  data.tar.gz: f39b677a8e703b9d9f8a48aa223365b6355eb5810735812cf600ae1645351d89
+  metadata.gz: 6b2eaad3a3794a09c6a10e69cc3813ad27789049bd71055f315edcc5ac61b1a6
+  data.tar.gz: 7a8529db038480936bbb44a2a9e059ea5625b6d3f1cbb9eb7d04c185ab4268b9
 SHA512:
-  metadata.gz: 0cab6849c05ca00890073e2ef7fe2db7410fbda9ac10f4d908fba7c04e02452dc31ec4f9c24c56dd5719ca11c6bcd57de325b1e422fab4114515674e3273c854
-  data.tar.gz: 7cb455c7da2207024e6ce8d41435dee1c6ed2d4357b259d9b34a750f829504576304aac7cc8e998a5bd06eeca61db8e643311bcf67c0726528bf3a0f7d04699a
+  metadata.gz: 5a8c23907e0e4f4d9024bf2457efdfa1b003d3d4870a65ec6a44e8ab3cc67d5d7bf096a5adba39a0e552c0eefe7fe9306a1612c19382ff64a3689805c98ff903
+  data.tar.gz: c4183ad2dade4aaf4511fd4d9f856c2532bf8c374a99a632010c629112c1f1fc8020f7bc7580cf3295a25bfd2826ce79b99561348f35c727176b20ea4f559cb6

data/.gitignore

@@ -54,3 +54,4 @@ Gemfile.lock
 
 # Used by RuboCop. Remote config files pulled in from inherit_from directive.
 # .rubocop-https?--*
+*.json

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 0.18 2025-09-14
+
+- Add `Request#set_cookie` method
+
+# 0.17 2025-09-14
+
+- Add support for server extensions: `Date`, `Server` headers
+- Add `Request#set_response_headers` for injecting response headers
+- Add support for env[:server_headers]
+
 # 0.16 2025-09-11
 
 - Remove support for HTTP/0.9, HTTP/1.0, use chunked transfer encoding

data/README.md

@@ -3,7 +3,7 @@
 # TP2 - a io_uring-based app server for Ruby
 
 [![Gem Version](https://badge.fury.io/rb/tp2.svg)](http://rubygems.org/gems/tp2)
-[![Tipi Test](https://github.com/digital-fabric/tp2/workflows/Tests/badge.svg)](https://github.com/digital-fabric/tp2/actions?query=workflow%3ATests)
+[![Tests](https://github.com/noteflakes/tp2/actions/workflows/test.yml/badge.svg)](https://github.com/noteflakes/tp2/actions/workflows/test.yml)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/tp2/blob/master/LICENSE)
 
 TP2 is an experimental HTTP server based on

data/TODO.md

@@ -1,7 +1,7 @@
 ## Immediate
 
-- [ ] Remove support for HTTP/0.9, HTTP/1.0
-  - [ ] Reply with 505 HTTP version not supported:
+- [v] Remove support for HTTP/0.9, HTTP/1.0
+  - [v] Reply with 505 HTTP version not supported:
 
     ```
     < GET / HTTP/0.9
@@ -10,7 +10,7 @@
     > Connection: close
     ```
 
-- [ ] Use chunked transfer encoding exclusively
+- [v] Use chunked transfer encoding exclusively
 - [ ] Cache rendered headers
   - [ ] Look at sketch in ~/Desktop/docs/
 

data/lib/tp2/connection.rb

@@ -13,11 +13,12 @@ module TP2
   class Connection
     attr_reader :fd, :response_headers, :logger
 
-    def initialize(machine, fd, opts, &app)
+    def initialize(server, machine, fd, env, &app)
+      @server = server
       @machine = machine
       @fd = fd
-      @opts = opts
-      @logger = opts[:logger]
+      @env = env
+      @logger = env[:logger]
       @stream = UM::Stream.new(machine, fd)
       @app = app
 
@@ -63,7 +64,7 @@ module TP2
     # Handles an error encountered while serving a request by logging the error
     # and optionally sending an error response with the relevant HTTP status
     # code. For I/O errors, no response is sent.
-    # 
+    #
     # @param request [Qeweney::Request] HTTP request
     # @param err [Exception] error
     # @return [void]
@@ -83,7 +84,7 @@ module TP2
     end
 
     # Logs the given err and given message.
-    # 
+    #
     # @param err [Exception] error
     # @param message [String] error message
     # @return [void]
@@ -131,6 +132,25 @@ module TP2
 
     # response API
 
+    # Sets response headers before sending any response. This method is used to
+    # add headers such as Set-Cookie or cache control headers to a response
+    # before actually responding, specifically in middleware hooks.
+    #
+    # @param headers [Hash] response headers
+    # @return [void]
+    def set_response_headers(headers)
+      @response_headers ? @response_headers.merge!(headers) : @response_headers = headers
+    end
+
+    def set_cookie(*cookies)
+      existing_cookies = @response_headers && @response_headers['Set-Cookie']
+      if existing_cookies
+        @response_headers['Set-Cookie'] = existing_cookies + cookies
+      else
+        set_response_headers('Set-Cookie' => cookies)
+      end
+    end
+
     SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
 
     # Sends response including headers and body. Waits for the request to complete
@@ -139,7 +159,10 @@ module TP2
     # @param body [String] response body
     # @param headers
     def respond(request, body, headers)
+      headers = @response_headers.merge(headers) if @response_headers
+
       formatted_headers = format_headers(headers, body)
+      @response_headers = headers
       request&.tx_incr(formatted_headers.bytesize + (body ? body.bytesize : 0))
       if body
         buf = "#{formatted_headers}#{body.bytesize.to_s(16)}\r\n#{body}\r\n#{EMPTY_CHUNK}"
@@ -149,7 +172,6 @@ module TP2
       end
       @logger&.info(request: request, response_headers: headers) if request
       @done = true
-      @response_headers = headers
     end
 
     # Sends response headers. If empty_response is truthy, the response status
@@ -201,28 +223,28 @@ module TP2
       @done = true
     end
 
-    def respond_with_static_file(req, path, opts, cache_headers)
+    def respond_with_static_file(req, path, env, cache_headers)
       fd = @machine.open(path, UM::O_RDONLY)
-      opts ||= {}
-      if opts[:headers]
-        opts[:headers].merge!(cache_headers)
+      env ||= {}
+      if env[:headers]
+        env[:headers].merge!(cache_headers)
       else
-        opts[:headers] = cache_headers
+        env[:headers] = cache_headers
       end
 
-      maxlen = opts[:max_len] || 65_536
+      maxlen = env[:max_len] || 65_536
       buf = String.new(capacity: maxlen)
       headers_sent = nil
       loop do
         res = @machine.read(fd, buf, maxlen, 0)
         if res < maxlen && !headers_sent
-          return respond(req, buf, opts[:headers])
+          return respond(req, buf, env[:headers])
         elsif res == 0
           return finish(req)
         end
 
         if !headers_sent
-          send_headers(req, opts[:headers])
+          send_headers(req, env[:headers])
           headers_sent = true
         end
         done = res < maxlen
@@ -230,7 +252,7 @@ module TP2
         return if done
       end
     ensure
-      @machine.close(fd) if fd
+      @machine.close_async(fd) if fd
     end
 
     def close
@@ -332,6 +354,7 @@ module TP2
     def format_headers(headers, body)
       status = headers[':status'] || (body ? Qeweney::Status::OK : Qeweney::Status::NO_CONTENT)
       lines = format_status_line(body, status)
+      lines << @env[:server_headers] if @env[:server_headers]
       headers.each do |k, v|
         next if k =~ INTERNAL_HEADER_REGEXP
 

data/lib/tp2/request_extensions.rb

@@ -11,4 +11,12 @@ class Qeweney::Request
 
     adapter.respond_with_static_file(self, path, opts, cache_headers)
   end
+
+  def set_response_headers(headers)
+    adapter.set_response_headers(headers)
+  end
+
+  def set_cookie(*)
+    adapter.set_cookie(*)
+  end
 end

data/lib/tp2/server.rb

@@ -9,42 +9,42 @@ module TP2
     PENDING_REQUESTS_GRACE_PERIOD = 0.1
     PENDING_REQUESTS_TIMEOUT_PERIOD = 5
 
-    def self.rack_app(opts)
-      raise 'Missing app location' if !opts[:app_location]
+    def self.rack_app(env)
+      raise 'Missing app location' if !env[:app_location]
 
-      TP2::RackAdapter.load(opts[:app_location])
+      TP2::RackAdapter.load(env[:app_location])
     end
 
-    def self.tp2_app(_machine, opts)
-      if opts[:app_location]
-        opts[:logger]&.info(message: 'Loading web app', location: opts[:app_location])
-        require opts[:app_location]
+    def self.tp2_app(_machine, env)
+      if env[:app_location]
+        env[:logger]&.info(message: 'Loading web app', location: env[:app_location])
+        require env[:app_location]
 
-        opts.merge!(TP2.config)
+        env.merge!(TP2.config)
       end
-      opts[:app]
+      env[:app]
     end
 
-    def self.static_app(opts); end
+    def self.static_app(env); end
 
-    def initialize(machine, opts, &app)
+    def initialize(machine, env, &app)
       @machine = machine
-      @opts = opts
-      @app = app || app_from_opts
+      @env = env
+      @app = app || app_from_env
       @server_fds = []
       @accept_fibers = []
     end
 
-    def app_from_opts
-      case @opts[:app_type]
+    def app_from_env
+      case @env[:app_type]
       when nil, :tp2
-        Server.tp2_app(@machine, @opts)
+        Server.tp2_app(@machine, @env)
       when :rack
-        Server.rack_app(@opts)
+        Server.rack_app(@env)
       when :static
-        Server.static_app(@opts)
+        Server.static_app(@env)
       else
-        raise "Invalid app type #{@opts[:app_type].inspect}"
+        raise "Invalid app type #{@env[:app_type].inspect}"
       end
     end
 
@@ -65,14 +65,15 @@ module TP2
         @accept_fibers << @machine.spin { accept_incoming(fd) }
       end
       bind_string = bind_info.map { it.join(':') }.join(', ')
-      @opts[:logger]&.info(message: "Listening on #{bind_string}")
+      @env[:logger]&.info(message: "Listening on #{bind_string}")
+      setup_server_extensions
 
       # map fibers
       @connection_fiber_map = {}
     end
 
     def get_bind_entries
-      bind = @opts[:bind]
+      bind = @env[:bind]
       case bind
       when Array
         bind.map { bind_info(it) }
@@ -98,9 +99,33 @@ module TP2
       fd
     end
 
+    def setup_server_extensions
+      extensions = @env[:server_extensions]
+      return if !extensions
+
+      server_name = extensions[:name]
+      if extensions[:date]
+        @date_header_fiber = @machine.spin {
+          @machine.periodically(1) { update_server_headers(server_name) }
+        }
+        update_server_headers(server_name)
+      elsif server_name
+        @env[:server_headers] = "Server: #{server_name}\r\n"
+      end
+    end
+
+    def update_server_headers(server_name)
+      @env[:server_date] = Time.now
+      if server_name
+        @env[:server_headers] = "Server: #{server_name}\r\nDate: #{@env[:server_date].httpdate}\r\n"
+      else
+        @env[:server_headers] = "Date: #{Time.now.httpdate}\r\n"
+      end
+    end
+
     def accept_incoming(listen_fd)
       @machine.accept_each(listen_fd) do |fd|
-        conn = Connection.new(@machine, fd, @opts, &@app)
+        conn = Connection.new(self, @machine, fd, @env, &@app)
         f = @machine.spin(conn) do
           it.run
         ensure
@@ -121,7 +146,7 @@ module TP2
     end
 
     def graceful_shutdown
-      @opts[:logger]&.info(message: 'Shutting down gracefully...')
+      @env[:logger]&.info(message: 'Shutting down gracefully...')
 
       # stop listening
       close_all_server_fds

data/lib/tp2/version.rb

@@ -1,3 +1,3 @@
 module TP2
-  VERSION = '0.16'
+  VERSION = '0.18'
 end

data/lib/tp2.rb

@@ -24,22 +24,22 @@ module TP2
   )
 
   class << self
-    def run(opts = nil, &app)
+    def run(env = {}, &app)
       if @in_run
-        @config = opts if opts
-        @config[:app] = app if app
+        @env = env
+        @env[:app] = app if app
         return
       end
 
-      opts ||= @config || {}
+      env ||= @env || {}
       begin
         @in_run = true
-        machine = opts[:machine] || UM.new
-        machine.puts(opts[:banner]) if opts[:banner]
+        machine = env[:machine] || UM.new
+        machine.puts(env[:banner]) if env[:banner]
 
-        opts[:logger]&.info(message: "Running TP2 #{TP2::VERSION}, UringMachine #{UM::VERSION}, Ruby #{RUBY_VERSION}")
+        env[:logger]&.info(message: "Running TP2 #{TP2::VERSION}, UringMachine #{UM::VERSION}, Ruby #{RUBY_VERSION}")
 
-        server = Server.new(machine, opts, &app)
+        server = Server.new(machine, env, &app)
 
         setup_signal_handling(machine, Fiber.current)
         server.run
@@ -48,11 +48,11 @@ module TP2
       end
     end
 
-    def config(opts = nil, &app)
-      return @config if !opts && !app
+    def env(env = nil, &app)
+      return @env if !env && !app
 
-      @config = opts || {}
-      @config[:app] = app if app
+      @env = env || {}
+      @env[:app] = app if app
     end
 
     private

data/test/bm_connection.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile {
+  gem 'tp2', path: '..'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+  gem 'vernier'
+}
+
+require 'vernier'
+require 'securerandom'
+require 'benchmark/ips'
+
+class ConnectionTester
+  def make_socket_pair
+    port = SecureRandom.random_number(10000..40000)
+    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    @machine.bind(server_fd, '127.0.0.1', port)
+    @machine.listen(server_fd, UM::SOMAXCONN)
+
+    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+    server_conn_fd = @machine.accept(server_fd)
+
+    @machine.close(server_fd)
+    [client_conn_fd, server_conn_fd]
+  end
+
+  def setup
+    @machine = UM.new
+    @c_fd, @s_fd = make_socket_pair
+    @reqs = []
+    @app = ->(req) { req.respond('foobar', 'Content-Type' => 'text/plain') }
+    @adapter = TP2::Connection.new(nil, @machine, @s_fd, {}, &@app)
+  end
+
+  def teardown
+    @machine.close(@c_fd) rescue nil
+    @machine.close(@s_fd) rescue nil
+  end
+
+  def write_http_request(msg, shutdown_wr = true)
+    @machine.send(@c_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+    @machine.shutdown(@c_fd, UM::SHUT_WR) if shutdown_wr
+  end
+
+  def write_client_side(msg)
+    @machine.send(@c_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+  end
+
+  def read_client_side(len = 65536)
+    buf = +''
+    res = @machine.recv(@c_fd, buf, len, 0)
+    res == 0 ? nil : buf
+  end
+
+  def run_request
+    write_http_request "GET / HTTP/1.1\r\n\r\n", false
+    @adapter.serve_request
+    read_client_side(len = 65536)
+  end
+end
+
+tester = ConnectionTester.new
+tester.setup
+
+# puts '*' * 40
+# p tester.run_request
+# p tester.run_request
+# puts '*' * 40
+
+# Vernier.profile(out: "profile.vernier.json") {
+#   100000.times { tester.run_request }
+# }
+
+Benchmark.ips do |x|
+  x.report('request') { tester.run_request }
+  x.compare!(order: :baseline)
+end

data/test/test_connection.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require_relative './helper'
+require 'securerandom'
 
 class ConnectionTest < Minitest::Test
   def make_socket_pair
-    port = 10000 + rand(30000)
+    port = SecureRandom.random_number(10000..40000)
     server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
     @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
     @machine.bind(server_fd, '127.0.0.1', port)
@@ -25,7 +26,8 @@ class ConnectionTest < Minitest::Test
     @reqs = []
     @hook = nil
     @app = ->(req) { @hook&.call(req); @reqs << req }
-    @adapter = TP2::Connection.new(@machine, @s_fd, {}, &@app)
+    @env = {}
+    @adapter = TP2::Connection.new(nil, @machine, @s_fd, @env, &@app)
   end
 
   def teardown
@@ -341,7 +343,7 @@ class ConnectionTest < Minitest::Test
     @adapter.run
     response = read_client_side
 
-    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n" + 
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n" +
                "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\ne\r\nHello, foobar!\r\n0\r\n\r\n"
     assert_equal(expected, response)
   end
@@ -520,4 +522,108 @@ class ConnectionTest < Minitest::Test
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nfoo\r\n3\r\nbar\r\n0\r\n\r\n"
     assert_equal expected, response
   end
+
+  def test_connection_server_headers
+    @env[:server_headers] = "Server: TP2\r\n"
+
+    @hook = ->(req) do
+      req.respond('foo')
+    end
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: TP2\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+
+    @env[:server_headers] = "Server: TP3\r\n"
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: TP3\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+  end
+
+  def test_set_response_headers
+    @hook = ->(req) {
+      req.set_response_headers("Set-Cookie" => 'foo=bar')
+      req.respond('foo')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+
+    @hook = ->(req) {
+      req.set_response_headers("Set-Cookie" => 'foo=bar')
+      req.respond('foo', 'Content-Type' => 'text/plain')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\nContent-Type: text/plain\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+  end
+
+  def test_set_response_headers
+    @hook = ->(req) {
+      req.set_response_headers("Set-Cookie" => 'foo=bar')
+      req.set_response_headers("Foo" => 'bar')
+      req.respond('foo', 'Content-Type' => 'text/plain')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\nFoo: bar\r\nContent-Type: text/plain\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+  end
+
+  def test_set_cookie_single
+    @hook = ->(req) {
+      req.set_cookie('foo=bar; HttpOnly')
+      req.respond('foo')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar; HttpOnly\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+    
+  end
+
+  def test_set_cookie_multi1
+    @hook = ->(req) {
+      req.set_cookie('foo=bar; HttpOnly', 'bar=baz')
+      req.respond('foo')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar; HttpOnly\r\nSet-Cookie: bar=baz\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+    
+  end
+
+  def test_set_cookie_multi2
+    @hook = ->(req) {
+      req.set_cookie('a=1', 'b=2')
+      req.set_cookie('c=3')
+      req.set_cookie('d=4', 'e=5')
+      req.respond('foo')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: a=1\r\nSet-Cookie: b=2\r\nSet-Cookie: c=3\r\nSet-Cookie: d=4\r\nSet-Cookie: e=5\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+    
+  end
 end

data/test/test_server.rb

@@ -22,11 +22,11 @@ class ServerTest < Minitest::Test
   class STOP < StandardError
   end
 
-  def setup
+  def setup(opts = {})
     @machine = UM.new
     @port = 10000 + rand(30000)
-    @opts = { bind: "127.0.0.1:#{@port}" }
-    @server = TP2::Server.new(@machine, @opts) { @app&.call(it) }
+    @env = { bind: "127.0.0.1:#{@port}" }.merge(opts)
+    @server = TP2::Server.new(@machine, @env) { @app&.call(it) }
     @f_server = @machine.spin { run_server }
 
     # let server spin and listen to incoming connections
@@ -94,8 +94,9 @@ class ServerTest < Minitest::Test
 
     write_http_request "GET /foo HTTP/1.1\r\nServer: foo.com\r\n\r\nSCHmet /bar HTTP/1.1\r\n\r\n"
 
+    @machine.sleep(0.1)
     response = read_client_side
-    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nmethod: get\r\n0\r\n\r\n" + 
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nmethod: get\r\n0\r\n\r\n" +
                "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\ne\r\nmethod: schmet\r\n0\r\n\r\n"
     assert_equal(expected, response)
   end
@@ -278,7 +279,7 @@ class ServerTest < Minitest::Test
   def test_logging
     skip
     reqs = []
-    @opts[:logger] = TestLogger.new
+    @env[:logger] = TestLogger.new
     @app = ->(req) { reqs << req; req.respond('Hello, world!', {}) }
 
     write_http_request "GET / HTTP/1.0\r\n\r\n"
@@ -286,10 +287,68 @@ class ServerTest < Minitest::Test
     expected = "HTTP/1.1 200\r\nContent-Length: 13\r\n\r\nHello, world!"
     assert_equal(expected, response)
 
-    entries = @opts[:logger].entries
+    entries = @env[:logger].entries
     assert_equal 1, entries.size
     assert_equal 1, reqs.size
 
     assert_equal reqs.first, entries.first[:request]
   end
+
+  def test_server_headers
+    @env[:server_headers] = "Server: Tipi\r\n"
+
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Tipi\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date
+    setup({ server_extensions: { date: true } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date_and_server_name
+    setup({ server_extensions: { date: true, name: 'Foo' } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Foo\r\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_server_name
+    setup({ server_extensions: { name: 'Bar' } })
+    @machine.sleep(0.1)
+    assert_nil @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: Bar\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tp2
 version: !ruby/object:Gem::Version
-  version: '0.16'
+  version: '0.18'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -78,6 +78,7 @@ files:
 - lib/tp2/request_extensions.rb
 - lib/tp2/server.rb
 - lib/tp2/version.rb
+- test/bm_connection.rb
 - test/helper.rb
 - test/run.rb
 - test/test_connection.rb