283 lines
9.7 KiB
Go
283 lines
9.7 KiB
Go
package compose
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/aritmolab/thothii/tools/tht/internal/config"
|
|
)
|
|
|
|
func TestRunnerPassesEachArgumentWithoutShellSplitting(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
runner := NewRunner(writeExecutable(t, "#!/bin/sh\nprintf '<%s>\\n' \"$@\"\ncat\n"))
|
|
result, err := runner.Run(context.Background(), []string{"compose", "--project-directory", "/tmp/a project with spaces", "config"}, strings.NewReader("stdin value\n"))
|
|
if err != nil {
|
|
t.Fatalf("Run() error = %v", err)
|
|
}
|
|
want := "<compose>\n<--project-directory>\n</tmp/a project with spaces>\n<config>\nstdin value\n"
|
|
if result.Stdout != want {
|
|
t.Errorf("stdout = %q, want %q", result.Stdout, want)
|
|
}
|
|
if result.ExitCode != 0 {
|
|
t.Errorf("ExitCode = %d, want 0", result.ExitCode)
|
|
}
|
|
}
|
|
|
|
func TestRunnerBoundsFloodingOutputDuringCapture(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
runner := NewRunner(writeExecutable(t, "#!/bin/sh\nwhile :; do printf '0123456789abcdef'; printf 'fedcba9876543210' >&2; done\n"))
|
|
started := time.Now()
|
|
result, err := RunBounded(runner, context.Background(), []string{"compose", "run", "--rm", "core"}, nil, CaptureLimits{
|
|
StdoutBytes: 1024,
|
|
StderrBytes: 1024,
|
|
})
|
|
if !errors.Is(err, ErrOutputLimit) {
|
|
t.Fatalf("RunBounded() error = %v, want ErrOutputLimit", err)
|
|
}
|
|
if len(result.Stdout) > 1024 || len(result.Stderr) > 1024 {
|
|
t.Fatalf("captured output exceeded limits: stdout=%d stderr=%d", len(result.Stdout), len(result.Stderr))
|
|
}
|
|
if elapsed := time.Since(started); elapsed > 5*time.Second {
|
|
t.Fatalf("overflow teardown took %s", elapsed)
|
|
}
|
|
}
|
|
|
|
func TestRunnerCancelsAndReapsAHangingChildWithinFinalBound(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
runner := NewRunner(writeExecutable(t, "#!/bin/sh\ntrap '' TERM INT\nwhile :; do sleep 1; done\n"))
|
|
ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
|
|
defer cancel()
|
|
started := time.Now()
|
|
_, err := RunBounded(runner, ctx, []string{"compose", "run", "--rm", "core"}, nil, CaptureLimits{
|
|
StdoutBytes: 1024,
|
|
StderrBytes: 1024,
|
|
})
|
|
if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Fatalf("RunBounded() error = %v, want deadline exceeded", err)
|
|
}
|
|
if elapsed := time.Since(started); elapsed > 5*time.Second {
|
|
t.Fatalf("cancellation teardown took %s", elapsed)
|
|
}
|
|
}
|
|
|
|
func TestRunnerCleansUpNamedComposeContainerAfterOverflow(t *testing.T) {
|
|
logFile := filepath.Join(t.TempDir(), "calls.log")
|
|
marker := filepath.Join(t.TempDir(), "container-present")
|
|
if err := os.WriteFile(marker, []byte("present"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("THT_RUNNER_TEST_LOG", logFile)
|
|
t.Setenv("THT_RUNNER_TEST_MARKER", marker)
|
|
t.Setenv("THT_RUNNER_TEST_MODE", "flood")
|
|
runner := NewRunner(writeExecutable(t, cleanupAwareDockerScript))
|
|
name := "thothii-cleanup-overflow-sentinel"
|
|
|
|
_, err := RunBounded(runner, context.Background(), []string{
|
|
"compose", "run", "--rm", "--name", name, "core",
|
|
}, nil, CaptureLimits{StdoutBytes: 1024, StderrBytes: 1024})
|
|
|
|
if !errors.Is(err, ErrOutputLimit) {
|
|
t.Fatalf("RunBounded() error = %v, want ErrOutputLimit", err)
|
|
}
|
|
assertContainerCleanup(t, logFile, marker, name)
|
|
}
|
|
|
|
func TestRunnerCleansUpNamedComposeContainerAfterCancellation(t *testing.T) {
|
|
logFile := filepath.Join(t.TempDir(), "calls.log")
|
|
marker := filepath.Join(t.TempDir(), "container-present")
|
|
if err := os.WriteFile(marker, []byte("present"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("THT_RUNNER_TEST_LOG", logFile)
|
|
t.Setenv("THT_RUNNER_TEST_MARKER", marker)
|
|
t.Setenv("THT_RUNNER_TEST_MODE", "hang")
|
|
runner := NewRunner(writeExecutable(t, cleanupAwareDockerScript))
|
|
name := "thothii-cleanup-cancel-sentinel"
|
|
ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
|
|
defer cancel()
|
|
|
|
_, err := RunBounded(runner, ctx, []string{
|
|
"compose", "run", "--rm", "--name", name, "core",
|
|
}, nil, CaptureLimits{StdoutBytes: 1024, StderrBytes: 1024})
|
|
|
|
if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Fatalf("RunBounded() error = %v, want deadline exceeded", err)
|
|
}
|
|
assertContainerCleanup(t, logFile, marker, name)
|
|
}
|
|
|
|
func TestRunnerSurfacesCleanupFailureWithoutContainerName(t *testing.T) {
|
|
logFile := filepath.Join(t.TempDir(), "calls.log")
|
|
marker := filepath.Join(t.TempDir(), "container-present")
|
|
if err := os.WriteFile(marker, []byte("present"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("THT_RUNNER_TEST_LOG", logFile)
|
|
t.Setenv("THT_RUNNER_TEST_MARKER", marker)
|
|
t.Setenv("THT_RUNNER_TEST_MODE", "cleanup-fails")
|
|
runner := NewRunner(writeExecutable(t, cleanupAwareDockerScript))
|
|
name := "thothii-cleanup-secret-sentinel"
|
|
ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
|
|
defer cancel()
|
|
|
|
_, err := RunBounded(runner, ctx, []string{
|
|
"compose", "run", "--rm", "--name", name, "core",
|
|
}, nil, CaptureLimits{StdoutBytes: 1024, StderrBytes: 1024})
|
|
|
|
if err == nil || !strings.Contains(err.Error(), "one-shot container cleanup failed") {
|
|
t.Fatalf("RunBounded() error = %v, want safe cleanup failure", err)
|
|
}
|
|
if strings.Contains(err.Error(), name) {
|
|
t.Fatalf("RunBounded() exposed the container name: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRunnerPropagatesAReapingFailure(t *testing.T) {
|
|
original := terminateProcessForRunner
|
|
terminateProcessForRunner = func(command *exec.Cmd, done <-chan error) error {
|
|
_ = terminateProcess(command, done)
|
|
return ErrProcessReap
|
|
}
|
|
t.Cleanup(func() { terminateProcessForRunner = original })
|
|
runner := NewRunner(writeExecutable(t, "#!/bin/sh\ntrap '' TERM INT\nwhile :; do sleep 1; done\n"))
|
|
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
|
|
defer cancel()
|
|
|
|
_, err := RunBounded(runner, ctx, []string{"version"}, nil, CaptureLimits{
|
|
StdoutBytes: 1024, StderrBytes: 1024,
|
|
})
|
|
|
|
if !errors.Is(err, context.DeadlineExceeded) || !errors.Is(err, ErrProcessReap) {
|
|
t.Fatalf("RunBounded() error = %v, want deadline and reap failure", err)
|
|
}
|
|
}
|
|
|
|
func TestRunnerReturnsTheChildExitCode(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
runner := NewRunner(writeExecutable(t, "#!/bin/sh\necho unavailable >&2\nexit 42\n"))
|
|
result, err := runner.Run(context.Background(), []string{"compose", "ps"}, nil)
|
|
if err == nil {
|
|
t.Fatal("Run() error = nil, want child exit error")
|
|
}
|
|
if result.ExitCode != 42 {
|
|
t.Errorf("ExitCode = %d, want 42", result.ExitCode)
|
|
}
|
|
if result.Stderr != "unavailable\n" {
|
|
t.Errorf("stderr = %q, want unavailable output", result.Stderr)
|
|
}
|
|
}
|
|
|
|
func TestRunnerRetainsTheExactNormalRmInvocationForAnUnnamedOneShot(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
runner := NewRunner(writeExecutable(t, "#!/bin/sh\nprintf '%s\\n' \"$@\"\n"))
|
|
result, err := runner.Run(context.Background(), []string{
|
|
"compose", "run", "--rm", "--no-deps", "core", "node", "diagnostic.js",
|
|
}, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got := strings.Fields(result.Stdout)
|
|
if strings.Join(got, " ") != "compose run --rm --no-deps core node diagnostic.js" {
|
|
t.Fatalf("one-shot argv = %#v, want exact original --rm invocation", got)
|
|
}
|
|
}
|
|
|
|
func TestRunnerReportsMissingDocker(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
runner := NewRunner(filepath.Join(t.TempDir(), "docker-does-not-exist"))
|
|
result, err := runner.Run(context.Background(), []string{"compose", "version"}, nil)
|
|
if !errors.Is(err, exec.ErrNotFound) {
|
|
t.Fatalf("Run() error = %v, want exec.ErrNotFound", err)
|
|
}
|
|
if result.ExitCode != 127 {
|
|
t.Errorf("ExitCode = %d, want 127", result.ExitCode)
|
|
}
|
|
}
|
|
|
|
func TestInstallationRunnerAppliesComposeArgumentsWithoutRewritingHostDockerCommands(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
recorded := &recordingRunner{}
|
|
installation := config.Installation{
|
|
Path: "/tmp/thothii/deploy/local/thothii-installation.yaml",
|
|
Profile: "local",
|
|
ProjectDirectory: "/tmp/thothii",
|
|
EnvFile: "/tmp/thothii/deploy/local/operator.env",
|
|
}
|
|
runner := InstallationRunner{Installation: installation, Runner: recorded}
|
|
if _, err := runner.Run(context.Background(), []string{"compose", "ps"}, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := runner.Run(context.Background(), []string{"inspect", "core-id"}, nil); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if got, want := strings.Join(recorded.calls[0], " "), strings.Join(installation.ComposeArgs("ps"), " "); got != want {
|
|
t.Fatalf("Compose call = %q, want %q", got, want)
|
|
}
|
|
if got, want := strings.Join(recorded.calls[1], " "), "inspect core-id"; got != want {
|
|
t.Fatalf("host Docker call = %q, want %q", got, want)
|
|
}
|
|
}
|
|
|
|
type recordingRunner struct{ calls [][]string }
|
|
|
|
func (r *recordingRunner) Run(_ context.Context, args []string, _ io.Reader) (Result, error) {
|
|
r.calls = append(r.calls, append([]string(nil), args...))
|
|
return Result{}, nil
|
|
}
|
|
|
|
func writeExecutable(t *testing.T, contents string) string {
|
|
t.Helper()
|
|
path := filepath.Join(t.TempDir(), "fake-docker")
|
|
if err := os.WriteFile(path, []byte(contents), 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path
|
|
}
|
|
|
|
func assertContainerCleanup(t *testing.T, logFile, marker, name string) {
|
|
t.Helper()
|
|
calls, err := os.ReadFile(logFile)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !strings.Contains(string(calls), "container rm -f "+name) {
|
|
t.Fatalf("Docker calls = %q, want bounded container cleanup", calls)
|
|
}
|
|
if _, err := os.Stat(marker); !os.IsNotExist(err) {
|
|
t.Fatalf("one-shot container marker still exists: %v", err)
|
|
}
|
|
}
|
|
|
|
const cleanupAwareDockerScript = `#!/bin/sh
|
|
printf '%s\n' "$*" >> "$THT_RUNNER_TEST_LOG"
|
|
if [ "$1" = "container" ] && [ "$2" = "ls" ]; then
|
|
if [ -f "$THT_RUNNER_TEST_MARKER" ]; then printf '%s\n' container-id; fi
|
|
exit 0
|
|
fi
|
|
if [ "$1" = "container" ] && [ "$2" = "rm" ]; then
|
|
if [ "$THT_RUNNER_TEST_MODE" = "cleanup-fails" ]; then exit 9; fi
|
|
rm -f "$THT_RUNNER_TEST_MARKER"
|
|
exit 0
|
|
fi
|
|
if [ "$THT_RUNNER_TEST_MODE" = "flood" ]; then
|
|
while :; do printf '0123456789abcdef'; printf 'fedcba9876543210' >&2; done
|
|
fi
|
|
trap '' TERM INT
|
|
while :; do sleep 1; done
|
|
`
|