starting new job...
→ running command: dir='/etc/byggsteg/job-clone//mutastructura/trunk'
branch='trunk'
if ! command -v git >/dev/null 2>&1; then
echo 'byggsteg: git is not on this deployment PATH, so the clone cannot be updated' >&2
exit 1
fi
if ! cd "$dir"; then
echo "byggsteg: cannot enter the clone $dir" >&2
exit 1
fi
root=$(git rev-parse --show-toplevel 2>/dev/null)
if [ "$root" != "$(pwd -P)" ]; then
echo "byggsteg: $dir is not a git checkout; remove it and the next run clones it again" >&2
exit 1
fi
if ! origin=$(git remote get-url origin 2>/dev/null); then
echo "byggsteg: $dir has no origin remote to fetch $branch from" >&2
exit 1
fi
before=$(git rev-parse --short HEAD 2>/dev/null) || before=none
attempt=1
while :; do
if GIT_TERMINAL_PROMPT=0 git fetch --quiet origin "+refs/heads/$branch:refs/remotes/origin/$branch"; then
break
fi
if [ "$attempt" -ge 3 ]; then
echo "byggsteg: could not fetch $branch from $origin after 3 attempts; is the branch still there, and is the remote reachable?" >&2
exit 1
fi
echo "byggsteg: fetching $branch from $origin failed; retrying in $((attempt * 2))s" >&2
sleep $((attempt * 2))
attempt=$((attempt + 1))
done
if ! git checkout --quiet --force -B "$branch" FETCH_HEAD; then
echo "byggsteg: fetched $branch from $origin but could not check it out" >&2
exit 1
fi
after=$(git rev-parse --short HEAD)
if [ "$before" = "$after" ]; then
echo "byggsteg: $branch was already at $after"
else
echo "byggsteg: $branch moved from $before to $after"
fi
byggsteg: trunk moved from 728ede7 to 7aaf261
✓ command finished in 0.72s
→ running command: cd /etc/byggsteg/job-clone/mutastructura/trunk && uname -a
Linux wolk-jjba 7.2.11-gnu #1 SMP PREEMPT_DYNAMIC 1 x86_64 GNU/Linux
✓ command finished in 0.02s
→ running command: cd /etc/byggsteg/job-clone/mutastructura/trunk && git log --name-status HEAD^..HEAD
commit 7aaf26173e7547cb7ed91a76664a6ac28740741c
Author: Josep Bigorra <jjbigorra@gmail.com>
Date: Tue Nov 10 21:00:37 2026 +0100
chore: Release v0.9.9
The funding file carries a custom funding URL that points at Buy Me a Coffee
(buymeacoffee.com/jjbigorra), so GitHub shows a Sponsor button on the
repository; the change landed in 728ede7 and this release carries it.
The version is bumped to v0.9.9 in default.nix, README.org, the PKGBUILD, the
openSUSE spec and the Debian changelog.
NEWS.org records the release.
maak test: 119 tests, 307 assertions, no failures.
🤖 Generated with ECA (deepseek/deepseek-flash)
Co-Authored-By: eca-agent <git@eca.dev>
M NEWS.org
M README.org
M default.nix
M packaging/arch/PKGBUILD
M packaging/debian/changelog
M packaging/opensuse/mutastructura.spec
✓ command finished in 0.03s
→ running command: cd /etc/byggsteg/job-clone/mutastructura/trunk && maak test
scanning directories for unit tests...
scanning present working directory for unit tests...
shuffled the files with seed 995905203 (replay with VERITAS_SEED=995905203)
found unit tests: (core.scm dialect.scm sql-parser.scm sql-runner.scm)
running unit tests from file: core.scm, entrypoint: spec
+----------------------------------------------+
[📑 suite] the engines and the names people call them
[🧪 test] a database reached through another driver keeps its own identity
[⚙️ assert] CockroachDB is opened by the PostgreSQL driver
✅ got: postgresql
[⚙️ assert] which is what guile-dbi is told
✅ got: postgresql
[⚙️ assert] and MariaDB by the MySQL one
✅ got: mysql
[🧪 test] every engine is a relational one
[⚙️ assert] SQLite is relational
✅ got: relational
[⚙️ assert] and so is PostgreSQL
✅ got: relational
[⚙️ assert] which is what the core asks
✅ got: #t
[🧪 test] a name is matched without case
[⚙️ assert] MySQL and mysql are the same request
✅ got: mysql
[⚙️ assert] and so are POSTGRES and postgres
✅ got: postgresql
[🧪 test] every alias resolves to the engine it names
[⚙️ assert] pg is PostgreSQL
✅ got: postgresql
[⚙️ assert] and so is psql
✅ got: postgresql
[⚙️ assert] a PostgreSQL-compatible database is reached as one
✅ got: postgresql
[⚙️ assert] mariadb is MySQL's engine
✅ got: mysql
[⚙️ assert] and so is percona
✅ got: mysql
[⚙️ assert] crdb is CockroachDB
✅ got: cockroachdb
[🧪 test] an engine carries the port and the ledger it defaults to
[⚙️ assert] PostgreSQL's port
✅ got: 5432
[⚙️ assert] MySQL's port
✅ got: 3306
[⚙️ assert] CockroachDB's port
✅ got: 26257
[⚙️ assert] and SQLite has none
✅ got: 0
[⚙️ assert] the SQL ledger's default name
✅ got: migrations_history
[🧪 test] every engine takes SQL migration files
[⚙️ assert] SQL for PostgreSQL
✅ got: (.sql)
[⚙️ assert] and for SQLite, which also knows its own suffix
✅ got: (.sql .sqlite.sql)
[🧪 test] the engines are listed once each
[⚙️ assert] in the order help lists them
✅ got: (sqlite3 postgresql cockroachdb mysql)
[🧪 test] an unknown name is refused, naming the ones that exist
[⚙️ assert] there is no such engine
✅ got: #f
[⚙️ assert] and the error says what there is instead
✅ got: #t
+----------------------------------------------+
[📑 suite] connection URLs
[🧪 test] the description of a connection never holds the password
[⚙️ assert] it says where it is going and as whom
✅ got: #t
[⚙️ assert] and not the password
✅ got: #f
[⚙️ assert] and it names the driver when that is the interesting part
✅ got: #t
[🧪 test] a port left out is the engine's own
[⚙️ assert] PostgreSQL defaults to 5432
✅ got: alice:secret:appdb:tcp:db.example.net:5432
[⚙️ assert] and MySQL to its own port on localhost
✅ got: alice:secret:appdb:tcp:localhost:3306
[🧪 test] a SQLite URL is a path, taken verbatim
[⚙️ assert] the engine
✅ got: sqlite3
[⚙️ assert] the absolute path is kept whole
✅ got: /var/lib/app.db
[⚙️ assert] and is the database
✅ got: /var/lib/app.db
[⚙️ assert] a relative path stays relative
✅ got: ./local.db
[🧪 test] a password with a colon is refused rather than truncated
[⚙️ assert] the reason and the way out are both named
✅ got: #t
[🧪 test] a URL becomes the driver's own connection string
[⚙️ assert] PostgreSQL's colon-delimited form
✅ got: alice:secret:appdb:tcp:db.example.net:5432
[⚙️ assert] and MySQL's
✅ got: alice:secret:appdb:tcp:127.0.0.1:3306
[🧪 test] a parameter is percent-decoded
[⚙️ assert] a space written as %20
✅ got: a b
[🧪 test] something that is not a URL is a connection string
[⚙️ assert] the string is passed through
✅ got: alice:secret:appdb:tcp:host:5432
[⚙️ assert] with the engine it was told
✅ got: postgresql
[🧪 test] a PostgreSQL URL is split into its parts
[⚙️ assert] the engine
✅ got: postgresql
[⚙️ assert] the host
✅ got: db.example.net
[⚙️ assert] the port
✅ got: 5432
[⚙️ assert] the user
✅ got: alice
[⚙️ assert] and the database
✅ got: appdb
+----------------------------------------------+
[📑 suite] a migration file and its order
[🧪 test] a directory that is not there is refused
[⚙️ assert] the directory is refused
✅ got: #t
[🧪 test] a dotted version sorts by number, not by text
[⚙️ assert] 1.2.10 comes after 1.2.9
✅ got: #t
[⚙️ assert] and the order key of the files agrees
✅ got: #t
[⚙️ assert] a version that is not numeric has no such key
✅ got: #f
[🧪 test] which files are migrations is the engine's answer
[⚙️ assert] SQL for PostgreSQL
✅ got: #t
[⚙️ assert] and not JSON
✅ got: #f
[⚙️ assert] nor does an engine take a stray note
✅ got: #f
[🧪 test] a name is read into a version and a description
[⚙️ assert] the file it is
✅ got: 2026-03-31_20:24:00_init.sql
[⚙️ assert] the version --target compares against
✅ got: 2026-03-31_20:24:00_init
[⚙️ assert] and that it is versioned
✅ got: versioned
[🧪 test] a file's checksum is its content's
[⚙️ assert] a SHA-256 is 64 hexadecimal characters
✅ got: 64
[⚙️ assert] and it is the same on the next read
✅ got: 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6
[⚙️ assert] while another file has another
✅ got: #f
[🧪 test] a `.repeatable.sql' name is a repeatable migration
[⚙️ assert] even without Flyway's `R__' prefix
✅ got: repeatable
[⚙️ assert] with the marker stripped from the version
✅ got: 2026-04-01_21:54:00_test
[🧪 test] Flyway's names are read the way Flyway reads them
[⚙️ assert] the version is the number
✅ got: 1.2
[⚙️ assert] and the description what follows the underscores
✅ got: add-user
[⚙️ assert] a V file is versioned
✅ got: versioned
[⚙️ assert] an R file is repeatable
✅ got: repeatable
[⚙️ assert] and a U file is a rollback
✅ got: undo
[🧪 test] the discovery of a directory is by extension, and sorted
[⚙️ assert] the SQL directory, in order
✅ got: (2026-03-31_20:24:00_init.sql 2026-04-01_21:54:00_test.repeatable.sql)
[🧪 test] a file is read with its byte order mark removed
[⚙️ assert] the BOM an editor wrote
✅ got: SELECT 1
[⚙️ assert] and a file that never had one
✅ got: SELECT 1
+----------------------------------------------+
[📑 suite] placeholders
[🧪 test] the question of whether there is a placeholder at all
[⚙️ assert] a `${' and a `}' together are one
✅ got: #t
[⚙️ assert] a positional parameter is not
✅ got: #f
[🧪 test] a placeholder nobody defined is left exactly as it was
[⚙️ assert] an empty set of placeholders changes nothing
✅ got: SELECT '${not-ours}'
[⚙️ assert] and neither does an incomplete one
✅ got: SELECT ${other}
[🧪 test] a `key=value' list becomes an alist
[⚙️ assert] spaces around the parts are not part of them
✅ got: ((user . ada) (schema . app))
[⚙️ assert] a comma-separated string is the same thing
✅ got: ((user . ada))
[⚙️ assert] an empty one defines nothing
✅ got: ()
[🧪 test] a migration's `${name}' becomes what it was given
[⚙️ assert] both placeholders substituted
✅ got: SELECT * FROM app.users WHERE id = 7
[🧪 test] a spec with no `=' is refused
[⚙️ assert] and the form it wants is named
✅ got: #t
+----------------------------------------------+
[📑 suite] the ledger entry the core reads
[🧪 test] a time is read from either column name
[⚙️ assert] the server's own stamp
✅ got: 1791981743651
[⚙️ assert] and the older spelling
✅ got: 5
[🧪 test] a kind is read whether it is a symbol, a string or missing
[⚙️ assert] the symbol the runner writes
✅ got: versioned
[⚙️ assert] the string a driver answers with
✅ got: repeatable
[⚙️ assert] and a name that says so when the field is gone
✅ got: repeatable
[🧪 test] a row is recognised as an entry
[⚙️ assert] an alist with a name is one
✅ got: #t
[⚙️ assert] a string is not
✅ got: #f
[⚙️ assert] and neither is an alist without a name
✅ got: #f
[🧪 test] a success is read whether it is a boolean or 1 and 0
[⚙️ assert] 1 is a success
✅ got: #t
[⚙️ assert] 0 is a failure
✅ got: #f
[⚙️ assert] and an entry that does not mention it succeeded
✅ got: #t
[⚙️ assert] an explicit #f is a failure
✅ got: #f
[🧪 test] an entry becomes a migration file for reporting
[⚙️ assert] with its version
✅ got: 2026-04-01_21:54:00_test
[⚙️ assert] and its kind
✅ got: versioned
[⚙️ assert] and known to be applied
✅ got: #t
[⚙️ assert] an entry with no time took none
✅ got: 0
[🧪 test] the newest applied version is the newest versioned one
[⚙️ assert] the newest versioned migration
✅ got: 2026-03-31_20:24:00_init
[⚙️ assert] and an empty ledger has none
✅ got: #f
+----------------------------------------------+
[📑 suite] comparing a directory with a ledger
[🧪 test] a file edited after it was applied is a change
[⚙️ assert] the state is changed
✅ got: changed
[⚙️ assert] which is a warning by default
✅ got: warn
[⚙️ assert] and a problem
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init) (checksum . 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6) (state . changed) (action . warn) (applied-on . 1791981743651) (execution-time . 12) (success . #t)))
[⚙️ assert] which validate turns into a refusal
✅ got: fail
[⚙️ assert] the same question asked on its own
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init)))
[🧪 test] a ledger entry whose file has gone is missing
[⚙️ assert] the file and the entry that has none
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init) (checksum . 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6) (state . applied) (action . skip) (applied-on . 1791981743651) (execution-time . 12) (success . #t)) ((name . 2026-01-01_00:00:00_gone.sql) (path . #f) (version . 2026-01-01_00:00:00_gone) (description . 2026-01-01_00:00:00_gone.sql) (kind . versioned) (order-key . 2026-01-01_00:00:00_gone) (checksum . dead) (applied? . #t) (state . missing) (action . warn) (applied-on . 1791981743651) (execution-time . 12) (success . #t)))
[⚙️ assert] the entry is missing its file
✅ got: missing
[⚙️ assert] and is reported rather than run
✅ got: warn
[⚙️ assert] the orphans are found on their own too
✅ got: (((name . 2026-01-01_00:00:00_gone.sql) (checksum . dead) (description . 2026-01-01_00:00:00_gone.sql) (kind . versioned) (installed-on . 1791981743651) (installed-by . mutastructura) (execution-time . 12) (success . 1)))
[🧪 test] a target holds back what is above it
[⚙️ assert] the migration at the target runs
✅ got: pending
[⚙️ assert] and the one after it does not
✅ got: beyond-target
[⚙️ assert] so one of the two would run
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init) (checksum . 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6) (state . pending) (action . apply) (applied-on . #f) (execution-time . #f) (success . #t)))
[⚙️ assert] and holding one back is not a problem
✅ got: ()
[🧪 test] an empty ledger makes every file pending
[⚙️ assert] both files are in the plan
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init) (checksum . 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6) (state . pending) (action . apply) (applied-on . #f) (execution-time . #f) (success . #t)) ((name . 2026-04-01_21:54:00_test.repeatable.sql) (path . migrations/lucidplan/2026-04-01_21:54:00_test.repeatable.sql) (version . 2026-04-01_21:54:00_test) (description . 2026-04-01_21:54:00_test) (kind . repeatable) (order-key . 2026-04-01_21:54:00_test) (checksum . b937e3b288e0595080667978a5f5e0bf09943508f25a5e90af7483e5a5e4a6b3) (state . repeatable-pending) (action . apply) (applied-on . #f) (execution-time . #f) (success . #t)))
[⚙️ assert] and both are pending
✅ got: (pending repeatable-pending)
[⚙️ assert] so both would run
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init) (checksum . 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6) (state . pending) (action . apply) (applied-on . #f) (execution-time . #f) (success . #t)) ((name . 2026-04-01_21:54:00_test.repeatable.sql) (path . migrations/lucidplan/2026-04-01_21:54:00_test.repeatable.sql) (version . 2026-04-01_21:54:00_test) (description . 2026-04-01_21:54:00_test) (kind . repeatable) (order-key . 2026-04-01_21:54:00_test) (checksum . b937e3b288e0595080667978a5f5e0bf09943508f25a5e90af7483e5a5e4a6b3) (state . repeatable-pending) (action . apply) (applied-on . #f) (execution-time . #f) (success . #t)))
[⚙️ assert] and the summary says so
✅ got: ((pending . 1) (repeatable-pending . 1))
[🧪 test] repair names the recorded failures and the changed files
[⚙️ assert] nothing to repair when the ledger agrees
✅ got: ()
[⚙️ assert] a changed file is a candidate
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init) (checksum . 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6) (state . changed) (action . warn) (applied-on . 1791981743651) (execution-time . 12) (success . #t)))
[⚙️ assert] which repair realigns
✅ got: changed
[⚙️ assert] and so is a recorded failure
✅ got: (((name . 2026-03-31_20:24:00_init.sql) (path . migrations/lucidplan/2026-03-31_20:24:00_init.sql) (version . 2026-03-31_20:24:00_init) (description . 2026-03-31_20:24:00_init) (kind . versioned) (order-key . 2026-03-31_20:24:00_init) (checksum . 0de08501706302a7910d747dd602b9a974ce4b2fe2580170a70917231a5064e6) (state . pending) (action . apply) (applied-on . #f) (execution-time . 0) (success . #f)))
[⚙️ assert] which repair forgets
✅ got: #f
[🧪 test] a pending migration older than the newest one is held back
[⚙️ assert] it is superseded by what is applied
✅ got: superseded
[⚙️ assert] unless out-of-order runs are allowed
✅ got: apply
[🧪 test] a file the ledger knows about is skipped
[⚙️ assert] it is applied
✅ got: applied
[⚙️ assert] and nothing is done
✅ got: skip
[⚙️ assert] so there is nothing to run
✅ got: ()
[⚙️ assert] and nothing to complain about
✅ got: ()
+----------------------------------------------+
[📑 suite] rolling back what can be rolled back
[🧪 test] a file marked irreversible is blocked, until it is not
[⚙️ assert] the directive stops the default
✅ got: blocked
[⚙️ assert] and says why
✅ got: marked irreversible
[⚙️ assert] while the explicit override runs it
✅ got: undo
[🧪 test] one migration is undone by default, and it is the newest
[⚙️ assert] the safe default is one step
✅ got: (((name . 2026-01-03_c.sql) (version . 2026-01-03_c) (file (name . 2026-01-03_c.sql) (path . /m/2026-01-03_c.sql) (version . 2026-01-03_c) (description . 2026-01-03_c) (kind . versioned) (order-key . 2026-01-03_c)) (undo (name . 2026-01-03_c.undo.sql) (path . /m/2026-01-03_c.undo.sql) (version . 2026-01-03_c) (description . 2026-01-03_c) (kind . undo) (order-key . 2026-01-03_c)) (irreversible . #f) (success . #t) (applied-on . 1791981743651) (action . undo) (reason . undo script)))
[⚙️ assert] the newest applied migration
✅ got: 2026-01-03_c.sql
[⚙️ assert] with the undo script beside it
✅ got: undo
[⚙️ assert] which is the file the runner would apply
✅ got: 2026-01-03_c.undo.sql
[🧪 test] --all is not combined with --steps or --to
[⚙️ assert] the alternatives are named
✅ got: #t
[🧪 test] repeatable migrations are not rollback candidates
[⚙️ assert] a repeatable is left for migrate to re-run
✅ got: ()
[⚙️ assert] and an empty database has nothing to undo
✅ got: ()
[🧪 test] --all stops at the first migration it cannot undo
[⚙️ assert] newest first, then the boundary
✅ got: (undo undo boundary)
[⚙️ assert] which is the migration without a script
✅ got: 2026-01-01_a.sql
[🧪 test] a recorded failure blocks its own rollback
✅ got: blocked
✅ got: records a failure; run repair first
[🧪 test] --to leaves the target applied and undoes what is above it
[⚙️ assert] newest first, target excluded
✅ got: (2026-01-03_c.sql 2026-01-02_b.sql)
[⚙️ assert] a target that is already the newest undoes nothing
✅ got: ()
[⚙️ assert] and a target that was never applied is refused
✅ got: #t
[🧪 test] more steps than there are migrations is refused
[⚙️ assert] rather than quietly undoing fewer
✅ got: #t
[🧪 test] a requested number of steps reports what blocks it
[⚙️ assert] the two that can, and the one that cannot
✅ got: (undo undo blocked)
[⚙️ assert] and why the last one is blocked
✅ got: no undo script
[🧪 test] --all with nothing reversible is a boundary alone
✅ got: (((action . boundary) (name . 2026-01-01_a.sql) (version . 2026-01-01_a) (file (name . 2026-01-01_a.sql) (path . /m/2026-01-01_a.sql) (version . 2026-01-01_a) (description . 2026-01-01_a) (kind . versioned) (order-key . 2026-01-01_a)) (undo . #f) (irreversible . #f) (success . #t) (applied-on . 1791981743651) (reason . no undo script)))
[⚙️ assert] the newest migration is the wall
✅ got: boundary
ℹ️ info - ran 7 tasks in: 1 seconds, -754323 microseconds
running unit tests from file: dialect.scm, entrypoint: spec
+----------------------------------------------+
[📑 suite] quoting, per engine
[🧪 test] MySQL doubles a backslash and SQLite does not
[⚙️ assert] SQLite leaves a backslash alone
✅ got: 'C:\temp'
[⚙️ assert] MySQL doubles it
✅ got: 'C:\\temp'
[⚙️ assert] and MariaDB doubles it too
✅ got: 'C:\\temp'
[🧪 test] a string is quoted with doubled single quotes
[⚙️ assert] an ordinary value
✅ got: 'users'
[⚙️ assert] an apostrophe does not end the literal
✅ got: 'user''s'
[🧪 test] an identifier is quoted the way the engine quotes them
[⚙️ assert] SQLite doubles the double quote
✅ got: "users"
[⚙️ assert] PostgreSQL does the same
✅ got: "users"
[⚙️ assert] MySQL uses backticks
✅ got: `users`
[⚙️ assert] and so does MariaDB, through the same alias
✅ got: `users`
[🧪 test] a literal is written as its SQL type
[⚙️ assert] a number as itself
✅ got: 36
[⚙️ assert] true as 1
✅ got: 1
[⚙️ assert] false as 0
✅ got: 0
[⚙️ assert] the null value as NULL
✅ got: NULL
[⚙️ assert] a symbol as a quoted string
✅ got: 'versioned'
[🧪 test] an identifier that holds a quote is still one identifier
[⚙️ assert] SQLite doubles the inner double quote
✅ got: "we""ird"
[⚙️ assert] MySQL doubles the inner backtick
✅ got: `we``ird`
+----------------------------------------------+
[📑 suite] transactions and locking
[🧪 test] PostgreSQL takes one advisory lock, named for the ledger
[⚙️ assert] one statement
✅ got: (SELECT pg_advisory_lock(7789568688506408848))
[⚙️ assert] and it is the advisory lock
✅ got: #t
[⚙️ assert] the same ledger gets the same key
✅ got: (SELECT pg_advisory_lock(5756235829675053970))
[⚙️ assert] and another ledger a different one
✅ got: #f
[🧪 test] a lock is released by the engine that took it
[⚙️ assert] PostgreSQL unlocks its own advisory lock
✅ got: #t
[⚙️ assert] MySQL releases the named lock
✅ got: #t
[🧪 test] only MySQL cannot undo a failed migration's DDL
[⚙️ assert] MySQL commits DDL as it runs
✅ got: #f
[⚙️ assert] SQLite rolls it back
✅ got: #t
[⚙️ assert] and so does PostgreSQL
✅ got: #t
[🧪 test] every other engine opens a plain transaction
[⚙️ assert] PostgreSQL
✅ got: BEGIN
[⚙️ assert] MySQL
✅ got: BEGIN
[🧪 test] CockroachDB takes no advisory lock at all
[⚙️ assert] no statement to take a lock that is not there
✅ got: ()
[⚙️ assert] and none to release it
✅ got: ()
[⚙️ assert] and it speaks PostgreSQL's SQL otherwise
✅ got: BEGIN
[⚙️ assert] with transactional DDL
✅ got: #t
[🧪 test] SQLite takes its write lock with the transaction
[⚙️ assert] the write lock comes with BEGIN
✅ got: BEGIN IMMEDIATE
[⚙️ assert] and no lock statement is needed
✅ got: ()
[🧪 test] MySQL asks for a lock and gives up after ten seconds
[⚙️ assert] the lock is named and timed
✅ got: #t
+----------------------------------------------+
[📑 suite] the ledger's own SQL
[🧪 test] creating the ledger twice is not an error
[⚙️ assert] MySQL
✅ got: #t
[⚙️ assert] PostgreSQL
✅ got: #t
[🧪 test] the columns are read from the catalogue as well
[⚙️ assert] SQLite gets the pragma
✅ got: #t
[⚙️ assert] PostgreSQL gets the column names
✅ got: #t
[🧪 test] the ledger has the same columns on every engine
[⚙️ assert] what the runner reads and writes
✅ got: (name checksum description kind installed-on installed-by execution-time success)
[⚙️ assert] MySQL agrees
✅ got: (name checksum description kind installed-on installed-by execution-time success)
[⚙️ assert] and PostgreSQL
✅ got: (name checksum description kind installed-on installed-by execution-time success)
[🧪 test] the catalogue is asked, not the table
[⚙️ assert] SQLite asks sqlite_master
✅ got: #t
[⚙️ assert] PostgreSQL asks information_schema
✅ got: #t
[⚙️ assert] MySQL asks information_schema too
✅ got: #t
[🧪 test] each engine gets a ledger it can create
[⚙️ assert] SQLite's own autoincrement
✅ got: #t
[⚙️ assert] PostgreSQL's serial and timestamps
✅ got: #t
[⚙️ assert] MySQL's unique key and engine
✅ got: #t
+----------------------------------------------+
[📑 suite] reading a ledger column
[🧪 test] every other column is read as it is named
[⚙️ assert] a ledger column comes back quoted
✅ got: "name"
[⚙️ assert] with the engine's own quoting
✅ got: `success`
[🧪 test] the timestamp column is read as text, where the driver needs it
[⚙️ assert] PostgreSQL, whose driver cannot unpack a TIMESTAMPTZ
✅ got: "installed_on"::text AS "installed_on"
[⚙️ assert] MySQL, whose driver answers with a number instead
✅ got: DATE_FORMAT(`installed_on`, '%Y-%m-%d %H:%i:%s') AS `installed_on`
[⚙️ assert] and MariaDB through the same alias
✅ got: DATE_FORMAT(`installed_on`, '%Y-%m-%d %H:%i:%s') AS `installed_on`
[⚙️ assert] SQLite, which keeps its timestamps as text already
✅ got: "installed_on"
[⚙️ assert] and CockroachDB, which is reached as PostgreSQL
✅ got: "installed_on"::text AS "installed_on"
[⚙️ assert] including the name the first ledger called it
✅ got: "applied_at"::text AS "applied_at"
+----------------------------------------------+
[📑 suite] dropping what clean found
[🧪 test] each engine lists what it can drop
[⚙️ assert] SQLite, without its own internal tables
✅ got: #t
[⚙️ assert] PostgreSQL, tables and views
✅ got: #t
[⚙️ assert] MySQL, through information_schema
✅ got: #t
[🧪 test] only PostgreSQL drops with CASCADE
[⚙️ assert] PostgreSQL cascades
✅ got: DROP TABLE IF EXISTS "users" CASCADE
[⚙️ assert] SQLite has nothing to cascade
✅ got: DROP TABLE IF EXISTS "users"
[⚙️ assert] and neither has MySQL
✅ got: DROP TABLE IF EXISTS `users`
[🧪 test] a view, a trigger and an index are dropped as what they are
[⚙️ assert] a view is dropped as a view
✅ got: DROP VIEW IF EXISTS "active_users" CASCADE
[⚙️ assert] a trigger as a trigger, whatever the case
✅ got: DROP TRIGGER IF EXISTS "touch_users"
[⚙️ assert] an index as an index
✅ got: DROP INDEX IF EXISTS `email_1`
[🧪 test] an object type is normalised to one of four
[⚙️ assert] a base table is a table
✅ got: table
[⚙️ assert] and so is a system table
✅ got: table
[⚙️ assert] a view is a view
✅ got: view
[⚙️ assert] a trigger is a trigger
✅ got: trigger
[⚙️ assert] an index is an index
✅ got: index
ℹ️ info - ran 5 tasks in: 0 seconds, 139639 microseconds
running unit tests from file: sql-parser.scm, entrypoint: spec
+----------------------------------------------+
[📑 suite] a semicolon is not always the end
[🧪 test] a file of whitespace and comments holds no statements
[⚙️ assert] nothing to run
✅ got: ()
[⚙️ assert] and an empty file has nothing either
✅ got: ()
[🧪 test] a doubled quote does not end the string
[⚙️ assert] the escaped quote is part of the value
✅ got: (SELECT 'it''s; fine')
[🧪 test] a semicolon inside a quoted identifier is part of the identifier
[⚙️ assert] the identifier is not cut in half
✅ got: (CREATE TABLE "we;ird" (x int))
[🧪 test] a semicolon inside a string is part of the string
[⚙️ assert] the insert is not cut in half
✅ got: (INSERT INTO t VALUES ('a;b') SELECT 1)
[⚙️ assert] and it still holds its semicolon
✅ got: #t
[🧪 test] a statement that is never terminated is still a statement
[⚙️ assert] the last statement is read
✅ got: (SELECT 1 SELECT 2)
[🧪 test] the line a statement starts on is reported
[⚙️ assert] the line of the first real character
✅ got: (1 3)
[🧪 test] nothing between two semicolons is not a statement
[⚙️ assert] the empty one is dropped
✅ got: (SELECT 1 SELECT 2)
[🧪 test] two statements separated by semicolons are two
[⚙️ assert] both are read
✅ got: (((index . 0) (line . 1) (sql . SELECT 1)) ((index . 1) (line . 1) (sql . SELECT 2)))
[⚙️ assert] and the delimiter is not part of either
✅ got: (SELECT 1 SELECT 2)
[⚙️ assert] each carries its position
✅ got: (0 1)
+----------------------------------------------+
[📑 suite] comments
[🧪 test] what a statement means is decided without its comments
[⚙️ assert] SQL is meaningful
✅ got: #t
[⚙️ assert] a comment is not
✅ got: #f
[⚙️ assert] and neither is whitespace
✅ got: #f
[⚙️ assert] the two questions are each other's opposite
✅ got: #t
[🧪 test] a comment can be stripped for the question of what is in a statement
[⚙️ assert] the SQL is kept
✅ got: #t
[⚙️ assert] and every comment is gone
✅ got: #f
[⚙️ assert] a block comment goes too
✅ got: #t
[🧪 test] a trailing comment neither splits nor extends a statement
[⚙️ assert] the comment is not a second statement
✅ got: (SELECT 1)
[🧪 test] `#' is a comment for MySQL and an operator for PostgreSQL
[⚙️ assert] MySQL reads it as a comment
✅ got: (# a; comment
SELECT 1)
[⚙️ assert] PostgreSQL does not, so the `;' splits
✅ got: (# a comment
SELECT 1)
[🧪 test] a `--' comment runs to the end of the line
[⚙️ assert] the semicolon in it is not one
✅ got: (-- a; comment
SELECT 1)
[🧪 test] a block comment nests where the engine nests them
[⚙️ assert] PostgreSQL reads one comment and one statement
✅ got: (/* outer /* inner; */ still; */ SELECT 1)
[⚙️ assert] with the select after it
✅ got: #t
[⚙️ assert] and the others split at the inner semicolon
✅ got: (/* outer /* inner; */ still */ SELECT 1)
+----------------------------------------------+
[📑 suite] what only one dialect does
[🧪 test] a backslash escapes inside a MySQL string
[⚙️ assert] MySQL's escaped quote keeps the string open
✅ got: (INSERT INTO t VALUES ('a\';b'))
[⚙️ assert] PostgreSQL's string ends at the quote
✅ got: (INSERT INTO t VALUES ('a\' b');)
[🧪 test] an `E' that is the tail of a word is not one
[⚙️ assert] a word ending in W is not an escape string
✅ got: (SELECT W'it\'s fine';)
[🧪 test] a backtick identifier is MySQL's alone
[⚙️ assert] MySQL reads the backtick as an identifier
✅ got: (CREATE TABLE `we;ird` (x int))
[⚙️ assert] and PostgreSQL does not
✅ got: (CREATE TABLE `we ird` (x int))
[🧪 test] PostgreSQL's `E' strings are escape strings
[⚙️ assert] the `E' makes the backslash an escape
✅ got: (SELECT E'it\'s; fine')
+----------------------------------------------+
[📑 suite] a body a semicolon must not end
[🧪 test] SQLite's trigger body is one statement
[⚙️ assert] the trigger and the select
✅ got: (CREATE TRIGGER touch AFTER INSERT ON users
BEGIN
UPDATE users SET n = 1;
DELETE FROM tmp;
END SELECT 1)
[⚙️ assert] the whole body is in the first
✅ got: #t
[⚙️ assert] including its END
✅ got: #t
[🧪 test] a statement that is not a CREATE is left exactly as it is
[⚙️ assert] three statements, not one
✅ got: (BEGIN SELECT 1 COMMIT)
[🧪 test] an `END IF' inside the body does not close it
[⚙️ assert] the routine and the select
✅ got: (CREATE PROCEDURE p()
BEGIN
IF x THEN
SELECT 1;
END IF;
SELECT 2;
END SELECT 3)
[⚙️ assert] the body after the END IF is still in it
✅ got: #t
+----------------------------------------------+
[📑 suite] dollar quoting
[🧪 test] a tag makes the quoting explicit, and can appear in the body
[⚙️ assert] the function and the select
✅ got: (CREATE FUNCTION f() RETURNS int AS $body$
SELECT 1; -- $$ is just text in here
$body$ LANGUAGE sql SELECT 2)
[⚙️ assert] and the `$$' inside is data
✅ got: #t
[🧪 test] a function body written with `$$' is one statement
[⚙️ assert] the function and the select
✅ got: (CREATE FUNCTION f() RETURNS int AS $$
BEGIN
RETURN 1;
END;
$$ LANGUAGE plpgsql SELECT 1)
[⚙️ assert] the body is in the first statement
✅ got: #t
[🧪 test] a positional parameter is not a tag
[⚙️ assert] the statement still ends at its semicolon
✅ got: (SELECT $1, $2 SELECT 3)
+----------------------------------------------+
[📑 suite] the mysql client's own directive
[🧪 test] the directive retargets the splitter
[⚙️ assert] the trigger and the select
✅ got: (CREATE TRIGGER t AFTER INSERT ON u
BEGIN
SELECT 1;
END SELECT 2)
[⚙️ assert] the body survived the new delimiter
✅ got: #t
[⚙️ assert] and the directive is not sent anywhere
✅ got: #f
[⚙️ assert] nor is the one that restored it
✅ got: #f
[🧪 test] a DELIMITER line is recognised, and only when it is one
[⚙️ assert] the delimiter is reported
✅ got: (delimiter . $$)
[⚙️ assert] in any case
✅ got: (delimiter . //)
[⚙️ assert] a word that only starts with it is not it
✅ got: #f
[⚙️ assert] nor is one with nothing to set
✅ got: #f
[⚙️ assert] nor one asking for two things
✅ got: #f
[⚙️ assert] nor a commented-out one
✅ got: #f
+----------------------------------------------+
[📑 suite] the entry points agree with each other
[🧪 test] an alias resolves to the dialect it names
[⚙️ assert] MariaDB lexes as MySQL
✅ got: (# a; comment
SELECT 1)
[🧪 test] the first statement of a file, and the line it is on
[⚙️ assert] the first statement is the first
✅ got: SELECT 1
[⚙️ assert] and it knows which line it starts on
✅ got: 3
[🧪 test] the byte order mark some editors write is not part of the SQL
[⚙️ assert] the BOM is dropped
✅ got: SELECT 1
[🧪 test] the string-in/list-of-strings-out entry point
[⚙️ assert] the simple entry point splits the same way
✅ got: (SELECT 1 SELECT 2)
[⚙️ assert] and knows the engine it was given
✅ got: (# a; comment
SELECT 1)
[⚙️ assert] with the `#' line read as a comment
✅ got: #t
ℹ️ info - ran 7 tasks in: 0 seconds, 108879 microseconds
running unit tests from file: sql-runner.scm, entrypoint: spec
+----------------------------------------------+
[📑 suite] the ledger, on a real database
[🧪 test] a closed session can be collected without an error
[⚙️ assert] closing a session twice, and collecting it, is not an error
✅ got: #t
[🧪 test] forgetting a migration removes its row
[⚙️ assert] forgetting a migration removes its row
✅ got: ()
[⚙️ assert] and looking it up answers nothing
✅ got: #f
[🧪 test] a recorded migration reads back in full
[⚙️ assert] one migration is one row
✅ got: (((id . 1) (name . 2026-01-01_10:00:00_init.sql) (checksum . d0f1) (description . init) (kind . versioned) (installed-on . 2026-11-10 20:04:30) (installed-by . mutastructura) (execution-time . 12) (success . 1)))
[⚙️ assert] with the name it was recorded under
✅ got: 2026-01-01_10:00:00_init.sql
[⚙️ assert] and its checksum
✅ got: d0f1
[⚙️ assert] and its kind, which only this ledger version has
✅ got: versioned
[⚙️ assert] and how long it took
✅ got: 12
[⚙️ assert] and a success the core can read
✅ got: #t
[🧪 test] recording the same migration again replaces its row
[⚙️ assert] recording the same migration again leaves one row
✅ got: (((id . 1) (name . 2026-01-01_10:00:00_init.sql) (checksum . d0f1) (description . init) (kind . versioned) (installed-on . 2026-11-10 20:04:30) (installed-by . mutastructura) (execution-time . 99) (success . 1)))
[⚙️ assert] with what the second recording said
✅ got: 99
[🧪 test] a session that may not write writes nothing
[⚙️ assert] a session that may not create the ledger does not
✅ got: #f
[⚙️ assert] and a database with no ledger has no history to report
✅ got: ()
[⚙️ assert] and nothing was written to the database at all
✅ got: ()
[🧪 test] opening a session creates the ledger
[⚙️ assert] opening a session creates the ledger
✅ got: #t
[⚙️ assert] and the catalogue agrees it is there
✅ got: #t
[⚙️ assert] and it holds nothing yet
✅ got: ()
[⚙️ assert] with the columns the ledger is made of
✅ got: (id name checksum description kind installed-on installed-by execution-time success)
+----------------------------------------------+
[📑 suite] reading rows
[🧪 test] an empty answer is not a failure
[⚙️ assert] a query with no rows answers with no rows, and no error
✅ got: ()
[🧪 test] every row of a query comes back
[⚙️ assert] every row of a query comes back
✅ got: (((a . 1) (b . x)) ((a . 2) (b . y)))
[⚙️ assert] with the values the database has
✅ got: 1
[🧪 test] a refused query raises
[⚙️ assert] a refused query raises the database's own message
✅ got: #t
+----------------------------------------------+
[📑 suite] running a migration
[🧪 test] a file becomes its statements, placeholders and all;;; note: source file ./src/mutastructura/mutastructura.scm
;;; newer than compiled /gnu/store/21afi1i81zcsj3g9fjxxaxrkfxm3gfjp-profile/lib/guile/3.0/site-ccache/mutastructura/mutastructura.go
;;; found fresh local cache at /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/mutastructura/trunk/src/mutastructura/mutastructura.scm.go
;;; note: source file ./src/mutastructura/persistence/sql-parser.scm
;;; newer than compiled /gnu/store/21afi1i81zcsj3g9fjxxaxrkfxm3gfjp-profile/lib/guile/3.0/site-ccache/mutastructura/persistence/sql-parser.go
;;; found fresh local cache at /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/mutastructura/trunk/src/mutastructura/persistence/sql-parser.scm.go
;;; note: source file ./src/mutastructura/persistence/migration-runner.scm
;;; newer than compiled /gnu/store/21afi1i81zcsj3g9fjxxaxrkfxm3gfjp-profile/lib/guile/3.0/site-ccache/mutastructura/persistence/migration-runner.go
;;; found fresh local cache at /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/mutastructura/trunk/src/mutastructura/persistence/migration-runner.scm.go
;;; note: source file ./src/mutastructura/persistence/util.scm
;;; newer than compiled /gnu/store/21afi1i81zcsj3g9fjxxaxrkfxm3gfjp-profile/lib/guile/3.0/site-ccache/mutastructura/persistence/util.go
;;; found fresh local cache at /root/.cache/guile/ccache/3.0-LE-8-4.7/etc/byggsteg/job-clone/mutastructura/trunk/src/mutastructura/persistence/util.scm.go
[⚙️ assert] a file is read as its statements
✅ got: (((index . 0) (line . 2) (sql . -- ${other} is somebody else's
CREATE TABLE app_users (id INTEGER PRIMARY KEY))) ((index . 1) (line . 3) (sql . CREATE INDEX users_idx ON app_users (id))))
[⚙️ assert] with the placeholder substituted in the first
✅ got: #t
[⚙️ assert] and in the second
✅ got: #t
[⚙️ assert] and a placeholder nobody defined is left alone
✅ got: #t
[🧪 test] a dry run reports and changes nothing
[⚙️ assert] a dry run reports the statements it would run
✅ got: 2
[⚙️ assert] and runs none of them
✅ got: #f
[🧪 test] applying then cleaning leaves an empty database
[⚙️ assert] applying a migration creates its table
✅ got: #t
[⚙️ assert] a dry run names what clean would drop
✅ got: 3
[⚙️ assert] and drops nothing
✅ got: #t
[⚙️ assert] clean drops what the catalogue reports
✅ got: 3
[⚙️ assert] and the database, ledger included, is empty
✅ got: ()
+----------------------------------------------+
[📑 suite] the vtable
[🧪 test] the SQL runner and the engines it answers for
[⚙️ assert] the SQL runner is the relational family
✅ got: relational
[⚙️ assert] and it says what it speaks
✅ got: #t
[⚙️ assert] sqlite3 is spoken to by it
✅ got: relational
[⚙️ assert] and so is an engine reached through MySQL's driver
✅ got: relational
ℹ️ info - ran 4 tasks in: 1 seconds, -269660 microseconds
finished running tests
--------------------------------------------------------------
Maak 0.14.0: the infinitely extensible command runner
Loading tasks from Maak file: /etc/byggsteg/job-clone/mutastructura/trunk/maak.scm
Executing Maak tasks: test
--------------------------------------------------------------
=> Running Maak task: test
Run the unit test suite with Veritas.
Execute command:
env VERITAS_TEST_TYPE=unit VERITAS_RUN_BENCHMARKS=false guix shell -m manifest.scm -- guile -L ./src -L ./test -L . -c '((@ (veritas runner) run-tests))'
Executing: env VERITAS_TEST_TYPE=unit VERITAS_RUN_BENCHMARKS=false guix shell -m manifest.scm -- guile -L ./src -L ./test -L . -c '((@ (veritas runner) run-tests))'
✓ command finished in 2.70s
→ running command: cd /etc/byggsteg/job-clone/mutastructura/trunk && sudo maak deploy
--------------------------------------------------------------
Maak 0.14.0: the infinitely extensible command runner
Loading tasks from Maak file: /etc/byggsteg/job-clone/mutastructura/trunk/maak.scm
Executing Maak tasks: deploy
--------------------------------------------------------------
=> Running Maak task: deploy
API documentation saved to doc/api
index.texi: warning: must specify a title with a title command or @top
Executing: guix time-machine --channels=channels.scm -- shell -m manifest.scm -- documenta api ./src/mutastructura
Executing: guix time-machine --channels=channels.scm -- shell -m manifest.scm -- texi2any -v --html --css-ref=https://jointhefreeworld.org/static/css/jointhefreeworld.css ./doc/api/index.texi
renamed './index' -> './doc/api-dist'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/API.html'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fmain.html'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fmutastructura.html'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005fdialect.html'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005fmigration_002drunner.html'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005frunners.html'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005fsql_002dparser.html'
removed '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005futil.html'
removed directory '/srv/http/jointhefreeworld.org/api-docs/mutastructura'
mkdir: created directory '/srv/http/jointhefreeworld.org/api-docs/mutastructura'
renamed 'doc/api-dist/API.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/API.html'
renamed 'doc/api-dist/mutastructura_005fmain.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fmain.html'
renamed 'doc/api-dist/mutastructura_005fmutastructura.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fmutastructura.html'
renamed 'doc/api-dist/mutastructura_005fpersistence_005fdialect.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005fdialect.html'
renamed 'doc/api-dist/mutastructura_005fpersistence_005fmigration_002drunner.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005fmigration_002drunner.html'
renamed 'doc/api-dist/mutastructura_005fpersistence_005frunners.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005frunners.html'
renamed 'doc/api-dist/mutastructura_005fpersistence_005fsql_002dparser.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005fsql_002dparser.html'
renamed 'doc/api-dist/mutastructura_005fpersistence_005futil.html' -> '/srv/http/jointhefreeworld.org/api-docs/mutastructura/mutastructura_005fpersistence_005futil.html'
Executing: mv -v doc/api-dist/* /srv/http/jointhefreeworld.org/api-docs/mutastructura
removed 'doc/api/index.texi'
removed directory 'doc/api'
removed directory 'doc/api-dist'
removed directory 'doc'
✓ command finished in 2.18s