huntedbytheirs/stupidtools
Template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
main
stupidtools/tests/integration/run.sh
T

382 lines
15 KiB
Bash
Executable File
Raw Permalink Blame History

#!/bin/sh
# tests/integration/run.sh - end-to-end integration test (plan todo 26).
#
# Drives a REAL fixture C project (tests/integration/fixture/) through the
# full stupidtools pipeline, once per shell in the portability matrix
# (dash/bash/zsh; sh stands in for dash when dash is not installed):
#
# 1. the wired binary ($TOP_DIR/src/stupidtools) generates ./configure
# from project.kdl into an isolated temp dir (one dir per shell);
# 2. that ./configure runs UNDER THE SHELL (any non-POSIX emission dies
# as a syntax error right here), writing Makefile/config.h/config.log/
# config.status;
# 3. make builds the fixture binary; assertions verify the build, the
# substituted Makefile (CC/CFLAGS/LIBS/prefix), config.h defines,
# config.log probe results and config.status --config.
#
# A second fixture (project-fail.kdl) checks a deliberately MISSING header:
# the generated configure must handle the failed probe CLEANLY under every
# shell - the failure is recorded (have_nope=no), the check is named in
# config.log (the compiler's diagnostic), config.h gets NO HAVE_NOPE
# define, and no shell may report a syntax error.
#
# NOTE (deviation, tracked in .omo/notepads/stupidtools/issues.md): the v1
# generator (todos 16/17, frozen to todo 26) follows autoconf semantics -
# a failed OPTIONAL check records have_<name>=no and configure still exits
# 0; it does not abort. The plan/todo text expected rc!=0 for a missing
# header. This runner asserts the generator's REAL contract (rc=0 + the
# failure recorded), and additionally exercises the genuinely-non-zero
# configure-error path (an unrecognized option exits 1 with a readable
# message and no shell syntax error) so BOTH halves of "fails cleanly
# (non-zero, readable message)" are covered by a real assertion.
#
# POSIX sh only (dash/bash/zsh safe): no [[ ]], arrays, local, ==, <<<, &>.
# Exit 0 = every shell's happy case AND failure case passed.
TOP_DIR=$(cd "$(dirname "$0")/../.." && pwd) || {
echo "FAIL: cannot resolve project root" >&2
exit 1
}
BIN="$TOP_DIR/src/stupidtools"
FIX="$TOP_DIR/tests/integration/fixture"
TESTS_RUN=0
TESTS_FAILED=0
# temp dirs created by new_work() are recorded in a file list; the trap
# cleans them on every exit path (a file list + $(cat ...) splits under
# every POSIX shell AND native zsh, unlike an unquoted variable).
WORK_LIST="${TMPDIR:-/tmp}/stupidtools-int-worklist.$$"
: > "$WORK_LIST"
cleanup_dirs() {
[ -s "$WORK_LIST" ] && rm -rf $(cat "$WORK_LIST")
rm -f "$WORK_LIST"
}
trap cleanup_dirs EXIT HUP INT TERM
pass() {
TESTS_RUN=$((TESTS_RUN + 1))
printf 'ok %d - %s\n' "$TESTS_RUN" "$1"
}
fail() {
TESTS_RUN=$((TESTS_RUN + 1))
TESTS_FAILED=$((TESTS_FAILED + 1))
printf 'not ok %d - %s\n' "$TESTS_RUN" "$1" >&2
}
# new_work: mktemp an isolated dir and record it for trap cleanup.
new_work() {
WORK=$(mktemp -d "${TMPDIR:-/tmp}/stupidtools-int.XXXXXX") || {
fail "cannot create temp dir"
return 1
}
printf '%s\n' "$WORK" >> "$WORK_LIST"
return 0
}
# --- preconditions (fail honestly, never silently skip) ------------------
if [ -x "$BIN" ]; then
pass "binary exists and is executable: $BIN"
else
fail "binary missing: $BIN (run 'make' first)"
fi
for f in project.kdl project-fail.kdl Makefile.in main.c demo.c demo.h; do
if [ -f "$FIX/$f" ]; then
pass "fixture file present: $f"
else
fail "fixture file missing: $FIX/$f"
fi
done
# --- the shell matrix -----------------------------------------------------
# Built as positional parameters and iterated with "$@" - the one portable
# multi-word construct that behaves identically under POSIX sh AND native
# zsh (an unquoted variable is NOT word-split in native zsh). dash when
# available (it now is on this host), else sh as stand-in; the runner
# prints which one it used - never a silent substitution.
set --
if command -v dash >/dev/null 2>&1; then
set -- "$@" dash
DASH_USED=yes
else
set -- "$@" sh
DASH_USED=no
printf '# note: dash: unavailable - matrix uses sh instead of dash\n'
fi
for cand in bash zsh; do
if command -v "$cand" >/dev/null 2>&1; then
set -- "$@" "$cand"
else
fail "required shell not installed: $cand"
fi
done
SHELLS="$*"
printf '# shell matrix: %s (dash used: %s)\n' "$SHELLS" "$DASH_USED"
printf '# note: failed-check semantics per the frozen v1 generator: a failed\n'
printf '# optional check records have_<name>=no and configure exits 0;\n'
printf '# the non-zero configure-error path is asserted via an unknown\n'
printf '# option instead (see header + issues.md).\n'
# --- happy case: one shell, one isolated dir ------------------------------
run_happy() {
shell=$1
new_work || return 1
if cp "$FIX/project.kdl" "$FIX/Makefile.in" "$FIX/main.c" "$FIX/demo.c" \
"$FIX/demo.h" "$WORK/" \
&& (cd "$WORK" && XDG_DATA_HOME="$WORK/xdg" STUPIDTOOLS_EXT= \
"$BIN" project.kdl >gen.log 2>&1) \
&& [ -s "$WORK/configure" ]; then
pass "$shell: stupidtools generated ./configure from project.kdl"
else
fail "$shell: configure generation failed: $(cat "$WORK/gen.log" 2>/dev/null)"
return 1
fi
# real dash is the strict oracle when it is in the matrix
if [ "$shell" = "dash" ]; then
if dash -n "$WORK/configure" 2>"$WORK/dashn.err"; then
pass "dash: generated ./configure passes dash -n"
else
fail "dash: generated ./configure fails dash -n: $(cat "$WORK/dashn.err" 2>/dev/null)"
fi
fi
# run configure UNDER THE SHELL. CC/CFLAGS/CXX/CXXFLAGS are unset so
# the generated ${VAR:-default} toolchain defaults apply (and zsh's
# no-word-split on unquoted $CFLAGS cannot be fed a multi-word value).
conf_rc=0
(cd "$WORK" && unset CC CFLAGS CXX CXXFLAGS
"$shell" ./configure --prefix="$WORK/install" \
>configure.out 2>configure.err) || conf_rc=$?
if [ "$conf_rc" -eq 0 ]; then
pass "$shell: ./configure exited 0"
else
fail "$shell: ./configure exited rc=$conf_rc: $(cat "$WORK/configure.err" 2>/dev/null)"
fi
if grep -iE 'syntax error|parse error' "$WORK/configure.out" \
"$WORK/configure.err" >/dev/null 2>&1; then
fail "$shell: configure output carries a shell-syntax-error signature"
else
pass "$shell: no shell-syntax-error signature in configure output"
fi
# the substituted Makefile: no @VAR@ left, LIBS accumulated, prefix set
if [ -f "$WORK/Makefile" ]; then
pass "$shell: configure wrote Makefile"
if grep -E '@[A-Za-z_][A-Za-z0-9_]*@' "$WORK/Makefile" >/dev/null 2>&1; then
fail "$shell: Makefile still contains @VAR@ placeholders"
else
pass "$shell: no @VAR@ placeholders left in Makefile"
fi
if grep '^LIBS' "$WORK/Makefile" | grep -q -- '-lpthread'; then
pass "$shell: Makefile LIBS contains -lpthread"
else
fail "$shell: Makefile LIBS missing -lpthread: $(grep '^LIBS' "$WORK/Makefile")"
fi
if grep '^LIBS' "$WORK/Makefile" | grep -q -- '-lm'; then
pass "$shell: Makefile LIBS contains -lm"
else
fail "$shell: Makefile LIBS missing -lm: $(grep '^LIBS' "$WORK/Makefile")"
fi
if grep -qF "prefix = $WORK/install" "$WORK/Makefile"; then
pass "$shell: Makefile prefix substituted with --prefix value"
else
fail "$shell: Makefile prefix unexpected: $(grep '^prefix' "$WORK/Makefile")"
fi
else
fail "$shell: configure wrote no Makefile"
fi
# make (bounded via timeout when available)
make_rc=0
if command -v timeout >/dev/null 2>&1; then
(cd "$WORK" && timeout 300 make >make.log 2>&1) || make_rc=$?
else
(cd "$WORK" && make >make.log 2>&1) || make_rc=$?
fi
if [ "$make_rc" -eq 0 ] && [ -x "$WORK/demo" ]; then
pass "$shell: make built the demo binary"
else
fail "$shell: make failed (rc=$make_rc): $(tail -n 5 "$WORK/make.log" 2>/dev/null)"
fi
# the binary must RUN and print the markers (pthread + libm proven live)
if [ -x "$WORK/demo" ]; then
demo_out=$("$WORK/demo" 2>"$WORK/demo.err")
demo_rc=$?
if [ "$demo_rc" -eq 0 ]; then
pass "$shell: demo binary runs (exit 0)"
else
fail "$shell: demo binary exited rc=$demo_rc: $(cat "$WORK/demo.err" 2>/dev/null)"
fi
if printf '%s\n' "$demo_out" | grep -qF 'sin(0.5) = 0.4794'; then
pass "$shell: demo prints the libm marker 'sin(0.5) = 0.4794'"
else
fail "$shell: demo output missing libm marker: '$demo_out'"
fi
if printf '%s\n' "$demo_out" | grep -qF 'worker thread ran'; then
pass "$shell: demo prints the pthread marker 'worker thread ran'"
else
fail "$shell: demo output missing pthread marker: '$demo_out'"
fi
else
fail "$shell: skipping binary checks (no demo binary)"
fi
# config.h: HAVE_ defines for the resolved features
if grep -qF '#define HAVE_PTHREAD 1' "$WORK/config.h"; then
pass "$shell: config.h defines HAVE_PTHREAD 1"
else
fail "$shell: config.h missing '#define HAVE_PTHREAD 1': $(cat "$WORK/config.h" 2>/dev/null)"
fi
if grep -qF '#define HAVE_MATH 1' "$WORK/config.h"; then
pass "$shell: config.h defines HAVE_MATH 1"
else
fail "$shell: config.h missing '#define HAVE_MATH 1'"
fi
# config.log: the ## results summary records every feature's resolution
if grep -qF 'have_pthread=yes' "$WORK/config.log"; then
pass "$shell: config.log records have_pthread=yes"
else
fail "$shell: config.log missing have_pthread=yes"
fi
if grep -qF 'have_math=yes' "$WORK/config.log"; then
pass "$shell: config.log records have_math=yes"
else
fail "$shell: config.log missing have_math=yes"
fi
# config.status --config must print the original invocation
cs_rc=0
cs_out=$("$shell" "$WORK/config.status" --config 2>"$WORK/cs.err") || cs_rc=$?
if [ "$cs_rc" -eq 0 ]; then
case "$cs_out" in
*"$WORK/install"*)
pass "$shell: config.status --config prints the original args" ;;
*)
fail "$shell: config.status --config output unexpected: '$cs_out'" ;;
esac
else
fail "$shell: config.status --config exited rc=$cs_rc: $(cat "$WORK/cs.err" 2>/dev/null)"
fi
# --help lists the option node's --enable-debug surface
help_rc=0
help_out=$(cd "$WORK" && unset CC CFLAGS CXX CXXFLAGS
"$shell" ./configure --help 2>&1) || help_rc=$?
if [ "$help_rc" -eq 0 ] \
&& printf '%s\n' "$help_out" | grep -qF -- '--enable-debug'; then
pass "$shell: --help exits 0 and lists --enable-debug"
else
fail "$shell: --help rc=$help_rc or --enable-debug missing"
fi
}
# --- failure case: missing header must fail cleanly, never a syntax error -
run_failure() {
shell=$1
new_work || return 1
if cp "$FIX/project-fail.kdl" "$FIX/Makefile.in" "$WORK/" \
&& (cd "$WORK" && XDG_DATA_HOME="$WORK/xdg" STUPIDTOOLS_EXT= \
"$BIN" project-fail.kdl >gen.log 2>&1) \
&& [ -s "$WORK/configure" ]; then
pass "$shell: stupidtools generated ./configure from project-fail.kdl"
else
fail "$shell: failure-fixture generation failed: $(cat "$WORK/gen.log" 2>/dev/null)"
return 1
fi
# the frozen v1 generator records the failed check and exits 0 (see the
# header NOTE); rc=0 here IS the clean-failure contract being asserted
conf_rc=0
(cd "$WORK" && unset CC CFLAGS CXX CXXFLAGS
"$shell" ./configure >configure.out 2>configure.err) || conf_rc=$?
if [ "$conf_rc" -eq 0 ]; then
pass "$shell: missing-header configure completed cleanly (rc=0, v1 generator semantics)"
else
fail "$shell: missing-header configure exited rc=$conf_rc: $(cat "$WORK/configure.err" 2>/dev/null)"
fi
if grep -iE 'syntax error|parse error' "$WORK/configure.out" \
"$WORK/configure.err" >/dev/null 2>&1; then
fail "$shell: missing-header configure output carries a shell-syntax-error signature"
else
pass "$shell: no shell-syntax-error signature on the missing-header run"
fi
# the failure is honestly recorded: have_nope=no, the healthy feature
# still yes, and the compiler's diagnostic names the missing check
if grep -qF 'have_nope=no' "$WORK/config.log"; then
pass "$shell: config.log records have_nope=no"
else
fail "$shell: config.log missing have_nope=no"
fi
if grep -qF 'have_posix=yes' "$WORK/config.log"; then
pass "$shell: config.log records have_posix=yes (configure kept going)"
else
fail "$shell: config.log missing have_posix=yes"
fi
if grep -qF 'nope_missing_xyz.h' "$WORK/config.log"; then
pass "$shell: config.log names the failed check (nope_missing_xyz.h)"
else
fail "$shell: config.log does not name the failed check"
fi
# config.h: no HAVE_NOPE define; the healthy feature still gets one
if grep -qF 'HAVE_NOPE' "$WORK/config.h"; then
fail "$shell: config.h must NOT define HAVE_NOPE"
else
pass "$shell: config.h has no HAVE_NOPE define"
fi
if grep -qF '#define HAVE_POSIX 1' "$WORK/config.h"; then
pass "$shell: config.h still defines HAVE_POSIX 1"
else
fail "$shell: config.h missing '#define HAVE_POSIX 1'"
fi
# config.status --config works on the failure fixture too
cs_rc=0
"$shell" "$WORK/config.status" --config >"$WORK/cs.out" 2>&1 || cs_rc=$?
if [ "$cs_rc" -eq 0 ]; then
pass "$shell: config.status --config exits 0 (failure fixture)"
else
fail "$shell: config.status --config exited rc=$cs_rc"
fi
# the genuinely-non-zero configure-error path: an unknown option must
# exit 1 with a readable message and no shell syntax error
bogus_rc=0
bogus_err=$(cd "$WORK" && "$shell" ./configure --definitely-bogus-flag \
2>&1) || bogus_rc=$?
if [ "$bogus_rc" -eq 1 ] \
&& printf '%s\n' "$bogus_err" | grep -qF 'unrecognized option'; then
pass "$shell: unknown option exits 1 with a readable message"
else
fail "$shell: unknown option rc=$bogus_rc: '$bogus_err'"
fi
if printf '%s\n' "$bogus_err" | grep -iE 'syntax error|parse error' \
>/dev/null 2>&1; then
fail "$shell: unknown-option failure output carries a syntax-error signature"
else
pass "$shell: no syntax-error signature on the unknown-option failure"
fi
}
# --- the matrix ------------------------------------------------------------
for shell in "$@"; do
run_happy "$shell"
run_failure "$shell"
done
# --- summary ---------------------------------------------------------------
if [ "$TESTS_FAILED" -ne 0 ]; then
printf 'FAILED: %d/%d checks failed\n' "$TESTS_FAILED" "$TESTS_RUN" >&2
exit 1
fi
printf 'All %d integration checks passed (matrix:%s).\n' "$TESTS_RUN" "$SHELLS"
Reference in New Issue View Git Blame Copy Permalink