tep 0.11.0

data/test/test_sqlite.rb

@@ -0,0 +1,148 @@
+require_relative "helper"
+
+# Tep::SQLite -- a thin libsqlite3 binding wired through spinel's
+# FFI DSL. Tests cover: basic CRUD, parameterised insert + select,
+# multi-row iteration, last_rowid, and a per-test temp .db file
+# so test order is irrelevant.
+class TestSqlite < TepTest
+  TMP_DB = "/tmp/tep_test_#{$$}.db"
+
+  app_source <<~RB
+    require 'sinatra'
+
+    on_start do
+      db = Tep::SQLite.new
+      if db.open("#{TMP_DB}")
+        db.exec("CREATE TABLE IF NOT EXISTS notes (id INTEGER PRIMARY KEY, body TEXT)")
+        db.exec("DELETE FROM notes")
+        db.prepare("INSERT INTO notes (body) VALUES (?)")
+        db.bind_str(1, "first note")
+        db.step
+        db.reset
+        db.bind_str(1, "second note")
+        db.step
+        db.reset
+        db.bind_str(1, "third note")
+        db.step
+        db.finalize
+        db.close
+      end
+    end
+
+    get '/note/:id' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      body = db.first_str("SELECT body FROM notes WHERE id = ?", params[:id])
+      db.close
+      "id=" + params[:id] + " body=" + body
+    end
+
+    get '/notes' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      out = ""
+      db.prepare("SELECT id, body FROM notes ORDER BY id")
+      while db.step == 1
+        out = out + db.col_int(0).to_s + ":" + db.col_str(1) + "\\n"
+      end
+      db.finalize
+      db.close
+      out
+    end
+
+    get '/count' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      n = db.first_int("SELECT count(*) FROM notes", "")
+      db.close
+      "count=" + n.to_s
+    end
+
+    post '/notes' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      db.prepare("INSERT INTO notes (body) VALUES (?)")
+      db.bind_str(1, params[:body])
+      db.step
+      db.finalize
+      id = db.last_rowid
+      db.close
+      "inserted=" + id.to_s
+    end
+
+    # 64-bit round-trip (issue #171): bind a value > 2^31 via bind_int,
+    # read it back via col_int. With the old 32-bit path this wrapped
+    # negative (3427544687 -> -867422609); now it must survive intact.
+    get '/bigint' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      db.exec("CREATE TABLE IF NOT EXISTS bignums (n INTEGER)")
+      db.exec("DELETE FROM bignums")
+      db.prepare("INSERT INTO bignums (n) VALUES (?)")
+      db.bind_int(1, 3427544687)
+      db.step
+      db.finalize
+      db.prepare("SELECT n FROM bignums LIMIT 1")
+      db.step
+      n = db.col_int(0)
+      db.finalize
+      db.close
+      "n=" + n.to_s
+    end
+  RB
+
+  Minitest.after_run do
+    File.unlink(TMP_DB) if File.exist?(TMP_DB)
+  end
+
+  def test_first_str_with_param
+    res = get("/note/1")
+    assert_equal "200", res.code
+    assert_equal "id=1 body=first note", res.body.strip
+  end
+
+  def test_first_str_missing_row_returns_empty
+    res = get("/note/9999")
+    assert_equal "200", res.code
+    assert_equal "id=9999 body=", res.body.strip
+  end
+
+  # Tests that mutate are written to be order-independent: minitest
+  # randomises seed-shuffled order and the test app boots once per
+  # class (on_start runs once), so reads-then-writes-then-reads in
+  # an arbitrary order all need to make sense.
+
+  def test_iterate_all_rows_has_seeded_bodies
+    res = get("/notes")
+    assert_equal "200", res.code
+    body = res.body
+    assert_match(/:first note$/, body)
+    assert_match(/:second note$/, body)
+    assert_match(/:third note$/, body)
+  end
+
+  def test_first_int_returns_at_least_seed_count
+    res = get("/count")
+    assert_equal "200", res.code
+    n = res.body.strip.split("=").last.to_i
+    assert n >= 3, "expected count >= 3, got #{n}"
+  end
+
+  def test_insert_and_last_rowid_round_trips
+    res = post("/notes", "body=via-test")
+    assert_equal "200", res.code
+    inserted_id = res.body.strip.split("=").last.to_i
+    assert inserted_id >= 1, "expected a positive rowid, got #{inserted_id}"
+
+    res2 = get("/note/#{inserted_id}")
+    assert_match(/body=via-test/, res2.body)
+  end
+
+  def test_bind_and_col_int_round_trip_64bit
+    # 3,427,544,687 > 2^31-1. The old 32-bit bind/col path truncated it
+    # to -867,422,609 (issue #171); 64-bit bind_int/col_int preserve it.
+    res = get("/bigint")
+    assert_equal "200", res.code
+    assert_equal "n=3427544687", res.body
+  end
+end

data/test/test_sqlite_cached.rb

@@ -0,0 +1,171 @@
+require_relative "helper"
+
+# Tep::SQLite#prepare_cached -- cache hit / miss / reset-on-finalize
+# semantics. Backs the perf-leverage win documented in issue #75.
+class TestSqliteCached < TepTest
+  TMP_DB = "/tmp/tep_test_cache_#{$$}.db"
+
+  app_source <<~RB
+    require 'sinatra'
+
+    on_start do
+      db = Tep::SQLite.new
+      if db.open("#{TMP_DB}")
+        db.exec("CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, name TEXT)")
+        db.exec("DELETE FROM items")
+        db.prepare("INSERT INTO items (name) VALUES (?)")
+        db.bind_str(1, "alpha")
+        db.step
+        db.reset
+        db.bind_str(1, "beta")
+        db.step
+        db.reset
+        db.bind_str(1, "gamma")
+        db.step
+        db.finalize
+        db.close
+      end
+    end
+
+    # Repeated prepare_cached with the SAME sql + DIFFERENT
+    # bindings -- the cache reuse path must reset+clear_bindings
+    # so the second call's binding wins.
+    get '/cached_rebind' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      sql = "SELECT name FROM items WHERE id = ?"
+      out = ""
+      i = 1
+      while i <= 3
+        db.prepare_cached(sql)
+        db.bind_int(1, i)
+        if db.step == 1
+          if out.length > 0
+            out = out + ","
+          end
+          out = out + db.col_str(0)
+        end
+        db.finalize
+        i += 1
+      end
+      db.close
+      out
+    end
+
+    # Mix prepare + prepare_cached + prepare -- exercises both
+    # paths in alternation. Uncached prepare after a cached one
+    # must release the cached cursor via reset (NOT finalize),
+    # leaving the cache slot valid for the next prepare_cached.
+    get '/mixed_prepare' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      cached_sql = "SELECT name FROM items WHERE id = ?"
+      # First cached hit (cache miss -> populate slot)
+      db.prepare_cached(cached_sql)
+      db.bind_int(1, 1)
+      db.step
+      first = db.col_str(0)
+      db.finalize
+      # Uncached prepare in between
+      db.prepare("SELECT name FROM items WHERE id = ?")
+      db.bind_int(1, 2)
+      db.step
+      middle = db.col_str(0)
+      db.finalize
+      # Cached hit again (slot still alive)
+      db.prepare_cached(cached_sql)
+      db.bind_int(1, 3)
+      db.step
+      last = db.col_str(0)
+      db.finalize
+      db.close
+      first + "|" + middle + "|" + last
+    end
+
+    # Cache survives across a different db (per-handle scope) --
+    # the cached_sql here belongs to db1; db2 with the same SQL
+    # gets a separate cache slot.
+    get '/per_handle' do
+      sql = "SELECT name FROM items WHERE id = ?"
+      db1 = Tep::SQLite.new
+      db1.open("#{TMP_DB}")
+      db1.prepare_cached(sql)
+      db1.bind_int(1, 1)
+      db1.step
+      r1 = db1.col_str(0)
+      db1.finalize
+      db1.close   # close while a cache slot still exists for this handle
+
+      db2 = Tep::SQLite.new
+      db2.open("#{TMP_DB}")
+      db2.prepare_cached(sql)
+      db2.bind_int(1, 2)
+      db2.step
+      r2 = db2.col_str(0)
+      db2.finalize
+      db2.close
+      r1 + "|" + r2
+    end
+
+    # Smoke: a tight loop of cached calls works without leaks --
+    # exercises the cache hit path repeatedly with the same SQL.
+    get '/loop_count' do
+      db = Tep::SQLite.new
+      db.open("#{TMP_DB}")
+      sql = "SELECT count(*) FROM items"
+      n = 0
+      i = 0
+      while i < 50
+        db.prepare_cached(sql)
+        if db.step == 1
+          n = db.col_int(0)
+        end
+        db.finalize
+        i += 1
+      end
+      db.close
+      "loops=" + i.to_s + " count=" + n.to_s
+    end
+  RB
+
+  Minitest.after_run do
+    File.unlink(TMP_DB) if File.exist?(TMP_DB)
+  end
+
+  def test_cache_hit_rebinds_correctly
+    # Same SQL, three different bindings, three different rows.
+    # If clear_bindings didn't fire, the int param would leak
+    # across calls and rows would repeat.
+    res = get("/cached_rebind")
+    assert_equal "200", res.code
+    assert_equal "alpha,beta,gamma", res.body
+  end
+
+  def test_mixed_prepare_paths_coexist
+    # The uncached prepare in the middle must not invalidate the
+    # cached slot for the surrounding prepare_cached calls.
+    res = get("/mixed_prepare")
+    assert_equal "200", res.code
+    assert_equal "alpha|beta|gamma", res.body
+  end
+
+  def test_close_finalizes_cached_stmts_for_handle
+    # /per_handle opens db1, caches a stmt, closes db1, opens db2,
+    # caches the same SQL (separate slot), closes db2. If close()
+    # didn't finalize db1's cached stmt, sqlite3_close would
+    # SQLITE_BUSY and the second open would land an invalid handle.
+    res = get("/per_handle")
+    assert_equal "200", res.code
+    assert_equal "alpha|beta", res.body
+  end
+
+  def test_loop_of_cached_calls_no_leak
+    # 50 reuses of the same cached SQL. If the cache flag handling
+    # was wrong, sqlite would either leak or error out around
+    # iteration 16+ (SQLITE_MAX_STATEMENT_PARAMETERS / stack
+    # exhaustion).
+    res = get("/loop_count")
+    assert_equal "200", res.code
+    assert_match(/loops=50 count=3/, res.body)
+  end
+end

data/test/test_static.rb

@@ -0,0 +1,57 @@
+require_relative "helper"
+
+# Static file serving + custom 404 handler.
+class TestStatic < TepTest
+  app_source <<~RB
+    set :public_dir, '#{File.expand_path("../public", __dir__)}'
+
+    not_found do
+      "tep-404 " + request.path
+    end
+
+    get '/' do
+      "root"
+    end
+  RB
+
+  def test_static_text_file
+    res = get("/hello.txt")
+    assert_equal "200", res.code
+    assert_match(/text\/plain/, res["content-type"])
+    assert_match(/static file serving/, res.body)
+  end
+
+  def test_static_css
+    res = get("/style.css")
+    assert_equal "200", res.code
+    assert_equal "text/css", res["content-type"]
+  end
+
+  def test_static_x_tep_marker
+    res = get("/hello.txt")
+    assert_equal "1", res["x-tep-static"]
+  end
+
+  def test_404_for_unknown_path
+    res = get("/no-such-file.txt")
+    assert_equal "404", res.code
+  end
+
+  def test_custom_404_body
+    res = get("/no-such-file.txt")
+    assert_match(/tep-404/, res.body)
+    assert_match(%r{/no-such-file\.txt}, res.body)
+  end
+
+  def test_path_traversal_rejected
+    res = get("/../etc/passwd")
+    assert_equal "404", res.code
+    refute_match(/root:/, res.body)
+  end
+
+  def test_get_route_still_wins_over_static
+    res = get("/")
+    assert_equal "200", res.code
+    assert_equal "root", res.body
+  end
+end

data/test/test_streaming.rb

@@ -0,0 +1,96 @@
+require_relative "helper"
+
+class TestStreaming < TepTest
+  app_source <<~RB
+    require 'sinatra'
+
+    class Ticks < Tep::Streamer
+      def pump(out)
+        out.write("data: 1\\n\\n")
+        out.write("data: 2\\n\\n")
+        out.write("data: 3\\n\\n")
+      end
+    end
+
+    get '/stream' do
+      stream Ticks.new
+    end
+
+    get '/normal' do
+      "regular response"
+    end
+  RB
+
+  def test_stream_uses_chunked_encoding
+    res = get("/stream")
+    assert_equal "200", res.code
+    assert_equal "chunked", res["transfer-encoding"]
+    assert_nil res["content-length"]
+  end
+
+  def test_stream_default_content_type
+    res = get("/stream")
+    assert_match(%r{text/event-stream}, res["content-type"])
+  end
+
+  def test_stream_emits_all_chunks
+    res = get("/stream")
+    assert_equal "data: 1\n\ndata: 2\n\ndata: 3\n\n", res.body
+  end
+
+  def test_normal_route_still_buffered
+    res = get("/normal")
+    assert_equal "200", res.code
+    assert_nil res["transfer-encoding"]
+    assert_equal "16", res["content-length"]
+    assert_equal "regular response", res.body
+  end
+end
+
+# Same streaming surface under Tep::Server::Scheduled. Regression
+# guard for #90: the scheduled server's write_response had no
+# res.streaming branch, so streamed responses came back with
+# Content-Length: 0 and an empty body (the Streamer never pumped).
+class TestStreamingScheduled < TepTest
+  app_source <<~RB
+    require 'sinatra'
+
+    set :scheduler, :scheduled
+    set :workers, 1
+
+    class Ticks < Tep::Streamer
+      def pump(out)
+        out.write("data: 1\\n\\n")
+        out.write("data: 2\\n\\n")
+        out.write("data: 3\\n\\n")
+      end
+    end
+
+    get '/stream' do
+      stream Ticks.new
+    end
+
+    get '/normal' do
+      "regular response"
+    end
+  RB
+
+  def test_scheduled_stream_uses_chunked_encoding
+    res = get("/stream")
+    assert_equal "200", res.code
+    assert_equal "chunked", res["transfer-encoding"]
+    assert_nil res["content-length"]
+  end
+
+  def test_scheduled_stream_emits_all_chunks
+    res = get("/stream")
+    assert_equal "data: 1\n\ndata: 2\n\ndata: 3\n\n", res.body
+  end
+
+  def test_scheduled_normal_route_still_buffered
+    res = get("/normal")
+    assert_equal "200", res.code
+    assert_nil res["transfer-encoding"]
+    assert_equal "regular response", res.body
+  end
+end

data/test/test_unsupported.rb

@@ -0,0 +1,32 @@
+require_relative "helper"
+
+# Features Sinatra has and tep doesn't yet. Tests that have moved
+# into the supported column live in their own file (test_cookies.rb,
+# test_sessions.rb, test_streaming.rb, test_regex_routes.rb,
+# test_modular.rb, test_erb.rb, test_misc_v02.rb, test_pass.rb,
+# test_multi_filters.rb, test_optional_segments.rb,
+# test_request_methods.rb).
+class TestUnsupported < TepTest
+  app_source <<~RB
+    get '/' do
+      "tep skip stub"
+    end
+  RB
+
+  def test_haml_templates
+    skip "Haml -- depends on a gem; out of scope for spinel-AOT"
+  end
+
+  def test_helpers_block
+    skip "`helpers do ... end` -- closures not first-class in spinel; would need translator support to define methods on Tep::Handler"
+  end
+
+  def test_request_ip
+    skip "request.ip / request.remote_ip -- needs an sphttp_accept_with_peer C helper. Other Rack::Request methods (host, user_agent, scheme, ssl?, etc.) are supported -- see test_request_methods.rb."
+  end
+
+  # `@ivar` template locals are now supported -- see test_erb_ivars.rb.
+
+  # send_file, configure, pass, multiple filters, optional segments
+  # have all moved into supported and have their own test files.
+end

data/test/test_websocket.rb

@@ -0,0 +1,152 @@
+# Tep::WebSocket frame + handshake tests via a live tep app.
+# RFC 6455 reference vectors covered:
+#   - Frame encode for text + binary + close + ping + pong
+#   - Handshake accept-key compute (the §1.3 worked example)
+#   - Handshake header parsing (Upgrade / Connection / Version / Key)
+#   - Subprotocol negotiation parser
+#
+# Integration coverage (Driver + Connection over a real socket
+# round-trip) lives separately and isn't in this commit -- it needs
+# a Ruby-side WS client to wire up, which is its own dependency.
+require_relative "helper"
+
+class TestWebSocket < TepTest
+  app_source <<~'RB'
+    require "sinatra"
+
+    # Encode a small text frame and dump it as a hex string so the
+    # MRI test can check byte-by-byte. Server frames are unmasked
+    # so byte 0 = 0x81 (FIN + opcode 1), byte 1 = payload length.
+    def hex_of(s)
+      out = ""
+      i = 0
+      while i < s.length
+        b = s[i].ord & 0xff
+        out = out + ((b / 16) < 10 ? (b / 16 + 48).chr : (b / 16 + 87).chr)
+        out = out + ((b % 16) < 10 ? (b % 16 + 48).chr : (b % 16 + 87).chr)
+        i += 1
+      end
+      out
+    end
+
+    get '/frame/text_small' do
+      f = Tep::WebSocket::Frame.new(true, Tep::WebSocket::OPCODE_TEXT, "Hello")
+      hex_of(f.encode_unmasked)
+    end
+
+    get '/frame/binary_short' do
+      f = Tep::WebSocket::Frame.new(true, Tep::WebSocket::OPCODE_BINARY, "abc")
+      hex_of(f.encode_unmasked)
+    end
+
+    get '/frame/text_extended_16' do
+      payload = ""
+      i = 0
+      while i < 200
+        payload = payload + "x"
+        i += 1
+      end
+      f = Tep::WebSocket::Frame.new(true, Tep::WebSocket::OPCODE_TEXT, payload)
+      # First 4 bytes only -- enough to verify the 16-bit length
+      # encoding (0x81 0x7e 0x00 0xc8 = FIN+text, 126 marker, 200 in 16-bit).
+      hex_of(f.encode_unmasked[0, 4])
+    end
+
+    get '/frame/close_with_code' do
+      body = Tep::WebSocket::Driver.encode_close_payload(1000, "bye")
+      f = Tep::WebSocket::Frame.new(true, Tep::WebSocket::OPCODE_CLOSE, body)
+      hex_of(f.encode_unmasked)
+    end
+
+    # Handshake accept key for the RFC 6455 §1.3 worked example.
+    get '/handshake/accept_key' do
+      Crypto.sp_crypto_websocket_accept("dGhlIHNhbXBsZSBub25jZQ==")
+    end
+
+    get '/handshake/build_response_with_protocol' do
+      Tep::WebSocket::Handshake.build_response("s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", "chat")
+    end
+
+    get '/handshake/build_response_no_protocol' do
+      Tep::WebSocket::Handshake.build_response("s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", "")
+    end
+
+    get '/handshake/split_csv' do
+      parts = Tep::WebSocket::Handshake.split_csv("a, b ,c")
+      parts.join("|")
+    end
+
+    get '/frame/reserved_opcode_rejects' do
+      Tep::WebSocket::Frame.reserved_opcode?(5) ? "yes" : "no"
+    end
+
+    get '/frame/control_opcode_classifies' do
+      a = Tep::WebSocket::Frame.control_opcode?(Tep::WebSocket::OPCODE_CLOSE)  ? "y" : "n"
+      b = Tep::WebSocket::Frame.control_opcode?(Tep::WebSocket::OPCODE_TEXT)   ? "y" : "n"
+      a + b
+    end
+  RB
+
+  def test_frame_text_small_encode
+    res = get("/frame/text_small")
+    # 0x81 = FIN + opcode 1 (text), 0x05 = unmasked, 5-byte payload,
+    # then "Hello" = 48 65 6c 6c 6f.
+    assert_equal "8105" + "48656c6c6f", res.body
+  end
+
+  def test_frame_binary_short_encode
+    res = get("/frame/binary_short")
+    # 0x82 = FIN + opcode 2 (binary), 0x03 = unmasked 3-byte payload,
+    # then "abc" = 61 62 63.
+    assert_equal "8203" + "616263", res.body
+  end
+
+  def test_frame_16bit_length_marker
+    res = get("/frame/text_extended_16")
+    # 0x81 = FIN + text, 0x7e = 126 marker (16-bit length follows),
+    # 0x00 0xc8 = 200 big-endian.
+    assert_equal "817e00c8", res.body
+  end
+
+  def test_frame_close_with_code_and_reason
+    res = get("/frame/close_with_code")
+    # 0x88 = FIN + opcode 8 (close), 0x05 = 5-byte payload,
+    # 0x03 0xe8 = 1000 big-endian, then "bye" = 62 79 65.
+    assert_equal "8805" + "03e8" + "627965", res.body
+  end
+
+  def test_handshake_accept_key_rfc_6455_vector
+    res = get("/handshake/accept_key")
+    # RFC 6455 §1.3 worked example.
+    assert_equal "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=", res.body
+  end
+
+  def test_handshake_response_with_protocol
+    res = get("/handshake/build_response_with_protocol")
+    assert_includes res.body, "HTTP/1.1 101 Switching Protocols"
+    assert_includes res.body, "Upgrade: websocket"
+    assert_includes res.body, "Connection: Upgrade"
+    assert_includes res.body, "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo="
+    assert_includes res.body, "Sec-WebSocket-Protocol: chat"
+  end
+
+  def test_handshake_response_omits_protocol_when_empty
+    res = get("/handshake/build_response_no_protocol")
+    refute_includes res.body, "Sec-WebSocket-Protocol"
+  end
+
+  def test_handshake_split_csv_trims_whitespace
+    res = get("/handshake/split_csv")
+    assert_equal "a|b|c", res.body
+  end
+
+  def test_frame_reserved_opcode_predicate
+    res = get("/frame/reserved_opcode_rejects")
+    assert_equal "yes", res.body
+  end
+
+  def test_frame_control_opcode_predicate
+    res = get("/frame/control_opcode_classifies")
+    assert_equal "yn", res.body
+  end
+end