Files
skyg-linux-tracker/dev/test.nu
T

385 lines
14 KiB
Nu
Executable File

#!/usr/bin/env nu
# The single source of truth for names and flags: drives dispatch, zsh/bash
# completion and the self-check. Nushell completion still comes from the
# signatures below; the self-check keeps both in step.
const command_table = [
{ name: "unit", usage: "cargo test --lib --bins", flags: [] }
{ name: "integration", usage: "cargo test --tests [filter] [--nocapture]", flags: ["--nocapture"] }
{ name: "lint", usage: "fmt, clippy and the openssl check", flags: [] }
{ name: "vm", usage: "nix build of a NixOS VM test: vm or peers", flags: [] }
{ name: "all", usage: "lint, unit, integration; stops at the first failure", flags: [] }
{ name: "ci", usage: "all plus the vm test", flags: [] }
{ name: "completions", usage: "print a zsh or bash completion script", flags: [] }
{ name: "self-check", usage: "check that the table, commands and help agree", flags: [] }
]
# One entry point for the repository's checks.
#
# Subcommands:
# unit cargo test --lib --bins
# integration cargo test --tests [filter] [--nocapture]
# lint cargo fmt --check, cargo clippy --all-targets -- -D warnings, cargo tree -i openssl (empty)
# vm nix build of a NixOS VM test: vm (checks) or peers (tests.<system>.peers)
# all lint, unit, integration; stops at the first failure
# ci all plus the vm test
# completions print a zsh or bash completion script
# self-check fail when the command table, the commands and the help text diverge
#
# Loaded as a module (`use dev/test.nu *`) this file provides `test` plus one
# command per subcommand, so Nushell completes names and flags natively.
#
# The checks are read-only against the host: no /etc, systemd or Docker changes.
export def main [
...args: string # subcommand and its arguments, as in `test integration peers`
--nocapture # forward to `test integration`
] {
if ($args | is-empty) {
print-help
return
}
let sub = ($args | first)
let rest = ($args | skip 1)
let positional = ($rest | where {|a| not ($a | str starts-with "-") })
if $sub not-in ($command_table | get name) {
error make { msg: $"unknown subcommand '($sub)'; run 'test --help' for the list" }
}
match $sub {
"unit" => { test unit }
"integration" => { test integration ($positional | get 0?) --nocapture=$nocapture }
"lint" => { test lint }
"vm" => { test vm ($positional | get 0?) }
"all" => { test all }
"ci" => { test ci }
"completions" => { test completions ($positional | get 0?) }
"self-check" => { test self-check }
_ => { error make { msg: $"subcommand '($sub)' has no dispatch arm" } }
}
}
# Run the unit tests: no sockets, no host access.
export def "test unit" [] {
run-steps (unit-steps)
}
# Run the integration tests (plain, tls, integration, binary_smoke, peers).
export def "test integration" [
filter?: string@"nu-complete test filters" # cargo name filter, e.g. a test name or file
--nocapture # do not capture test output
] {
run-steps (integration-steps $filter $nocapture)
}
# Formatting, lints and the dependency check.
export def "test lint" [] {
run-steps (lint-steps)
}
# Run a NixOS VM test. Slow: it builds and boots VMs.
export def "test vm" [
name?: string@"nu-complete test vm" # vm (checks) or peers (tests.<system>.peers)
] {
let name = ($name | default "vm")
if $name not-in (nu-complete test vm) {
error make { msg: $"unknown VM test '($name)'; expected one of: (nu-complete test vm | str join ', ')" }
}
run-steps (vm-steps $name)
}
# lint, unit and integration; stops at the first failure.
export def "test all" [] {
run-steps ((lint-steps) | append (unit-steps) | append (integration-steps null false))
}
# `test all` plus the VM test.
export def "test ci" [] {
run-steps ((lint-steps) | append (unit-steps) | append (integration-steps null false) | append (vm-steps "vm"))
}
# Print a completion script for a shell that cannot load this module (zsh, bash).
export def "test completions" [
shell?: string@"nu-complete test shells" # zsh or bash
] {
let shell = ($shell | default "zsh")
match $shell {
"zsh" => { print (completion-script zsh) }
"bash" => { print (completion-script bash) }
_ => { error make { msg: $"unknown shell '($shell)'; expected one of: (nu-complete test shells | str join ', ')" } }
}
}
# Fail if the command table, the defined commands or the help text diverge.
export def "test self-check" [] {
let problems = (check-consistency)
if not ($problems | is-empty) {
print -e "test self-check failed:"
$problems | each {|p| print -e $" - ($p)" } | ignore
exit 1
}
print "test self-check: command table, commands and help agree"
}
def "nu-complete test vm" [] {
["vm" "peers"]
}
def "nu-complete test shells" [] {
["zsh" "bash"]
}
# Test names come from cargo; the first Tab compiles in debug mode and is slow,
# so the list is kept for the rest of the session.
def "nu-complete test filters" [] {
if ($env.SKYG_TEST_FILTERS? | is-not-empty) {
return $env.SKYG_TEST_FILTERS
}
let listed = (do -i { run-external "cargo" "test" "--tests" "--" "--list" | complete })
let names = ($listed
| default {stdout: ""}
| get stdout
| lines
| where {|l| $l =~ ': (test|benchmark)$'}
| each {|l| $l | str replace -r ': (test|benchmark)$' '' | str replace -r '^.*: ' '' }
| uniq)
if not ($names | is-empty) {
$env.SKYG_TEST_FILTERS = $names
}
$names
}
def step-record [label: string, command: string, body: closure] {
{ label: $label, command: $command, body: $body }
}
def unit-steps [] {
[(step-record "unit" "cargo test --lib --bins" {||
run-checked "cargo" ["test" "--lib" "--bins"]
})]
}
def require-kvm [] {
if not ("/dev/kvm" | path exists) {
error make {
msg: "/dev/kvm is missing: NixOS VM tests need hardware virtualisation. Run on a Linux host with KVM, or in CI with KVM exposed; there is no software fallback."
}
}
}
def vm-steps [name: string] {
require-kvm
let attr = (match $name {
"peers" => "tests"
_ => "checks"
})
let system = $"($nu.os-info.arch)-($nu.os-info.name)"
[(step-record $"vm ($name)" $"nix build .#($attr).($system).($name) -L" {||
print "NixOS VM tests are slow: expect several minutes."
run-checked "nix" ["build" $".#($attr).($system).($name)" "-L"]
})]
}
def integration-steps [filter: any, nocapture: bool] {
let filter_args = (if ($filter | is-empty) { [] } else { ["--", $filter] })
let capture_args = (if $nocapture { ["--nocapture"] } else { [] })
let args = (["test" "--tests"] | append $filter_args | append $capture_args)
let label = (if ($filter | is-empty) { "integration" } else { $"integration ($filter)" })
[(step-record $label $"cargo ($args | str join ' ')" {|| run-checked "cargo" $args })]
}
def lint-steps [] {
[
(step-record "fmt" "cargo fmt --check" {||
run-checked "cargo" ["fmt" "--check"]
})
(step-record "clippy" "cargo clippy --all-targets -- -D warnings" {||
run-checked "cargo" ["clippy" "--all-targets" "--" "-D" "warnings"]
})
# An empty tree is the only acceptable answer; cargo itself exits non-zero
# when nothing matches, so the exit code is not the signal here.
(step-record "openssl" "cargo tree -i openssl (must be empty)" {||
let found = (run-external "cargo" "tree" "-i" "openssl" | complete)
if not (($found.stdout | str trim) | is-empty) {
error make { msg: $"openssl is in the dependency tree:\n($found.stdout)" }
}
})
]
}
# Run each step in order, stop at the first failure, always print the summary
# table and exit non-zero if anything failed.
def run-steps [steps: list] {
mut results = []
for s in $steps {
let r = (run-step $s)
$results = ($results | append $r)
if $r.result != "ok" { break }
}
let width = ([26 ($results | each {|r| $r.step | str length } | math max)] | math max)
print ""
print "Summary:"
print ((pad "step" $width "left") + (pad "result" 8 "left") + (pad "seconds" 9 "right") + " command")
for r in $results {
let status = (pad $r.result 8 "left")
print ((pad $r.step $width "left") + (if $r.result == "ok" { $"(ansi green)($status)(ansi reset)" } else { $"(ansi red)($status)(ansi reset)" }) + (pad $"(($r.seconds))s" 9 "right") + $" ($r.command)")
}
print ""
if ($results | any {|r| $r.result != "ok" }) {
exit 1
}
}
def pad [text: string, width: int, alignment: string] {
$text | fill -a $alignment -w $width
}
def run-step [s: record] {
print ""
print $"(ansi cyan)==> ($s.label)(ansi reset) ($s.command)"
let started = (date now)
let ok = (try {
do $s.body | ignore
true
} catch {|e|
print -e $"(ansi red)($s.label) failed: ($e.msg)(ansi reset)"
false
})
{
step: $s.label
command: $s.command
result: (if $ok { "ok" } else { "FAILED" })
seconds: ((((date now) - $started) / 1sec) | math round --precision 1)
}
}
# Redirect straight to stdout so long builds and tests show progress; Nushell
# raises on a non-zero exit, which the enclosing step records as a failure.
def run-checked [cmd: string, args: list<string>] {
run-external $cmd ...$args o> /dev/stdout
}
def print-help [] {
print "Run the repository's checks."
print ""
print "Usage: test <subcommand> [args]"
print ""
$command_table | each {|c| {subcommand: $c.name, flags: ($c.flags | str join " "), what: $c.usage} } | table -e | print
print ""
print "In Nushell: use dev/test.nu * (then `test integration peers`). In zsh/bash: source <(test completions zsh|bash)."
print "Underlying commands: test --help, or `test <subcommand> --help`."
}
def completion-script [shell: string] {
let subcommands = ($command_table | get name | str join " ")
let flags = ($command_table | get flags | flatten | uniq | str join " ")
let replacements = {
"__SUBCOMMANDS__": $subcommands
"__FLAGS__": $flags
"__VM__": (nu-complete test vm | str join " ")
"__SHELLS__": (nu-complete test shells | str join " ")
}
let template = (match $shell {
"zsh" => (zsh-template)
_ => (bash-template)
})
$replacements | transpose key value | reduce --fold $template {|it, acc| $acc | str replace -a $it.key $it.value }
}
def zsh-template [] {
# A raw string cannot start with `#` in Nushell, so the template starts on the next line.
r#'
#compdef test
# Completion for the repository test runner: source <(test completions zsh)
_test_runner() {
local -a subcommands
subcommands=(__SUBCOMMANDS__)
if (( CURRENT == 2 )); then
if [[ "${words[2]}" == -* ]]; then
compadd -- __FLAGS__
else
_describe 'subcommand' subcommands
fi
return
fi
case "${words[2]}" in
vm) compadd -- __VM__ __FLAGS__ ;;
completions) compadd -- __SHELLS__ ;;
*) compadd -- __FLAGS__ ;;
esac
}
compdef _test_runner test
'# | str trim --left
}
def bash-template [] {
r#'
# bash completion for the repository test runner: source <(test completions bash)
_test_runner() {
local cur sub i
cur="${COMP_WORDS[COMP_CWORD]}"
sub=""
for ((i=1; i<COMP_CWORD; i++)); do
case "${COMP_WORDS[i]}" in
-*) ;;
*) sub="${COMP_WORDS[i]}"; break ;;
esac
done
if [[ -z "$sub" ]]; then
COMPREPLY=( $(compgen -W "__SUBCOMMANDS__" -- "$cur") )
return 0
fi
case "$sub" in
vm) COMPREPLY=( $(compgen -W "__VM__ __FLAGS__" -- "$cur") ) ;;
completions) COMPREPLY=( $(compgen -W "__SHELLS__" -- "$cur") ) ;;
*) COMPREPLY=( $(compgen -W "__FLAGS__" -- "$cur") ) ;;
esac
return 0
}
complete -F _test_runner test
'# | str trim --left
}
# Compare the table with the commands Nushell actually parsed from this file and
# with the help block above; every entry must agree in all three places.
def check-consistency [] {
let defined = (scope commands | where {|c| $c.name == "test" or ($c.name | str starts-with "test ")} | get name
| where {|n| $n != "test" } | each {|n| $n | str substring 5.. })
let table = ($command_table | get name)
# The entry point is `test` once the file is used as a module and `main` when
# it runs as a script; both modes must agree with the table.
let entry = (scope commands | where {|c| $c.name in ["test" "main"]} | get 0?)
let usage = (if $entry == null { "" } else { $entry.extra_description | default "" })
mut problems = []
for name in $table {
if $name not-in $defined {
$problems = ($problems | append $"table lists '($name)' but there is no 'test ($name)' command")
}
if not ($usage =~ ('(?m)^\s+' + $name + '\s')) {
$problems = ($problems | append $"help text does not list '($name)'")
}
let cmd = (scope commands | where name == $"test ($name)" | get 0?)
let flags = (if $cmd == null { [] } else { $cmd.signatures | get any | where {|p| $p.parameter_type in ["switch" "named"]} | each {|p| $"--($p.parameter_name)" } | sort })
let expected = (($command_table | where name == $name | get 0.flags) | sort)
if $flags != $expected {
$problems = ($problems | append $"flags of 'test ($name)' are ($flags | to json -r), table says ($expected | to json -r)")
}
}
for name in $defined {
if $name not-in $table {
$problems = ($problems | append $"command 'test ($name)' is not in the command table")
}
}
# The generated shells must at least parse; only checked where the shell exists.
for shell in (nu-complete test shells) {
if not ((which $shell | is-empty)) {
let file = ($nu.temp-dir | path join $"test-completions-($nu.pid).($shell)")
completion-script $shell | save -f $file
let syntax = (run-external $shell "-n" $file | complete)
rm -f $file
if $syntax.exit_code != 0 {
$problems = ($problems | append $"($shell) completion script does not parse: ($syntax.stderr | str trim)")
}
}
}
$problems
}