check / check (push) Successful in 6m10s
cobra parsed flags for `sww healthcheck`, so `--x` exited 2 with cobra's error and `-h` printed help and exited 0, where the issue keeps HealthCheck's own message and status 1 for any argument. The command now passes every argument to HealthCheck. Model: opus-5-5
358 lines
8.3 KiB
Go
358 lines
8.3 KiB
Go
package sww_test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/rand"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strings"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
|
|
// The time zone database, so that the process TestMainRunsWAF starts
|
|
// finds the zone TZ names on any host.
|
|
_ "time/tzdata"
|
|
|
|
"sneak.berlin/go/smallwebwaf/internal/sww"
|
|
"sneak.berlin/go/smallwebwaf/internal/waf"
|
|
)
|
|
|
|
// commandForMain, while set in the environment, has this test binary run Main
|
|
// with the command it gives, in place of the tests, so that a test can run
|
|
// Main in a process of its own.
|
|
const commandForMain = "SWW_TEST_COMMAND"
|
|
|
|
func TestMain(m *testing.M) {
|
|
command, set := os.LookupEnv(commandForMain)
|
|
if !set {
|
|
os.Exit(m.Run())
|
|
}
|
|
|
|
os.Args = strings.Fields("sww " + command)
|
|
|
|
os.Exit(sww.Main(testVersion))
|
|
}
|
|
|
|
// startProcess starts cmd and returns a channel that gets its exit status. As
|
|
// the test ends, cmd is killed and the test waits for it to exit.
|
|
func startProcess(t *testing.T, cmd *exec.Cmd) <-chan int {
|
|
t.Helper()
|
|
|
|
err := cmd.Start()
|
|
if err != nil {
|
|
t.Fatalf("start: %v", err)
|
|
}
|
|
|
|
exited := make(chan int, 1)
|
|
waitReturned := make(chan struct{})
|
|
|
|
go func() {
|
|
_ = cmd.Wait()
|
|
exited <- cmd.ProcessState.ExitCode()
|
|
|
|
close(waitReturned)
|
|
}()
|
|
|
|
t.Cleanup(func() {
|
|
_ = cmd.Process.Kill()
|
|
|
|
<-waitReturned
|
|
})
|
|
|
|
return exited
|
|
}
|
|
|
|
func TestMainRunsWAF(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// Kiritimati is 14 hours ahead of UTC; every time sww gives stays in UTC.
|
|
const zone = "Pacific/Kiritimati"
|
|
|
|
_, err := time.LoadLocation(zone)
|
|
if err != nil {
|
|
t.Fatalf("load %s: %v", zone, err)
|
|
}
|
|
|
|
binary, err := os.Executable()
|
|
if err != nil {
|
|
t.Fatalf("find the test binary: %v", err)
|
|
}
|
|
|
|
dir := t.TempDir()
|
|
out := &output{}
|
|
//nolint:gosec // this test binary
|
|
cmd := exec.CommandContext(t.Context(), binary)
|
|
cmd.Stdout = out
|
|
|
|
// The Core Rule Set is off. Main keeps waf's own limit for its checks,
|
|
// and on a busy host the Core Rule Set's inspection can pass it.
|
|
cmd.Env = append(os.Environ(),
|
|
"TZ="+zone,
|
|
commandForMain+"="+wafCommand,
|
|
listenAddr+"="+localhost+":0",
|
|
stateDir+"="+dir,
|
|
cacheDir+"="+dir,
|
|
ruleFilesDir+"="+t.TempDir(),
|
|
lookupSource+"=off",
|
|
"SWW_WAF_CORE_RULE_SET_MODE=off")
|
|
|
|
exited := startProcess(t, cmd)
|
|
|
|
starting := out.lineBeforeExit(t, "starting", exited)
|
|
addr, _ := starting["address"].(string)
|
|
ask(t, addr, "/", http.StatusOK, waf.DispositionAllow)
|
|
|
|
// The files are written as sww stops.
|
|
err = cmd.Process.Signal(syscall.SIGTERM)
|
|
if err != nil {
|
|
t.Fatalf("signal: %v", err)
|
|
}
|
|
|
|
select {
|
|
case status := <-exited:
|
|
if status != 0 {
|
|
t.Fatalf(
|
|
"exit status %d, want 0; output:\n%s",
|
|
status,
|
|
out.text(),
|
|
)
|
|
}
|
|
case <-time.After(waitLimit):
|
|
t.Fatal("still running after being told to stop")
|
|
}
|
|
|
|
wantUTC(t, "the process line", starting["time"])
|
|
wantUTC(t, "the request line", out.line(t, "type", "request")["time"])
|
|
|
|
path := filepath.Join(dir, "clients.json")
|
|
|
|
//nolint:gosec // a file in the test's directory
|
|
clients, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatalf("read clients.json: %v", err)
|
|
}
|
|
|
|
stamp := regexp.MustCompile(`"\d{4}-\d\d-\d\dT[^"]*"`)
|
|
|
|
times := stamp.FindAllString(string(clients), -1)
|
|
if len(times) == 0 {
|
|
t.Errorf("clients.json holds no time:\n%s", clients)
|
|
}
|
|
|
|
for _, stored := range times {
|
|
wantUTC(t, "clients.json", strings.Trim(stored, `"`))
|
|
}
|
|
}
|
|
|
|
// wantUTC checks that value, a time read from the log line or file that
|
|
// where names, is in UTC.
|
|
func wantUTC(t *testing.T, where string, value any) {
|
|
t.Helper()
|
|
|
|
text, _ := value.(string)
|
|
if !strings.HasSuffix(text, "Z") {
|
|
t.Errorf("%s gives the time %v, want one in UTC", where, value)
|
|
}
|
|
}
|
|
|
|
func TestMainWithoutACommandItKnowsPrintsTheCommands(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
// completion is cobra's own command, which sww turns off.
|
|
for _, command := range []string{"", "serve", "completion"} {
|
|
t.Run("command "+command, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
code, stdout, stderr := runMain(t, command)
|
|
|
|
if code != 2 {
|
|
t.Errorf("exit status %d, want 2", code)
|
|
}
|
|
|
|
wantTheCommands(t, "stderr", stderr)
|
|
|
|
if stdout != "" {
|
|
t.Errorf("stdout %q, want nothing", stdout)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMainHelpPrintsTheCommands(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, command := range []string{"help", "--help"} {
|
|
t.Run("command "+command, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
code, stdout, _ := runMain(t, command)
|
|
|
|
if code != 0 {
|
|
t.Errorf("exit status %d, want 0", code)
|
|
}
|
|
|
|
wantTheCommands(t, "stdout", stdout)
|
|
})
|
|
}
|
|
}
|
|
|
|
// wantTheCommands checks that text, what Main wrote to where, names each
|
|
// command.
|
|
func wantTheCommands(t *testing.T, where, text string) {
|
|
t.Helper()
|
|
|
|
for _, name := range []string{"rproxy", wafCommand, "healthcheck"} {
|
|
if !strings.Contains(text, name) {
|
|
t.Errorf("%s %q does not name %s", where, text, name)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMainHealthCheckRefusesAnArgument(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, argument := range []string{"now", "--x", "-h"} {
|
|
t.Run("argument "+argument, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
code, stdout, stderr := runMain(t, "healthcheck "+argument)
|
|
|
|
want := "sww healthcheck: unexpected argument \"" +
|
|
argument + "\"\n"
|
|
if code != 1 || stderr != want || stdout != "" {
|
|
t.Errorf("exit status %d, stdout %q and stderr %q, "+
|
|
"want 1, nothing and %q", code, stdout, stderr, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// runMain runs Main with command in a process of its own, and returns its
|
|
// exit status and what it wrote to stdout and stderr.
|
|
func runMain(t *testing.T, command string) (int, string, string) {
|
|
t.Helper()
|
|
|
|
binary, err := os.Executable()
|
|
if err != nil {
|
|
t.Fatalf("find the test binary: %v", err)
|
|
}
|
|
|
|
ctx, cancel := context.WithTimeout(t.Context(), waitLimit)
|
|
defer cancel()
|
|
|
|
var stdout, stderr bytes.Buffer
|
|
|
|
//nolint:gosec // this test binary
|
|
cmd := exec.CommandContext(ctx, binary)
|
|
cmd.Stdout, cmd.Stderr = &stdout, &stderr
|
|
|
|
cmd.Env = append(os.Environ(), commandForMain+"="+command)
|
|
|
|
err = cmd.Run()
|
|
|
|
var exitErr *exec.ExitError
|
|
if err != nil && !errors.As(err, &exitErr) {
|
|
t.Fatalf("run: %v", err)
|
|
}
|
|
|
|
return cmd.ProcessState.ExitCode(), stdout.String(), stderr.String()
|
|
}
|
|
|
|
// ask sends waf at addr rproxy's question about a request for path from
|
|
// placed, checks the answer's status and disposition, and closes it.
|
|
func ask(t *testing.T, addr, path string, status int, disposition string) {
|
|
t.Helper()
|
|
|
|
req, err := http.NewRequestWithContext(t.Context(), http.MethodGet,
|
|
"http://"+addr+path, http.NoBody)
|
|
if err != nil {
|
|
t.Fatalf("new request: %v", err)
|
|
}
|
|
|
|
req.Header.Set(waf.ClientHeader, placed)
|
|
req.Header.Set("X-Request-ID", rand.Text())
|
|
|
|
transport := &http.Transport{}
|
|
defer transport.CloseIdleConnections()
|
|
|
|
res, err := (&http.Client{Transport: transport}).Do(req)
|
|
if err != nil {
|
|
t.Fatalf("question: %v", err)
|
|
}
|
|
|
|
_, _ = io.Copy(io.Discard, res.Body)
|
|
_ = res.Body.Close()
|
|
|
|
if res.StatusCode != status ||
|
|
res.Header.Get(waf.DispositionHeader) != disposition {
|
|
t.Errorf(
|
|
"answered %d with disposition %q, want %d with %q",
|
|
res.StatusCode,
|
|
res.Header.Get(waf.DispositionHeader),
|
|
status,
|
|
disposition,
|
|
)
|
|
}
|
|
}
|
|
|
|
// runWAF runs `sww waf` with the settings in env, has use
|
|
// send it requests at the address it listens on, stops it as SIGTERM does, and
|
|
// checks that it stopped in order.
|
|
func runWAF(t *testing.T, env map[string]string, use func(addr string)) {
|
|
t.Helper()
|
|
|
|
ctx, stop := context.WithCancel(t.Context())
|
|
out := &output{}
|
|
exited := make(chan int, 1)
|
|
|
|
go func() {
|
|
exited <- run(ctx, env, out)
|
|
}()
|
|
|
|
addr, _ := out.lineBeforeExit(t, "starting", exited)["address"].(string)
|
|
use(addr)
|
|
stop()
|
|
|
|
select {
|
|
case status := <-exited:
|
|
if status != 0 {
|
|
t.Fatalf(
|
|
"exit status %d, want 0; output:\n%s",
|
|
status,
|
|
out.text(),
|
|
)
|
|
}
|
|
case <-time.After(waitLimit):
|
|
t.Fatal("still running after being told to stop")
|
|
}
|
|
|
|
out.line(t, "msg", "stopped")
|
|
}
|
|
|
|
func TestWAFKeepsItsBansAcrossARestartAndNeedsNoApp(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
env := map[string]string{
|
|
listenAddr: localhost + ":0",
|
|
stateDir: t.TempDir(),
|
|
ruleFilesDir: filepath.Join("..", "..", "share", "rules.d"),
|
|
}
|
|
|
|
runWAF(t, env, func(addr string) {
|
|
ask(t, addr, "/", http.StatusOK, waf.DispositionAllow)
|
|
// The default rule file bans a probe for this.
|
|
ask(t, addr, "/.env", http.StatusForbidden, waf.DispositionDeny)
|
|
})
|
|
|
|
runWAF(t, env, func(addr string) {
|
|
ask(t, addr, "/", http.StatusForbidden, waf.DispositionDeny)
|
|
})
|
|
}
|