WeKnora/internal/agent/tools/shell_exec_test.go

175 lines
5.3 KiB
Go

package tools
import (
"context"
"encoding/json"
"errors"
"strings"
"testing"
"time"
"github.com/Tencent/WeKnora/internal/sandbox"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
type fakeShellExecutor struct {
result *sandbox.ExecuteResult
err error
timeout time.Duration
}
func (f *fakeShellExecutor) ExecShellCommand(
_ context.Context,
_ string,
_ string,
_ string,
timeout time.Duration,
_ map[string]string,
) (*sandbox.ExecuteResult, error) {
f.timeout = timeout
if f.err != nil {
return nil, f.err
}
if f.result == nil {
return &sandbox.ExecuteResult{ExitCode: 0}, nil
}
return f.result, nil
}
func shellExecTestContext() context.Context {
return WithToolExecContext(context.Background(), &ToolExecContext{SessionID: "session-1"})
}
func TestShellExecRejectsWorkDirOutsideWorkspace(t *testing.T) {
executor := &fakeShellExecutor{}
tool := NewShellExecTool(executor)
result, err := tool.Execute(shellExecTestContext(), json.RawMessage(
`{"command":"pwd","work_dir":"/etc"}`,
))
require.NoError(t, err)
require.False(t, result.Success)
require.Contains(t, result.Error, "outside the sandbox workspace")
assert.Equal(t, time.Duration(0), executor.timeout)
}
func TestShellExecTimeoutHonorsAndCapsRequestedValue(t *testing.T) {
executor := &fakeShellExecutor{}
tool := NewShellExecTool(executor)
result, err := tool.Execute(shellExecTestContext(), json.RawMessage(
`{"command":"sleep 1","timeout_sec":999}`,
))
require.NoError(t, err)
require.True(t, result.Success)
assert.Equal(t, shellExecMaxTimeout, executor.timeout)
}
func TestShellExecConfigurableOutputAndRegistryOverride(t *testing.T) {
content := strings.Repeat("x", 24*1024)
executor := &fakeShellExecutor{result: &sandbox.ExecuteResult{
Stdout: content,
ExitCode: 0,
}}
registry := NewToolRegistry()
registry.RegisterTool(NewShellExecTool(executor))
result, err := registry.ExecuteTool(shellExecTestContext(), ToolShellExec, json.RawMessage(
`{"command":"cat large.txt","max_output_bytes":32768}`,
))
require.NoError(t, err)
require.True(t, result.Success)
assert.Contains(t, result.Output, content)
assert.NotContains(t, result.Output, "output truncated")
assert.Equal(t, 32768, result.Data["max_output_bytes"])
}
func TestShellExecOutputLimitIsHardCapped(t *testing.T) {
tool := NewShellExecTool(&fakeShellExecutor{})
limit := tool.OutputLimitChars(json.RawMessage(`{"max_output_bytes":999999}`))
assert.Equal(t, maxShellExecVisibleBytes, limit)
}
func TestShellExecSuppressesBinaryStreams(t *testing.T) {
binary := "prefix\x00\x01payload"
executor := &fakeShellExecutor{result: &sandbox.ExecuteResult{
Stdout: binary,
Stderr: "text error",
ExitCode: 0,
}}
tool := NewShellExecTool(executor)
result, err := tool.Execute(shellExecTestContext(), json.RawMessage(`{"command":"cat image.bin"}`))
require.NoError(t, err)
require.True(t, result.Success)
assert.NotContains(t, result.Output, binary)
assert.Contains(t, result.Output, "Binary Output Suppressed")
assert.Equal(t, "", result.Data["stdout"])
assert.Equal(t, true, result.Data["stdout_binary"])
assert.Equal(t, len(binary), result.Data["stdout_bytes"])
assert.Equal(t, "text error", result.Data["stderr"])
}
func TestShellExecDescriptionSupportsGeneralExploration(t *testing.T) {
description := NewShellExecTool(&fakeShellExecutor{}).Description()
for _, command := range []string{"find", "file", "sed", "head", "tail", "cat", "grep", "awk"} {
assert.Contains(t, description, command)
}
assert.Contains(t, description, "Use freely to explore")
assert.Contains(t, description, "Binary output is never returned")
}
func TestShellExecBoundsStdoutStderrErrorAndTotal(t *testing.T) {
executor := &fakeShellExecutor{result: &sandbox.ExecuteResult{
Stdout: strings.Repeat("o", 100*1024),
Stderr: strings.Repeat("s", 40*1024) + "TAIL_ERROR",
Error: strings.Repeat("e", 8*1024),
}}
result, err := NewShellExecTool(executor).Execute(
shellExecTestContext(),
json.RawMessage(`{"command":"noisy","max_output_bytes":999999,"max_stderr_bytes":999999}`),
)
require.NoError(t, err)
require.True(t, result.Success)
assert.LessOrEqual(t, len(result.Output), maxShellExecVisibleBytes)
assert.LessOrEqual(t, result.Data["stdout_returned_bytes"].(int), maxShellExecOutputBytes)
assert.LessOrEqual(t, result.Data["stderr_returned_bytes"].(int), maxShellExecStderrBytes)
assert.LessOrEqual(t, result.Data["error_returned_bytes"].(int), maxShellExecErrorBytes)
assert.Equal(t, true, result.Data["stdout_truncated"])
assert.Equal(t, true, result.Data["stderr_truncated"])
assert.Equal(t, true, result.Data["error_truncated"])
assert.Contains(t, result.Data["stderr"], "TAIL_ERROR")
}
func TestShellExecBoundsExecutorErrors(t *testing.T) {
executor := &fakeShellExecutor{err: errors.New(strings.Repeat("network failure ", 1024))}
result, err := NewShellExecTool(executor).Execute(
shellExecTestContext(),
json.RawMessage(`{"command":"echo hi"}`),
)
require.NoError(t, err)
require.False(t, result.Success)
assert.LessOrEqual(t, len(result.Error), maxShellExecErrorBytes)
assert.Contains(t, result.Error, "truncated")
}
func TestTruncateShellStreamIncludesMarkerWithinLimit(t *testing.T) {
output, truncated := truncateShellStream(strings.Repeat("x", 10000), 100)
require.True(t, truncated)
assert.LessOrEqual(t, len(output), 100)
assert.Contains(t, output, "truncated")
}