tep 0.11.0

data/test/test_parallel.rb

@@ -0,0 +1,102 @@
+require_relative "helper"
+
+# Tep::Parallel -- fork-based fan-out. Boots a tep app that runs a
+# Worker against a small input list and checks both the
+# result-collecting and fire-and-forget shapes.
+class TestParallel < TepTest
+
+  app_source <<~RB
+    require 'sinatra'
+
+    class Doubler < Tep::ParallelWorker
+      def run(item)
+        # Item is a small integer-as-string; double it and emit the
+        # child's pid so the test can verify each result came from a
+        # distinct process.
+        n = item.to_i
+        (n * 2).to_s + ":" + Sock.sphttp_getpid.to_s
+      end
+    end
+
+    class Echoer < Tep::ParallelWorker
+      def run(item)
+        item
+      end
+    end
+
+    # Two workers so we can ensure the result order matches the
+    # input order even though forks complete out of order.
+    get '/map_doubled' do
+      items = ["1", "2", "3", "4"]
+      p = Tep::Parallel.new(Doubler.new)
+      results = p.map_processes(items)
+      out = ""
+      i = 0
+      while i < results.length
+        if out.length > 0
+          out = out + ","
+        end
+        out = out + results[i]
+        i += 1
+      end
+      out
+    end
+
+    get '/map_echo' do
+      items = ["alpha", "beta", "gamma"]
+      p = Tep::Parallel.new(Echoer.new)
+      results = p.map_processes(items)
+      results.join("|")
+    end
+
+    get '/each' do
+      # Fire-and-forget: writes a sentinel file in each child;
+      # parent then asserts the files exist.
+      items = ["x", "y"]
+      p = Tep::Parallel.new(FileSentinel.new)
+      p.each_process(items)
+      ok = "yes"
+      if Tep::Shell.read("/tmp/tep_par_test_each_x").length == 0
+        ok = "missing_x"
+      end
+      if Tep::Shell.read("/tmp/tep_par_test_each_y").length == 0
+        ok = "missing_y"
+      end
+      Tep::Shell.run("rm -f /tmp/tep_par_test_each_x /tmp/tep_par_test_each_y")
+      ok
+    end
+
+    class FileSentinel < Tep::ParallelWorker
+      def run(item)
+        File.write("/tmp/tep_par_test_each_" + item, "done")
+        ""
+      end
+    end
+  RB
+
+  def test_map_processes_returns_ordered_results
+    res = get("/map_doubled")
+    assert_equal "200", res.code
+    body  = res.body
+    parts = body.split(",")
+    assert_equal 4, parts.length
+    # Each entry: "doubled:pid". The doubled values must be 2,4,6,8.
+    doubled = parts.map { |s| s.split(":")[0] }
+    assert_equal %w[2 4 6 8], doubled
+    # The pids should all be distinct -- one process per item.
+    pids = parts.map { |s| s.split(":")[1] }
+    assert_equal pids.uniq.length, pids.length, "expected distinct child pids, got #{pids.inspect}"
+  end
+
+  def test_map_processes_preserves_strings
+    res = get("/map_echo")
+    assert_equal "200", res.code
+    assert_equal "alpha|beta|gamma", res.body
+  end
+
+  def test_each_process_runs_workers_for_side_effects
+    res = get("/each")
+    assert_equal "200", res.code
+    assert_equal "yes", res.body
+  end
+end

data/test/test_params.rb

@@ -0,0 +1,99 @@
+require_relative "helper"
+
+# Sinatra-style params: path captures, query string, form body merging.
+class TestParams < TepTest
+  app_source <<~RB
+    get '/path/:a/:b' do
+      "" + params[:a] + "/" + params[:b]
+    end
+
+    get '/q' do
+      "" + params[:foo]
+    end
+
+    get '/multi' do
+      "" + params[:a] + "+" + params[:b]
+    end
+
+    post '/form' do
+      "" + params[:name] + "=" + params[:age]
+    end
+
+    post '/multipart' do
+      "" + params[:name] + "=" + params[:age]
+    end
+
+    get '/encoded/:name' do
+      "" + params[:name]
+    end
+
+    get '/missing' do
+      v = params[:nope]
+      v.length.to_s + ":" + v
+    end
+
+    get '/q-and-path/:id' do
+      "" + params[:id] + "+" + params[:tag]
+    end
+  RB
+
+  def test_path_capture_two
+    res = get("/path/foo/bar")
+    assert_equal "foo/bar", res.body
+  end
+
+  def test_query_single
+    res = get("/q?foo=hello")
+    assert_equal "hello", res.body
+  end
+
+  def test_query_multiple
+    res = get("/multi?a=1&b=2")
+    assert_equal "1+2", res.body
+  end
+
+  def test_form_body
+    res = post("/form", "name=alice&age=30",
+               "Content-Type" => "application/x-www-form-urlencoded")
+    assert_equal "alice=30", res.body
+  end
+
+  def test_multipart_body
+    # Browsers send multipart/form-data for any form using FormData
+    # or carrying a file input. The text fields land in req.params;
+    # file-upload parts are skipped in v1.
+    bnd  = "----TepTestBoundary"
+    body = "--#{bnd}\r\n" \
+           "Content-Disposition: form-data; name=\"name\"\r\n" \
+           "\r\n" \
+           "alice\r\n" \
+           "--#{bnd}\r\n" \
+           "Content-Disposition: form-data; name=\"age\"\r\n" \
+           "\r\n" \
+           "30\r\n" \
+           "--#{bnd}--\r\n"
+    res = post("/multipart", body,
+               "Content-Type" => "multipart/form-data; boundary=#{bnd}")
+    assert_equal "alice=30", res.body
+  end
+
+  def test_url_encoded_path
+    res = get("/encoded/hello%20world")
+    assert_equal "hello world", res.body
+  end
+
+  def test_url_encoded_plus
+    res = get("/q?foo=hello+world")
+    assert_equal "hello world", res.body
+  end
+
+  def test_missing_param_is_empty_string
+    res = get("/missing")
+    assert_equal "0:", res.body
+  end
+
+  def test_query_overlays_path
+    res = get("/q-and-path/42?tag=ruby")
+    assert_equal "42+ruby", res.body
+  end
+end

data/test/test_pass.rb

@@ -0,0 +1,42 @@
+require_relative "helper"
+
+# `pass` skips to the next matching route. Sinatra raises
+# Sinatra::Pass internally; tep just sets a flag and the dispatcher
+# walks to the next match.
+class TestPass < TepTest
+  app_source <<~RB
+    require 'sinatra'
+
+    # First definition wins, but it can pass for `/admin/special`.
+    get '/admin/:section' do
+      pass if params[:section] == "special"
+      "default admin: " + params[:section]
+    end
+
+    get '/admin/special' do
+      "special admin handler"
+    end
+
+    # If every match passes, default 404 fires.
+    get '/skip' do
+      pass
+    end
+  RB
+
+  def test_pass_falls_through_to_next_match
+    res = get("/admin/special")
+    assert_equal "200", res.code
+    assert_equal "special admin handler", res.body
+  end
+
+  def test_no_pass_returns_first_match
+    res = get("/admin/users")
+    assert_equal "200", res.code
+    assert_equal "default admin: users", res.body
+  end
+
+  def test_pass_with_no_more_matches_404s
+    res = get("/skip")
+    assert_equal "404", res.code
+  end
+end

data/test/test_password.rb

@@ -0,0 +1,101 @@
+require_relative "helper"
+
+# Tep::Password -- PBKDF2-SHA256 password hashing.
+class TestPassword < TepTest
+  app_source <<~RB
+    require 'sinatra'
+
+    post '/hash' do
+      res.headers["Content-Type"] = "text/plain"
+      pwd = Tep::Json.get_str(req.raw_body, "password")
+      Tep::Password.hash(pwd)
+    end
+
+    post '/verify' do
+      res.headers["Content-Type"] = "text/plain"
+      pwd = Tep::Json.get_str(req.raw_body, "password")
+      hash = Tep::Json.get_str(req.raw_body, "hash")
+      Tep::Password.verify(pwd, hash) ? "ok" : "bad"
+    end
+
+    post '/split' do
+      res.headers["Content-Type"] = "text/plain"
+      parts = Tep::Password.split4(req.raw_body)
+      parts[0] + "|" + parts[1] + "|" + parts[2] + "|" + parts[3]
+    end
+
+    post '/random' do
+      res.headers["Content-Type"] = "text/plain"
+      Crypto.sp_crypto_random_b64url(16)
+    end
+  RB
+
+  def issue_hash(pwd)
+    post("/hash", %({"password":"#{pwd}"})).body.strip
+  end
+
+  def verify_pwd(pwd, hash)
+    body = '{"password":"' + pwd + '","hash":"' + hash + '"}'
+    post("/verify", body).body.strip
+  end
+
+  def test_hash_format
+    h = issue_hash("hunter2")
+    # pbkdf2-sha256$<iters>$<salt>$<derived>
+    parts = h.split("$")
+    assert_equal 4, parts.length
+    assert_equal "pbkdf2-sha256", parts[0]
+    assert_equal "200000", parts[1]
+    assert parts[2].length > 0, "salt should be non-empty"
+    assert parts[3].length > 0, "derived should be non-empty"
+  end
+
+  def test_verify_good_password
+    h = issue_hash("hunter2")
+    assert_equal "ok", verify_pwd("hunter2", h)
+  end
+
+  def test_verify_wrong_password
+    h = issue_hash("hunter2")
+    assert_equal "bad", verify_pwd("not-the-password", h)
+  end
+
+  def test_random_salt_per_hash
+    h1 = issue_hash("same-password")
+    h2 = issue_hash("same-password")
+    refute_equal h1, h2, "two hashes of the same password should differ (random salt)"
+    # but BOTH must verify
+    assert_equal "ok", verify_pwd("same-password", h1)
+    assert_equal "ok", verify_pwd("same-password", h2)
+  end
+
+  def test_malformed_hash_returns_bad
+    assert_equal "bad", verify_pwd("anything", "not-a-real-hash")
+    assert_equal "bad", verify_pwd("anything", "pbkdf2-sha256$bad")
+    assert_equal "bad", verify_pwd("anything", "")
+  end
+
+  def test_random_b64url_distinct
+    r1 = post("/random", "").body.strip
+    r2 = post("/random", "").body.strip
+    refute_equal r1, r2
+    # 16 bytes -> 22 b64url chars (no padding).
+    assert_equal 22, r1.length
+  end
+
+  def test_split4_basic
+    res = post("/split", "a$b$c$d")
+    assert_equal "a|b|c|d", res.body.strip
+  end
+
+  def test_split4_with_empty_segments
+    res = post("/split", "$$c$d")
+    assert_equal "||c|d", res.body.strip
+  end
+
+  def test_split4_short_input
+    # Fewer than 3 separators -- trailing slots stay "".
+    res = post("/split", "x$y")
+    assert_equal "x|y||", res.body.strip
+  end
+end