paivana

test_reverse_proxy.sh (22113B)

---

 #!/bin/bash
 #
 # Reverse-proxy integration tests for paivana.
 #
 # Starts upstream HTTP servers (one per language: C/MHD, Go, Python, Rust)
 # and a paivana-httpd instance running with -n (paywall disabled), then
 # exercises the reverse-proxy behaviors with curl, wget, and a custom
 # libcurl / raw-socket pipelining client.
 #
 # Progress markers: each test prints "<description> " with no newline,
 # then "OK" on pass or "FAIL: <detail>" on failure.  Failure exits
 # non-zero, which make(1) treats as a TEST FAILURE.
 #
 # Environment variables honored:
 #   PAIVANA_HTTPD   path to paivana-httpd binary (default: built
 #                   in the sibling src/backend tree)
 #   SRCDIR          source dir containing .py / .rs / .go sources
 #                   (default: directory of this script)
 #   BUILDDIR        directory holding upstream_mhd, upstream_go,
 #                   upstream_rs, pipeline_client (default: $PWD)
 #   KEEP_TMP=1      keep the scratch dir and log files after exit
 #
 set -u
 
 function die() {
     echo "FAIL: $*" >&2
     exit 1
 }
 
 function msg() {
     printf '%s ' "$*"
 }
 
 function ok() {
     echo "OK"
 }
 
 function fail() {
     echo "FAIL: $*"
     dump_logs
     exit 1
 }
 
 function here() {
     cd -- "$(dirname -- "$0")" && pwd
 }
 
 SRCDIR="${SRCDIR:-$(here)}"
 BUILDDIR="${BUILDDIR:-$PWD}"
 
 # Default to the in-tree build path.
 PAIVANA_HTTPD="${PAIVANA_HTTPD:-$BUILDDIR/../backend/paivana-httpd}"
 if [ ! -x "$PAIVANA_HTTPD" ];
 then
     # Try the source layout (e.g. when tests are run from source tree)
     alt="$SRCDIR/../backend/paivana-httpd"
     if [ -x "$alt" ];
     then
         PAIVANA_HTTPD="$alt"
     fi
 fi
 
 if [ ! -x "$PAIVANA_HTTPD" ];
 then
     echo "SKIP: paivana-httpd binary not found (looked at $PAIVANA_HTTPD)" >&2
     exit 77
 fi
 
 # Binaries/commands for upstreams
 UPSTREAM_MHD="$BUILDDIR/upstream_mhd"
 UPSTREAM_GO="$BUILDDIR/upstream_go"
 UPSTREAM_RS="$BUILDDIR/upstream_rs"
 PIPELINE_CLIENT="$BUILDDIR/pipeline_client"
 
 # Ports (fixed, but we still wait/retry binding; if they're busy the
 # test bails out early so the user can rerun.)
 PAIVANA_PORT=18500
 MHD_PORT=18401
 GO_PORT=18402
 PY_PORT=18403
 RS_PORT=18404
 DEAD_PORT=18499   # nothing should be listening here
 
 TMPDIR="$(mktemp -d -t paivana-tests.XXXXXX)"
 LOGDIR="$TMPDIR/logs"
 mkdir -p "$LOGDIR"
 
 # paivana normally resolves its config.d via the install prefix.
 # Tests run against the uninstalled build tree, so point the
 # project's base-config override at an empty directory: no
 # auxiliary config snippets are needed for reverse-proxy tests.
 BASE_CONFIG_DIR="$TMPDIR/configd"
 mkdir -p "$BASE_CONFIG_DIR"
 export PAIVANA_BASE_CONFIG="$BASE_CONFIG_DIR"
 
 PIDS=()
 PAIVANA_PID=""
 
 function dump_logs() {
     echo "-- logs in $LOGDIR --" >&2
     for f in "$LOGDIR"/*.log; do
         [ -e "$f" ] || continue
         echo "==> $f <==" >&2
         tail -n 40 "$f" >&2
     done
 }
 
 function cleanup() {
     set +e
     for p in "${PIDS[@]:-}";
     do
         [ -n "$p" ] && kill -TERM "$p" 2>/dev/null
     done
     [ -n "$PAIVANA_PID" ] && kill -TERM "$PAIVANA_PID" 2>/dev/null
     # Give them a moment to exit cleanly
     sleep 0.2
     for p in "${PIDS[@]:-}";
     do
         [ -n "$p" ] && kill -KILL "$p" 2>/dev/null
     done
     [ -n "$PAIVANA_PID" ] && kill -KILL "$PAIVANA_PID" 2>/dev/null
     if [ "${KEEP_TMP:-0}" = "1" ];
     then
         echo "Temp files kept in $TMPDIR" >&2
     else
         rm -rf "$TMPDIR"
     fi
 }
 trap cleanup EXIT
 trap 'echo "FAIL: interrupted" >&2; exit 1' INT TERM
 
 function wait_for_port() {
     # Block until a TCP port accepts a connection (max ~5s).
     # NOTE: must run the /dev/tcp probe in a subshell — `exec` on the
     # parent shell with a failing redirection would terminate bash in
     # non-interactive mode (the 2>/dev/null does not suppress that).
     local host="$1" port="$2" tries=50
     while [ "$tries" -gt 0 ];
     do
         if ( exec 7<>"/dev/tcp/$host/$port" ) 2>/dev/null;
         then
             return 0
         fi
         sleep 0.1
         tries=$((tries - 1))
     done
     return 1
 }
 
 # Start a background upstream; record pid in PIDS.
 function start_bg() {
     local name="$1" port="$2"; shift 2
     local log="$LOGDIR/$name.log"
     ( exec "$@" "$port" ) >"$log" 2>&1 &
     local pid=$!
     PIDS+=("$pid")
     if ! wait_for_port 127.0.0.1 "$port";
     then
         echo "FAIL: $name did not start on port $port" >&2
         tail -n 20 "$log" >&2
         exit 1
     fi
 }
 
 function start_paivana() {
     # $1 = upstream base URL
     local dest="$1"
     local cfg="$TMPDIR/paivana.conf"
     sed -e "s|@DEST@|$dest|g" -e "s|@PORT@|$PAIVANA_PORT|g" \
         "$SRCDIR/test_reverse_proxy.conf.in" > "$cfg"
     local log="$LOGDIR/paivana.log"
     ( exec "$PAIVANA_HTTPD" -c "$cfg" -n -L WARNING ) >"$log" 2>&1 &
     PAIVANA_PID=$!
     if ! wait_for_port 127.0.0.1 "$PAIVANA_PORT";
     then
         echo "FAIL: paivana-httpd did not start on port $PAIVANA_PORT" >&2
         tail -n 20 "$log" >&2
         exit 1
     fi
 }
 
 function stop_paivana() {
     if [ -n "$PAIVANA_PID" ];
     then
         kill -TERM "$PAIVANA_PID" 2>/dev/null
         wait "$PAIVANA_PID" 2>/dev/null
         PAIVANA_PID=""
     fi
 }
 
 # Start all upstreams that we have binaries for.
 function start_upstreams() {
     start_bg mhd "$MHD_PORT" "$UPSTREAM_MHD"
     if [ -x "$UPSTREAM_GO" ];
     then
         start_bg go "$GO_PORT" "$UPSTREAM_GO"
     else
         echo "NOTE: upstream_go not built, skipping Go upstream tests" >&2
         GO_PORT=""
     fi
     if [ -x "$UPSTREAM_RS" ];
     then
         start_bg rs "$RS_PORT" "$UPSTREAM_RS"
     else
         echo "NOTE: upstream_rs not built, skipping Rust upstream tests" >&2
         RS_PORT=""
     fi
     if command -v python3 >/dev/null 2>&1;
     then
         local log="$LOGDIR/py.log"
         ( exec python3 "$SRCDIR/upstream_py.py" "$PY_PORT" ) >"$log" 2>&1 &
         PIDS+=("$!")
         if ! wait_for_port 127.0.0.1 "$PY_PORT";
         then
             echo "FAIL: upstream_py did not start on port $PY_PORT" >&2
             tail -n 20 "$log" >&2
             exit 1
         fi
     else
         echo "NOTE: python3 not available, skipping Python upstream tests" >&2
         PY_PORT=""
     fi
 }
 
 ######################################################################
 # Test helpers
 ######################################################################
 
 PAIVANA_URL() { echo "http://127.0.0.1:$PAIVANA_PORT$1"; }
 
 # GET via curl; verifies status code and a substring of the body.
 function test_get() {
     local desc="$1" path="$2" want_status="$3" want_sub="$4"
     msg "$desc"
     local out status
     out="$(curl -sS -o "$TMPDIR/body" -w '%{http_code}' "$(PAIVANA_URL "$path")" 2>"$TMPDIR/err")" \
         || { fail "curl: $(cat "$TMPDIR/err")"; }
     status="$out"
     [ "$status" = "$want_status" ] || fail "status=$status want=$want_status"
     if [ -n "$want_sub" ] && ! grep -q -- "$want_sub" "$TMPDIR/body";
     then
         fail "body missing substring '$want_sub' (got: $(tr -d '\n' <"$TMPDIR/body" | head -c 120))"
     fi
     ok
 }
 
 # HEAD
 function test_head() {
     local desc="$1" path="$2" want_status="$3"
     msg "$desc"
     local status
     status="$(curl -sS -I -o /dev/null -w '%{http_code}' "$(PAIVANA_URL "$path")" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     [ "$status" = "$want_status" ] || fail "status=$status want=$want_status"
     ok
 }
 
 # Generic method with optional body; checks status and body substring.
 function test_method() {
     local desc="$1" method="$2" path="$3" body="$4" want_status="$5" want_sub="$6"
     msg "$desc"
     local args=(-sS -o "$TMPDIR/body" -w '%{http_code}' -X "$method" "$(PAIVANA_URL "$path")")
     if [ -n "$body" ];
     then
         args+=(--data-binary "@$body")
     fi
     local status
     status="$(curl "${args[@]}" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     [ "$status" = "$want_status" ] || \
         fail "status=$status want=$want_status; body=$(head -c 200 "$TMPDIR/body")"
     if [ -n "$want_sub" ] && ! grep -q -- "$want_sub" "$TMPDIR/body";
     then
         fail "body missing substring '$want_sub' (got: $(head -c 200 "$TMPDIR/body"))"
     fi
     ok
 }
 
 ######################################################################
 # Test battery — runs against whichever upstream we've pointed
 # paivana at.
 ######################################################################
 
 function run_battery() {
     local label="$1"
 
     test_get "[$label] GET /hello (basic proxy pass-through)" \
         /hello 200 "Hello from"
 
     test_get "[$label] GET /status/201 (2xx status forwarding)" \
         /status/201 201 "status 201"
 
     test_get "[$label] GET /status/404 (4xx status forwarding)" \
         /status/404 404 "status 404"
 
     test_get "[$label] GET /status/500 (5xx status forwarding)" \
         /status/500 500 "status 500"
 
     test_head "[$label] HEAD /hello" /hello 200
 
     # Medium response body (128 KiB): exercises streaming download
     test_get "[$label] GET /large/131072 (128 KiB response)" \
         /large/131072 200 ""
     local sz
     sz="$(wc -c <"$TMPDIR/body" | tr -d ' ')"
     msg "[$label] verify 128 KiB body length"
     [ "$sz" = "131072" ] || fail "got $sz bytes, expected 131072"
     ok
 
     # POST /echo — round-trip body
     printf 'hello-payload-%s' "$label" >"$TMPDIR/post_body"
     test_method "[$label] POST /echo (body round-trip)" \
         POST /echo "$TMPDIR/post_body" 200 "hello-payload-$label"
 
     # POST /upload — byte count
     dd if=/dev/urandom of="$TMPDIR/rnd" bs=1024 count=64 status=none
     test_method "[$label] POST /upload (64 KiB binary upload)" \
         POST /upload "$TMPDIR/rnd" 200 "Received 65536 bytes"
 
     # PUT /put
     test_method "[$label] PUT /put (PUT forwarding)" \
         PUT /put "$TMPDIR/post_body" 200 "PUT received"
 
     # PATCH /patch
     test_method "[$label] PATCH /patch (PATCH forwarding)" \
         PATCH /patch "$TMPDIR/post_body" 200 "PATCH received"
 
     # DELETE /item/1 with empty body
     msg "[$label] DELETE /item/1 (204 No Content)"
     local status
     status="$(curl -sS -X DELETE -o /dev/null -w '%{http_code}' "$(PAIVANA_URL /item/1)" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     [ "$status" = "204" ] || fail "status=$status"
     ok
 
     # OPTIONS — server should echo 204 + Allow
     msg "[$label] OPTIONS /anything (204 + Allow header)"
     local opts
     opts="$(curl -sS -X OPTIONS -D "$TMPDIR/hdrs" -o /dev/null -w '%{http_code}' "$(PAIVANA_URL /hello)" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     [ "$opts" = "204" ] || fail "status=$opts"
     grep -qi '^allow:' "$TMPDIR/hdrs" || fail "no Allow header returned"
     ok
 
     # Header propagation: X-Forwarded-For must be added by paivana.
     msg "[$label] GET /echo-headers (X-Forwarded-For added)"
     curl -sS -o "$TMPDIR/body" "$(PAIVANA_URL /echo-headers)" 2>"$TMPDIR/err" \
         || fail "curl: $(cat "$TMPDIR/err")"
     grep -qi '^x-forwarded-for:' "$TMPDIR/body" || \
         fail "upstream did not see X-Forwarded-For; headers:\n$(cat "$TMPDIR/body")"
     grep -qi '^x-forwarded-proto:' "$TMPDIR/body" || \
         fail "upstream did not see X-Forwarded-Proto"
     grep -qi '^via:' "$TMPDIR/body" || \
         fail "upstream did not see Via: paivana"
     ok
 
     # RFC 9110 §7.6.3: client's Via chain must be preserved and our
     # pseudonym *appended* to it, not replaced.
     msg "[$label] client Via is preserved and paivana is appended"
     curl -sS -H 'Via: 1.1 alpha.example, 2.0 beta.example' \
          -o "$TMPDIR/body" "$(PAIVANA_URL /echo-headers)" 2>"$TMPDIR/err" \
         || fail "curl: $(cat "$TMPDIR/err")"
     local via
     via="$(grep -i '^via:' "$TMPDIR/body" | tr -d '\r')"
     [ -n "$via" ] || fail "no Via header at upstream"
     # Expect: "Via: 1.1 alpha.example, 2.0 beta.example, 1.1 paivana"
     case "$via" in
         *"alpha.example"*"beta.example"*paivana*) ;;
         *) fail "Via not appended correctly: '$via'";;
     esac
     ok
 
     # RFC 9110 §7.6.1: headers named in the client's Connection
     # header are hop-by-hop and must not be forwarded upstream.
     msg "[$label] headers named in Connection: are stripped"
     curl -sS \
          -H 'Connection: X-Custom-Hop, X-Other-Hop' \
          -H 'X-Custom-Hop: must-not-forward' \
          -H 'X-Other-Hop: neither' \
          -H 'X-Keep: keep-this' \
          -o "$TMPDIR/body" "$(PAIVANA_URL /echo-headers)" 2>"$TMPDIR/err" \
         || fail "curl: $(cat "$TMPDIR/err")"
     if grep -qi '^x-custom-hop:' "$TMPDIR/body";
     then
         fail "X-Custom-Hop leaked to upstream (Connection list ignored)"
     fi
     if grep -qi '^x-other-hop:' "$TMPDIR/body";
     then
         fail "X-Other-Hop leaked to upstream (Connection list ignored)"
     fi
     grep -qi '^x-keep:.*keep-this' "$TMPDIR/body" || \
         fail "X-Keep (not named in Connection) was incorrectly dropped"
     ok
 
     # Custom request header must be forwarded.
     msg "[$label] custom request header X-Test is forwarded"
     curl -sS -H 'X-Test: dingbat-42' \
          -o "$TMPDIR/body" "$(PAIVANA_URL /echo-headers)" 2>"$TMPDIR/err" \
         || fail "curl: $(cat "$TMPDIR/err")"
     grep -qi '^x-test:.*dingbat-42' "$TMPDIR/body" || \
         fail "upstream did not see X-Test: dingbat-42"
     ok
 
     # Response header passthrough: upstream sets X-Upstream.
     msg "[$label] upstream response header X-Upstream is forwarded"
     curl -sS -D "$TMPDIR/hdrs" -o /dev/null "$(PAIVANA_URL /hello)" 2>"$TMPDIR/err" \
         || fail "curl: $(cat "$TMPDIR/err")"
     grep -qi '^x-upstream:' "$TMPDIR/hdrs" || \
         fail "X-Upstream header not forwarded back to client"
     ok
 }
 
 ######################################################################
 # Cross-cutting tests (do not depend on which upstream is used).
 ######################################################################
 
 function test_method_not_allowed() {
     msg "unsupported HTTP method (TRACE) yields 405"
     local status
     status="$(curl -sS -X TRACE -o /dev/null -w '%{http_code}' \
                    "$(PAIVANA_URL /hello)" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     [ "$status" = "405" ] || fail "status=$status want=405"
     ok
 }
 
 function test_upload_too_big() {
     msg "upload exceeding 1 MiB buffer yields 413"
     dd if=/dev/zero of="$TMPDIR/big" bs=1024 count=2048 status=none
     local status
     status="$(curl -sS -X POST --data-binary "@$TMPDIR/big" \
                    -o /dev/null -w '%{http_code}' \
                    "$(PAIVANA_URL /upload)" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     # 413 == Content Too Large; some builds report 500 on hook close
     [ "$status" = "413" ] || fail "status=$status want=413"
     ok
 }
 
 function test_upload_too_big_early() {
     # Open a raw TCP connection and send a POST whose Content-Length
     # already exceeds the buffer cap, but DON'T send any body bytes.
     # Paivana must reject on the Content-Length header alone (during
     # MHD's HEADERS_PROCESSED callback), respond with 413 and close
     # the connection.  If the early-reject path is missing the server
     # would block waiting for a body that never arrives and we'd hit
     # the timeout, which fails the test rather than masquerading as
     # a pass.
     msg "Content-Length exceeding 1 MiB triggers early 413 (no body sent)"
     local out
     out="$( ( exec 3<>"/dev/tcp/127.0.0.1/$PAIVANA_PORT"
               printf 'POST /upload HTTP/1.1\r\nHost: 127.0.0.1:%s\r\nContent-Length: 10485760\r\nConnection: close\r\n\r\n' \
                      "$PAIVANA_PORT" >&3
               timeout 5 cat <&3 ) 2>"$TMPDIR/err")" \
         || fail "raw POST failed (timeout or socket error): $(cat "$TMPDIR/err")"
     case "$out" in
         'HTTP/1.1 413'*) ;;
         *) fail "expected 413 status line, got: $(echo "$out" | head -c 80)";;
     esac
     ok
 }
 
 function test_upload_too_big_no_continue() {
     # When the client opts in to 100-continue, paivana must NOT send
     # the interim 100 response if it has already decided to reject
     # the upload — it should jump straight to 413.  Use curl with
     # `Expect: 100-continue` and verbose tracing, then assert that
     # no `< HTTP/1.1 100` line appeared on the wire.
     msg "rejection suppresses 100 Continue when client opts in"
     dd if=/dev/zero of="$TMPDIR/big" bs=1024 count=2048 status=none
     local status
     status="$(curl -sSv -X POST -H 'Expect: 100-continue' \
                    --expect100-timeout 5 \
                    --data-binary "@$TMPDIR/big" \
                    -o /dev/null -w '%{http_code}' \
                    "$(PAIVANA_URL /upload)" 2>"$TMPDIR/trace")" \
         || fail "curl: $(cat "$TMPDIR/trace")"
     [ "$status" = "413" ] || fail "status=$status want=413"
     if grep -q '^< HTTP/1.1 100' "$TMPDIR/trace";
     then
         fail "server sent 100 Continue before 413; trace: $(grep '^<' "$TMPDIR/trace")"
     fi
     ok
 }
 
 function test_upload_too_big_chunked() {
     # Chunked transfer-encoding has no Content-Length, so paivana
     # cannot know the upload is too big until it actually reaches
     # the cap mid-stream.  This test guards the fallback
     # drain-then-reject path that runs in BODY_RECEIVING /
     # FULL_REQ_RECEIVED.
     msg "chunked upload exceeding 1 MiB still yields 413 (drain path)"
     dd if=/dev/zero of="$TMPDIR/big" bs=1024 count=2048 status=none
     local status
     status="$(curl -sS -X POST \
                    -H 'Transfer-Encoding: chunked' \
                    -H 'Content-Length:' \
                    --data-binary "@$TMPDIR/big" \
                    -o /dev/null -w '%{http_code}' \
                    "$(PAIVANA_URL /upload)" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     [ "$status" = "413" ] || fail "status=$status want=413"
     ok
 }
 
 function test_upstream_down() {
     msg "upstream down yields 502 Bad Gateway"
     # Re-point paivana at a port with nothing listening.
     stop_paivana
     start_paivana "http://127.0.0.1:$DEAD_PORT"
     local status
     status="$(curl -sS -o "$TMPDIR/body" -w '%{http_code}' \
                    --max-time 10 \
                    "$(PAIVANA_URL /hello)" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     [ "$status" = "502" ] || fail "status=$status want=502"
     grep -qi 'bad gateway' "$TMPDIR/body" || \
         fail "no 'Bad Gateway' in body"
     ok
 }
 
 # curl with multiple URLs on one command line uses HTTP keep-alive
 # (not true pipelining, but exercises the same code path in paivana
 # of handling successive requests on one TCP connection).
 function test_keepalive_curl() {
     msg "curl keep-alive: 3 sequential GETs on one connection"
     local out
     out="$(curl -sS --http1.1 \
                 -w '\n@status=%{http_code}\n' \
                 "$(PAIVANA_URL /hello)" \
                 "$(PAIVANA_URL /hello)" \
                 "$(PAIVANA_URL /hello)" 2>"$TMPDIR/err")" \
         || fail "curl: $(cat "$TMPDIR/err")"
     local count
     count="$(printf '%s\n' "$out" | grep -c '^Hello from')"
     [ "$count" = "3" ] || fail "got $count Hello lines; want 3; out:\n$out"
     ok
 }
 
 function test_wget_basic() {
     msg "wget fetch (third-party client interop)"
     if ! command -v wget >/dev/null 2>&1; then
         echo "SKIP (wget missing)"
         return
     fi
     local body
     body="$(wget -qO- --timeout=5 "$(PAIVANA_URL /hello)")" \
         || fail "wget failed"
     echo "$body" | grep -q '^Hello from' \
         || fail "unexpected body from wget: $body"
     ok
 }
 
 function test_pipelined() {
     msg "HTTP/1.1 pipelined requests (4 back-to-back on one TCP socket)"
     if [ ! -x "$PIPELINE_CLIENT" ]; then
         echo "SKIP (pipeline_client not built)"
         return
     fi
     local out
     out="$("$PIPELINE_CLIENT" 127.0.0.1 "$PAIVANA_PORT" \
               /hello /status/201 /hello /status/404 2>"$TMPDIR/err")" \
         || fail "pipeline_client: $(cat "$TMPDIR/err")"
     printf '%s\n' "$out" >"$TMPDIR/pipeline.out"
     local n
     n="$(grep -c '^--- response' "$TMPDIR/pipeline.out")"
     [ "$n" = "4" ] || fail "got $n responses, want 4; output:\n$out"
     # Order preserved: responses must match the request sequence.
     grep -q '^--- response 0: status=200' "$TMPDIR/pipeline.out" \
         || fail "response 0: wrong status; out:\n$out"
     grep -q '^--- response 1: status=201' "$TMPDIR/pipeline.out" \
         || fail "response 1: wrong status; out:\n$out"
     grep -q '^--- response 2: status=200' "$TMPDIR/pipeline.out" \
         || fail "response 2: wrong status; out:\n$out"
     grep -q '^--- response 3: status=404' "$TMPDIR/pipeline.out" \
         || fail "response 3: wrong status; out:\n$out"
     ok
 }
 
 ######################################################################
 # Drive the tests.
 ######################################################################
 
 echo "=== paivana reverse-proxy tests ==="
 echo "Temp dir: $TMPDIR"
 echo "Paivana binary: $PAIVANA_HTTPD"
 echo "Source dir: $SRCDIR"
 echo "Build dir: $BUILDDIR"
 
 start_upstreams
 
 # --- C / libmicrohttpd upstream ---------------------------------------
 start_paivana "http://127.0.0.1:$MHD_PORT"
 run_battery "mhd"
 
 test_method_not_allowed
 test_upload_too_big
 test_upload_too_big_early
 test_upload_too_big_no_continue
 test_upload_too_big_chunked
 test_keepalive_curl
 test_wget_basic
 test_pipelined
 
 stop_paivana
 
 # --- Go upstream ------------------------------------------------------
 if [ -n "$GO_PORT" ];
 then
     start_paivana "http://127.0.0.1:$GO_PORT"
     run_battery "go"
     test_pipelined
     stop_paivana
 fi
 
 # --- Python upstream --------------------------------------------------
 if [ -n "$PY_PORT" ];
 then
     start_paivana "http://127.0.0.1:$PY_PORT"
     run_battery "py"
     test_pipelined
     stop_paivana
 fi
 
 # --- Rust upstream ----------------------------------------------------
 if [ -n "$RS_PORT" ];
 then
     start_paivana "http://127.0.0.1:$RS_PORT"
     run_battery "rs"
     test_pipelined
     stop_paivana
 fi
 
 # --- Upstream-down test (runs last because it restarts paivana) -------
 test_upstream_down
 stop_paivana
 
 echo "=== all tests passed ==="
 exit 0