tep 0.11.0

data/test/real_world/07_bbc_rest_api.rb

@@ -0,0 +1,228 @@
+## Thing
+# RESTful API example
+# - manages single resource called Thing /thing
+# - all results (including error messages) returned as JSON (Accept header)
+
+## requires
+require 'sinatra'
+require 'json'
+require 'time'
+require 'pp'
+
+### datamapper requires
+require 'data_mapper'
+require 'dm-types'
+require 'dm-timestamps'
+require 'dm-validations'
+
+## model
+### helper modules
+#### StandardProperties
+module StandardProperties
+  def self.included(other)
+    other.class_eval do
+      property :id, other::Serial
+      # property :created_at, DateTime
+      # property :updated_at, DateTime
+    end
+  end
+end
+
+#### Validations
+module Validations
+  def valid_id?(id)
+    id && id.to_s =~ /^\d+$/
+  end
+end
+
+### Thing
+class Thing
+  include DataMapper::Resource
+  include StandardProperties
+  extend Validations
+
+  property :name, String, :required => true
+  property :status, String
+end
+
+## set up db
+env = ENV["RACK_ENV"]
+puts "RACK_ENV: #{env}"
+if env.to_s.strip == ""
+  abort "Must define RACK_ENV (used for db name)"
+end
+
+case env
+when "test"
+  DataMapper.setup(:default, "sqlite3::memory:")
+else
+  DataMapper.setup(:default, "sqlite3:#{ENV["RACK_ENV"]}.db")
+end
+
+## create schema if necessary
+DataMapper.auto_upgrade!
+
+## logger
+def logger
+  @logger ||= Logger.new(STDOUT)
+end
+
+## ThingResource application
+class ThingResource < Sinatra::Base
+  set :methodoverride, true
+
+  ## helpers
+
+  def self.put_or_post(*a, &b)
+    put *a, &b
+    post *a, &b
+  end
+
+  helpers do
+    def json_status(code, reason)
+      status code
+      {
+        :status => code,
+        :reason => reason
+      }.to_json
+    end
+
+    def accept_params(params, *fields)
+      h = { }
+      fields.each do |name|
+        h[name] = params[name] if params[name]
+      end
+      h
+    end
+  end
+
+  ## GET /thing - return all things
+  get "/thing/?", :provides => :json do
+    content_type :json
+
+    if things = Thing.all
+      things.to_json
+    else
+      json_status 404, "Not found"
+    end
+  end
+
+  ## GET /thing/:id - return thing with specified id
+  get "/thing/:id", :provides => :json do
+    content_type :json
+
+    # check that :id param is an integer
+    if Thing.valid_id?(params[:id])
+      if thing = Thing.first(:id => params[:id].to_i)
+        thing.to_json
+      else
+        json_status 404, "Not found"
+      end
+    else
+      # TODO: find better error for this (id not an integer)
+      json_status 404, "Not found"
+    end
+  end
+
+  ## POST /thing/ - create new thing
+  post "/thing/?", :provides => :json do
+    content_type :json
+
+    new_params = accept_params(params, :name, :status)
+    thing = Thing.new(new_params)
+    if thing.save
+      headers["Location"] = "/thing/#{thing.id}"
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.5
+      status 201 # Created
+      thing.to_json
+    else
+      json_status 400, thing.errors.to_hash
+    end
+  end
+
+  ## PUT /thing/:id/:status - change a thing's status
+  put_or_post "/thing/:id/status/:status", :provides => :json do
+    content_type :json
+
+    if Thing.valid_id?(params[:id])
+      if thing = Thing.first(:id => params[:id].to_i)
+        thing.status = params[:status]
+        if thing.save
+          thing.to_json
+        else
+          json_status 400, thing.errors.to_hash
+        end
+      else
+        json_status 404, "Not found"
+      end
+    else
+      json_status 404, "Not found"
+    end
+  end
+
+  ## PUT /thing/:id - change or create a thing
+  put "/thing/:id", :provides => :json do
+    content_type :json
+
+    new_params = accept_params(params, :name, :status)
+
+    if Thing.valid_id?(params[:id])
+      if thing = Thing.first_or_create(:id => params[:id].to_i)
+        thing.attributes = thing.attributes.merge(new_params)
+        if thing.save
+          thing.to_json
+        else
+          json_status 400, thing.errors.to_hash
+        end
+      else
+        json_status 404, "Not found"
+      end
+    else
+      json_status 404, "Not found"
+    end
+  end
+
+  ## DELETE /thing/:id - delete a specific thing
+  delete "/thing/:id/?", :provides => :json do
+    content_type :json
+
+    if thing = Thing.first(:id => params[:id].to_i)
+      thing.destroy!
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.7
+      status 204 # No content
+    else
+      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.2
+      # Note: section 9.1.2 states:
+      #   Methods can also have the property of "idempotence" in that
+      #   (aside from error or expiration issues) the side-effects of
+      #   N > 0 identical requests is the same as for a single
+      #   request.
+      # i.e that the /side-effects/ are idempotent, not that the
+      # result of the /request/ is idempotent, so I think it's correct
+      # to return a 404 here.
+      json_status 404, "Not found"
+    end
+  end
+
+  ## misc handlers: error, not_found, etc.
+  get "*" do
+    status 404
+  end
+
+  put_or_post "*" do
+    status 404
+  end
+
+  delete "*" do
+    status 404
+  end
+
+  not_found do
+    json_status 404, "Not found"
+  end
+
+  error do
+    json_status 500, env['sinatra.error'].message
+  end
+
+end

data/test/real_world/07_sklise_things.rb

@@ -0,0 +1,109 @@
+# Require the bundler gem and then call Bundler.require to load in all gems
+# listed in Gemfile.
+require 'bundler'
+Bundler.require
+
+# Setup DataMapper with a database URL. On Heroku, ENV['DATABASE_URL'] will be
+# set, when working locally this line will fall back to using SQLite in the
+# current directory.
+DataMapper.setup(:default, ENV['DATABASE_URL'] || "sqlite://#{Dir.pwd}/development.sqlite")
+
+# Define a simple DataMapper model.
+class Thing
+  include DataMapper::Resource
+
+  property :id, Serial, :key => true
+  property :created_at, DateTime
+  property :title, String, :length => 255
+  property :description, Text
+end
+
+# Finalize the DataMapper models.
+DataMapper.finalize
+
+# Tell DataMapper to update the database according to the definitions above.
+DataMapper.auto_upgrade!
+
+get '/' do
+  send_file './public/index.html'
+end
+
+# Route to show all Things, ordered like a blog
+get '/things' do
+  content_type :json
+  @things = Thing.all(:order => :created_at.desc)
+
+  @things.to_json
+end
+
+# CREATE: Route to create a new Thing
+post '/things' do
+  content_type :json
+
+  # These next commented lines are for if you are using Backbone.js
+  # JSON is sent in the body of the http request. We need to parse the body
+  # from a string into JSON
+  # params_json = JSON.parse(request.body.read)
+
+  # If you are using jQuery's ajax functions, the data goes through in the
+  # params.
+  @thing = Thing.new(params)
+
+  if @thing.save
+    @thing.to_json
+  else
+    halt 500
+  end
+end
+
+# READ: Route to show a specific Thing based on its `id`
+get '/things/:id' do
+  content_type :json
+  @thing = Thing.get(params[:id].to_i)
+
+  if @thing
+    @thing.to_json
+  else
+    halt 404
+  end
+end
+
+# UPDATE: Route to update a Thing
+put '/things/:id' do
+  content_type :json
+
+  # These next commented lines are for if you are using Backbone.js
+  # JSON is sent in the body of the http request. We need to parse the body
+  # from a string into JSON
+  # params_json = JSON.parse(request.body.read)
+
+  # If you are using jQuery's ajax functions, the data goes through in the
+  # params.
+
+  @thing = Thing.get(params[:id].to_i)
+  @thing.update(params)
+
+  if @thing.save
+    @thing.to_json
+  else
+    halt 500
+  end
+end
+
+# DELETE: Route to delete a Thing
+delete '/things/:id/delete' do
+  content_type :json
+  @thing = Thing.get(params[:id].to_i)
+
+  if @thing.destroy
+    {:success => "ok"}.to_json
+  else
+    halt 500
+  end
+end
+
+# If there are no Things in the database, add a few.
+if Thing.count == 0
+  Thing.create(:title => "Test Thing One", :description => "Sometimes I eat pizza.")
+  Thing.create(:title => "Test Thing Two", :description => "Other times I eat cookies.")
+end

data/test/real_world/08_jwd83_helloworld.rb

@@ -0,0 +1,56 @@
+# boilerplate includes
+require 'rubygems'
+require 'bundler'
+
+# remainder of includes handled by bundler and the Gemfile
+Bundler.require
+
+
+# define settings
+configure do
+    set :version, "0.0.1"
+end
+
+# define helpers
+helpers do
+  def h(text)
+    # used to safely escape html
+    Rack::Utils.escape_html(text)
+  end
+end
+
+# create routes
+get '/' do
+    erb :index
+end
+
+get '/welcome/:name' do
+    @name = params[:name]
+    erb :welcomer
+end
+
+get '/goodbye/:name' do
+    @name = params[:name]
+    erb :leaver
+end
+
+# below here we have templates
+__END__
+@@welcomer
+<h3>Using the "welcomer" inline template</h3>
+<h1>
+
+    Greetings <%=h @name %>
+</h1>
+<h5>
+    Version <%= settings.version %>
+</h5>
+
+@@leaver
+<h3>Using the "leaver" inline template</h3>
+<h1>
+    Seeya later <%=h @name %>
+</h1>
+<h5>
+    Version <%= settings.version %>
+</h5>

data/test/run_all.rb

@@ -0,0 +1,7 @@
+# Drive-all: run every test_*.rb under test/ in one process. Use
+# `make test` or `ruby test/run_all.rb`.
+require_relative "helper"
+
+Dir[File.join(__dir__, "test_*.rb")].sort.each do |f|
+  require_relative File.basename(f)
+end

data/test/run_parallel.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# run_parallel.rb -- run each test/test_*.rb in its own process, in
+# parallel, and aggregate the per-file summaries into one overall line.
+#
+# Why this exists: `make test` (test/run_all.rb) is serial and runs in
+# one process because the per-class boot harness expects one thread
+# touching state at a time. The wall time is dominated by ~54 test
+# classes each doing a `bin/tep build` (~12 s of spinel codegen per
+# class) sequentially -- around 11 min of pure compilation on the gx10.
+# Separate processes sidestep the threading constraint cleanly: each
+# worker runs one test file (its own minitest), with its own port base,
+# so N classes compile + run concurrently.
+#
+#   make test-parallel
+#   TEP_TEST_PROCS=8 make test-parallel    # cap concurrency (default: Etc.nprocessors)
+#
+# Output: one tick (`✓` / `✗`) per test file with a per-file run/assertion
+# tally, full output dumped for failing files, then one aggregate
+# summary line. Exit 0 iff every file passed.
+require "etc"
+require "shellwords"
+
+ROOT  = File.expand_path("..", __dir__)
+TESTS = Dir[File.join(ROOT, "test", "test_*.rb")].sort
+PROCS = (ENV["TEP_TEST_PROCS"] || Etc.nprocessors.to_s).to_i
+
+# Each test class boots its own app on a port from the harness's
+# next_port counter; spacing 100 per file is comfy headroom (test
+# files have at most a couple of classes).
+PORT_BASE_STEP = 100
+PORT_BASE_START = (ENV["TEP_TEST_PORT_BASE"] || "4900").to_i
+
+queue   = TESTS.each_with_index.to_a
+mutex   = Mutex.new
+results = []
+
+workers = PROCS.times.map do
+  Thread.new do
+    loop do
+      job = mutex.synchronize { queue.shift }
+      break unless job
+      path, idx = job
+      port_base = PORT_BASE_START + idx * PORT_BASE_STEP
+      env = { "TEP_TEST_PORT_BASE" => port_base.to_s }
+      # Honor TEP_SKIP_SPINEL_FRESH if the caller set it (Makefile
+      # handles the freshness check once; per-process would be wasteful).
+      ["TEP_SKIP_SPINEL_FRESH", "SPINEL", "TEP_KEEP_TMP"].each do |k|
+        env[k] = ENV[k] if ENV[k]
+      end
+      output = nil
+      start  = Time.now
+      IO.popen(env, ["ruby", path], err: [:child, :out]) { |io| output = io.read }
+      ok     = $?.success?
+      elapsed = Time.now - start
+      mutex.synchronize do
+        results << { path: path, ok: ok, output: output, elapsed: elapsed }
+      end
+    end
+  end
+end
+workers.each(&:join)
+
+# Sort so the printed order is deterministic (queue order), not
+# completion order.
+results.sort_by! { |r| TESTS.index(r[:path]) }
+
+totals = { runs: 0, assertions: 0, failures: 0, errors: 0, skips: 0 }
+results.each do |r|
+  m = r[:output].to_s.match(/(\d+) runs, (\d+) assertions, (\d+) failures, (\d+) errors, (\d+) skips/)
+  if m
+    totals[:runs]       += m[1].to_i
+    totals[:assertions] += m[2].to_i
+    totals[:failures]   += m[3].to_i
+    totals[:errors]     += m[4].to_i
+    totals[:skips]      += m[5].to_i
+  end
+  rel  = r[:path].sub(ROOT + "/", "")
+  mark = r[:ok] ? "✓" : "✗"   # ✓ / ✗
+  tally = m ? " #{m[1]}r/#{m[2]}a/#{m[3]}f/#{m[4]}e/#{m[5]}s" : ""
+  puts "%s %s%s  [%.1fs]" % [mark, rel, tally, r[:elapsed]]
+  unless r[:ok]
+    puts r[:output]
+  end
+end
+
+puts ""
+puts "%d runs, %d assertions, %d failures, %d errors, %d skips" % \
+  [totals[:runs], totals[:assertions], totals[:failures], totals[:errors], totals[:skips]]
+exit(results.all? { |r| r[:ok] } ? 0 : 1)

data/test/spinel_scheduled_burst_segv_repro.rb

@@ -0,0 +1,33 @@
+# Minimal repro for the Tep::Server::Scheduled segfault under
+# concurrent HTTP/1.1 keep-alive bursts. Stand-alone -- doesn't
+# require PG or any other battery; the segfault reproduces with
+# the plainest possible "hello world" route.
+#
+# Build + run:
+#   bin/tep build test/spinel_scheduled_burst_segv_repro.rb -o /tmp/repro
+#   /tmp/repro -p 4985 &
+#   # Drive it with two concurrent persistent-keepalive clients:
+#   ruby -e '
+#     require "net/http"; require "uri"
+#     uri = URI("http://127.0.0.1:4985/hi")
+#     2.times.map { Thread.new {
+#       Net::HTTP.start(uri.host, uri.port) { |h|
+#         100.times { h.request(Net::HTTP::Get.new(uri.path)) }
+#       }
+#     } }.each(&:join)
+#   '
+#
+# Observed (spinel master 6513d2d, 2026-05-20): server dies with
+# SIGSEGV (SEGV_ACCERR) somewhere around request ~60-80. strace
+# shows the segfault happens right after a normal-looking recvfrom
+# returns the HTTP request bytes -- the crash is in the Ruby /
+# spinel runtime between recv and the handler dispatch + write.
+#
+# Default Tep::Server (prefork-blocking) handles the same burst
+# fine; the segfault is specific to Tep::Server::Scheduled.
+require_relative "../lib/tep"
+set :scheduler, :scheduled
+
+get '/hi' do
+  "hello"
+end

data/test/test_api_gateway.rb

@@ -0,0 +1,76 @@
+require_relative "helper"
+
+# examples/api_gateway integration: a non-streaming Tep::Proxy that
+# gates on a capability (before_forward short-circuit), swaps the
+# upstream credential, and stamps observability headers in
+# after_forward -- which must run on BOTH the forwarded and the
+# short-circuited (denied) paths.
+#
+# Self-call shape (scheduled + workers=1, like test_http/test_proxy):
+# the upstream echoes the Authorization header it received, so the
+# test can confirm the credential swap; the gateway is the
+# subclass-override form, built per-request with the runtime port
+# (the example app uses the block DSL).
+class TestApiGateway < TepTest
+  app_source <<~RB
+    require 'sinatra'
+
+    set :scheduler, :scheduled
+    set :workers, 1
+
+    # Upstream: echo the Authorization header the gateway attached.
+    get '/up/echo' do
+      "auth=" + req.req_headers["authorization"]
+    end
+
+    # Grant :call_upstream when the request carries ?auth=ok (stands in
+    # for the Auth battery populating req.identity).
+    before do
+      if params[:auth] == "ok"
+        req.identity = Tep::Identity.new("client:test", nil, [:call_upstream])
+      end
+    end
+
+    class ApiGw < Tep::Proxy
+      def rewrite_path(path)
+        "/up/echo"
+      end
+      def before_forward(req, res, ureq)
+        if !req.identity.may?(:call_upstream)
+          res.set_status(403)
+          res.set_body("denied")
+          true
+        else
+          ureq.set_header("Authorization", "Bearer upstream-secret")
+          false
+        end
+      end
+      def after_forward(req, ures, res)
+        res.headers["X-Proxy-Status"] = ures.status.to_s
+        0
+      end
+    end
+
+    get '/gw/:port' do
+      ApiGw.new("http://127.0.0.1:" + params[:port]).handle(req, res)
+      res.body
+    end
+  RB
+
+  def test_forwards_with_credential_when_capable
+    res = get("/gw/#{@port}?auth=ok")
+    assert_equal "200", res.code
+    # Upstream saw the gateway's attached credential, not the client's.
+    assert_equal "auth=Bearer upstream-secret", res.body
+    # after_forward stamped the real upstream status.
+    assert_equal "200", res["X-Proxy-Status"]
+  end
+
+  def test_rejects_without_capability
+    res = get("/gw/#{@port}")           # no ?auth=ok -> no capability
+    assert_equal "403", res.code
+    assert_equal "denied", res.body
+    # after_forward ran on the short-circuit path too (ures.status 0).
+    assert_equal "0", res["X-Proxy-Status"]
+  end
+end