wastebin-mcp-go/cli_test.go
opencode-agent[bot] 4e0d7474f1
fix: sandbox translation now MCP-only; CLI rejects sandbox envs (#244)
* Sandbox translation now MCP-only; CLI rejects sandbox envs.

Co-authored-by: xlionjuan <[email protected]>

* docs: clarify CLI env var contract in INSTALL.md

CLI mode reads the same supported env vars as MCP mode, except the
sandbox path translation variables, which are rejected. Aligns the
CLI mode section with the sandbox translation note on the same page.

---------

Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>
Co-authored-by: xlionjuan <[email protected]>
2026-08-04 03:03:46 +08:00

488 lines
14 KiB
Go

package main
import (
"bytes"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func TestPrintCLIHelp(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
printCLIHelp(&buf)
output := buf.String()
if !strings.Contains(output, "wastebin-mcp-go") {
t.Error("expected help to contain project name")
}
if !strings.Contains(output, "USAGE:") {
t.Error("expected help to contain USAGE section")
}
if !strings.Contains(output, "--content") {
t.Error("expected help to mention --content flag")
}
if !strings.Contains(output, "--file-path") {
t.Error("expected help to mention --file-path flag")
}
if !strings.Contains(output, "--burn-after-reading") {
t.Error("expected help to mention --burn-after-reading flag")
}
if !strings.Contains(output, "EXIT CODES:") {
t.Error("expected help to contain EXIT CODES section")
}
}
func TestBuildCreatePasteArgs(t *testing.T) {
t.Parallel()
tests := []struct {
name string
flags CLIFlags
wantContent *string
wantFilePath *string
wantExtension *string
wantExpires *string
wantTitle *string
wantBurnAfterReading *bool
wantPassword *string
wantTranslateSandboxPath *bool
}{
{
name: "content only",
flags: CLIFlags{Content: "hello world"},
wantContent: new("hello world"),
},
{
name: "file_path only",
flags: CLIFlags{FilePath: "/tmp/doc.md"},
wantFilePath: new("/tmp/doc.md"),
},
{
name: "content and file_path both empty (nil output)",
flags: CLIFlags{},
// All fields should remain nil
},
{
name: "extension override",
flags: CLIFlags{Content: "code", Extension: "go"},
wantContent: new("code"),
wantExtension: new("go"),
},
{
name: "expires",
flags: CLIFlags{Content: "ephemeral", Expires: "1h"},
wantContent: new("ephemeral"),
wantExpires: new("1h"),
},
{
name: "title",
flags: CLIFlags{Content: "my paste", Title: "My Paste Title"},
wantContent: new("my paste"),
wantTitle: new("My Paste Title"),
},
{
name: "burn_after_reading",
flags: CLIFlags{Content: "secret", BurnAfterReading: true},
wantContent: new("secret"),
wantBurnAfterReading: new(true),
},
{
name: "burn_after_reading false (default) — pointer stays nil",
flags: CLIFlags{Content: "normal"},
wantContent: new("normal"),
// BurnAfterReading is false in flags, so pointer should be nil
},
{
name: "password",
flags: CLIFlags{Content: "encrypted", Password: "hunter2", PasswordSet: true},
wantContent: new("encrypted"),
wantPassword: new("hunter2"),
},
{
name: "explicitly empty password preserved as pointer",
flags: CLIFlags{Content: "secret", Password: "", PasswordSet: true},
wantContent: new("secret"),
wantPassword: new(""),
},
{
name: "password not set remains nil",
flags: CLIFlags{Content: "unprotected"},
wantContent: new("unprotected"),
wantPassword: nil,
},
{
name: "translate_sandbox_path — no field in CLIFlags, always nil",
flags: CLIFlags{Content: "paste"},
wantContent: new("paste"),
// TranslateSandboxPath is not set by buildCreatePasteArgs
},
{
name: "all fields set",
flags: CLIFlags{
Content: "full paste",
FilePath: "/path/to/file",
Extension: "py",
Expires: "7d",
Title: "Full Test",
BurnAfterReading: true,
Password: "secret123",
PasswordSet: true,
},
wantContent: new("full paste"),
wantFilePath: new("/path/to/file"),
wantExtension: new("py"),
wantExpires: new("7d"),
wantTitle: new("Full Test"),
wantBurnAfterReading: new(true),
wantPassword: new("secret123"),
// TranslateSandboxPath has no corresponding CLIFlags field
},
{
name: "various combinations — content + extension + expires",
flags: CLIFlags{
Content: "combo",
Extension: "md",
Expires: "30M",
},
wantContent: new("combo"),
wantExtension: new("md"),
wantExpires: new("30M"),
},
{
name: "various combinations — file_path + title + password",
flags: CLIFlags{
FilePath: "/data/report.txt",
Title: "Report",
Password: "1234",
PasswordSet: true,
},
wantFilePath: new("/data/report.txt"),
wantTitle: new("Report"),
wantPassword: new("1234"),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
args := buildCreatePasteArgs(&tt.flags)
// Compare each field
assertStringPtr(t, "Content", args.Content, tt.wantContent)
assertStringPtr(t, "FilePath", args.FilePath, tt.wantFilePath)
assertStringPtr(t, "Extension", args.Extension, tt.wantExtension)
assertStringPtr(t, "Expires", args.Expires, tt.wantExpires)
assertStringPtr(t, "Title", args.Title, tt.wantTitle)
assertStringPtr(t, "Password", args.Password, tt.wantPassword)
assertBoolPtr(t, "BurnAfterReading", args.BurnAfterReading, tt.wantBurnAfterReading)
assertBoolPtr(t, "TranslateSandboxPath", args.TranslateSandboxPath, tt.wantTranslateSandboxPath)
})
}
}
// assertStringPtr compares two *string values for equality.
func assertStringPtr(t *testing.T, name string, got, want *string) {
t.Helper()
switch {
case got == nil && want == nil:
// Both nil — OK
case got == nil:
t.Errorf("%s: got nil, want %v", name, *want)
case want == nil:
t.Errorf("%s: got %v, want nil", name, *got)
case *got != *want:
t.Errorf("%s: got %q, want %q", name, *got, *want)
}
}
// assertBoolPtr compares two *bool values for equality.
func assertBoolPtr(t *testing.T, name string, got, want *bool) {
t.Helper()
switch {
case got == nil && want == nil:
// Both nil — OK
case got == nil:
t.Errorf("%s: got nil, want %v", name, *want)
case want == nil:
t.Errorf("%s: got %v, want nil", name, *got)
case *got != *want:
t.Errorf("%s: got %t, want %t", name, *got, *want)
}
}
func TestBuildCreatePasteArgsWithParseCreateFlagsContent(t *testing.T) {
t.Parallel()
// Integration-style: verify that parseCreateFlags -> buildCreatePasteArgs
// produces the expected CreatePasteArgs for a full flags input.
flags, err := parseCreateFlags([]string{
"--content", "hello",
"--extension", "md",
"--expires", "3600",
"--title", "test paste",
"--burn-after-reading",
"--password", "secret",
})
if err != nil {
t.Fatalf("parseCreateFlags failed: %v", err)
}
args := buildCreatePasteArgs(flags)
assertStringPtr(t, "Content", args.Content, new("hello"))
assertStringPtr(t, "Extension", args.Extension, new("md"))
assertStringPtr(t, "Expires", args.Expires, new("3600"))
assertStringPtr(t, "Title", args.Title, new("test paste"))
assertStringPtr(t, "Password", args.Password, new("secret"))
assertBoolPtr(t, "BurnAfterReading", args.BurnAfterReading, new(true))
// Fields not passed should remain nil
assertStringPtr(t, "FilePath", args.FilePath, nil)
assertBoolPtr(t, "TranslateSandboxPath", args.TranslateSandboxPath, nil)
}
func TestBuildCreatePasteArgs_EmptyPasswordPreserved(t *testing.T) {
t.Parallel()
flags, err := parseCreateFlags([]string{
"--content", "secret",
"--password", "",
})
if err != nil {
t.Fatalf("parseCreateFlags failed: %v", err)
}
if !flags.PasswordSet {
t.Fatal("expected PasswordSet=true for explicitly provided --password")
}
args := buildCreatePasteArgs(flags)
// Verify the empty password is preserved as a pointer (not nil), so the
// handler's buildRequest can reject it with errPasswordEmpty.
argPass := args.Password
if argPass == nil {
t.Fatal("expected non-nil Password pointer for explicitly empty --password")
}
if *argPass != "" {
t.Errorf("expected empty password string, got %q", *argPass)
}
}
func TestBuildCreatePasteArgsWithParseCreateFlagsFilePath(t *testing.T) {
t.Parallel()
flags, err := parseCreateFlags([]string{
"--file-path", "/tmp/doc.md",
})
if err != nil {
t.Fatalf("parseCreateFlags failed: %v", err)
}
args := buildCreatePasteArgs(flags)
assertStringPtr(t, "FilePath", args.FilePath, new("/tmp/doc.md"))
assertStringPtr(t, "Content", args.Content, nil)
assertStringPtr(t, "Extension", args.Extension, nil)
assertStringPtr(t, "Expires", args.Expires, nil)
assertStringPtr(t, "Title", args.Title, nil)
assertStringPtr(t, "Password", args.Password, nil)
assertBoolPtr(t, "BurnAfterReading", args.BurnAfterReading, nil)
assertBoolPtr(t, "TranslateSandboxPath", args.TranslateSandboxPath, nil)
}
func TestCheckNoSandboxTranslationEnv(t *testing.T) {
// Cannot use t.Parallel() due to environment variable manipulation.
t.Setenv("WASTEBIN_MCP_SANDBOX_MOUNTS", "")
t.Setenv("WASTEBIN_MCP_SANDBOX_TRANSPARENT", "")
err := checkNoSandboxTranslationEnv()
if err != nil {
t.Fatalf("expected nil with no sandbox translation env vars set, got: %v", err)
}
}
func TestCheckNoSandboxTranslationEnv_SandboxMountsSet(t *testing.T) {
// Cannot use t.Parallel() due to environment variable manipulation.
t.Setenv("WASTEBIN_MCP_SANDBOX_MOUNTS", "/host:/workspace")
t.Setenv("WASTEBIN_MCP_SANDBOX_TRANSPARENT", "")
err := checkNoSandboxTranslationEnv()
if err == nil {
t.Fatal("expected error when WASTEBIN_MCP_SANDBOX_MOUNTS is set")
}
if !errors.Is(err, errSandboxTranslationCLIUnsupported) {
t.Errorf("expected errSandboxTranslationCLIUnsupported, got: %v", err)
}
if !strings.Contains(err.Error(), "WASTEBIN_MCP_SANDBOX_MOUNTS") {
t.Errorf("expected error to name WASTEBIN_MCP_SANDBOX_MOUNTS, got: %v", err)
}
}
func TestCheckNoSandboxTranslationEnv_SandboxTransparentSet(t *testing.T) {
// Cannot use t.Parallel() due to environment variable manipulation.
t.Setenv("WASTEBIN_MCP_SANDBOX_MOUNTS", "")
t.Setenv("WASTEBIN_MCP_SANDBOX_TRANSPARENT", "true")
err := checkNoSandboxTranslationEnv()
if err == nil {
t.Fatal("expected error when WASTEBIN_MCP_SANDBOX_TRANSPARENT is set")
}
if !errors.Is(err, errSandboxTranslationCLIUnsupported) {
t.Errorf("expected errSandboxTranslationCLIUnsupported, got: %v", err)
}
if !strings.Contains(err.Error(), "WASTEBIN_MCP_SANDBOX_TRANSPARENT") {
t.Errorf("expected error to name WASTEBIN_MCP_SANDBOX_TRANSPARENT, got: %v", err)
}
}
func TestRunCLIMode_RejectsSandboxTranslationEnv(t *testing.T) {
// Cannot use t.Parallel() due to environment variable manipulation.
// The sandbox env check runs before ConfigFromEnv, so no server URL is
// required — the sandbox error must surface, not a configuration error.
t.Setenv("WASTEBIN_MCP_SANDBOX_MOUNTS", "")
t.Setenv("WASTEBIN_MCP_SANDBOX_TRANSPARENT", "true")
err := runCLIMode(&CLIFlags{Content: "test"})
if err == nil {
t.Fatal("expected error when a sandbox translation env var is set in CLI mode")
}
if !errors.Is(err, errSandboxTranslationCLIUnsupported) {
t.Errorf("expected errSandboxTranslationCLIUnsupported, got: %v", err)
}
}
func TestRunCLIMode_CreatePasteError(t *testing.T) {
// Cannot use t.Parallel() due to environment variable manipulation.
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.WriteHeader(http.StatusInternalServerError)
}))
defer ts.Close()
t.Setenv("WASTEBIN_SERVER_URL", ts.URL)
err := runCLIMode(&CLIFlags{Content: "test"})
if err == nil {
t.Fatal("expected error")
}
if !strings.Contains(err.Error(), "create paste failed") {
t.Errorf("expected 'create paste failed', got: %v", err)
}
}
func TestRunCLIMode_ClientError(t *testing.T) {
// URL with unsupported scheme passes ConfigFromEnv but fails NewWastebinClient.
t.Setenv("WASTEBIN_SERVER_URL", "ftp://server")
err := runCLIMode(&CLIFlags{Content: "test"})
if err == nil {
t.Fatal("expected error")
}
if !strings.Contains(err.Error(), "failed to create client") {
t.Errorf("expected 'failed to create client', got: %v", err)
}
}
func TestRunCLIMode_ConfigError(t *testing.T) {
// Don't set WASTEBIN_SERVER_URL — ConfigFromEnv should fail.
// Ensure any previously set env var is cleared.
t.Setenv("WASTEBIN_SERVER_URL", "")
err := runCLIMode(&CLIFlags{Content: "test"})
if err == nil {
t.Fatal("expected error for missing server URL")
}
if !strings.Contains(err.Error(), "configuration error") {
t.Errorf("expected configuration error, got: %v", err)
}
}
func TestRunCLIMode_DebugPath(t *testing.T) {
// Cannot use t.Parallel() due to environment variable manipulation.
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
t.Errorf("expected POST, got %s", r.Method)
}
if r.URL.Path != "/" {
t.Errorf("expected /, got %s", r.URL.Path)
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_ = json.NewEncoder(w).Encode(map[string]string{"path": "/ABCDEFG"}) //nolint:errcheck // Test helper OK
}))
defer ts.Close()
t.Setenv("WASTEBIN_SERVER_URL", ts.URL)
err := runCLIMode(&CLIFlags{Content: "hello", Debug: true})
if err != nil {
t.Fatalf("runCLIMode failed: %v", err)
}
}
func TestRunCLIModeWithTestServer(t *testing.T) {
// Cannot use t.Parallel() due to environment variable manipulation.
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
t.Errorf("expected POST, got %s", r.Method)
}
if r.URL.Path != "/" {
t.Errorf("expected /, got %s", r.URL.Path)
}
if ct := r.Header.Get("Content-Type"); ct != "application/json" {
t.Errorf("expected Content-Type application/json, got %s", ct)
}
var req map[string]any
decodeErr := json.NewDecoder(r.Body).Decode(&req)
if decodeErr != nil {
t.Errorf("failed to decode request: %v", decodeErr)
}
if req["text"] != "hello" {
t.Errorf("expected text 'hello', got %v", req["text"])
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_ = json.NewEncoder(w).Encode(map[string]string{"path": "/ABCDEFG"}) //nolint:errcheck // Test helper OK
}))
defer ts.Close()
t.Setenv("WASTEBIN_SERVER_URL", ts.URL)
t.Setenv("DEBUG", "false")
err := runCLIMode(&CLIFlags{Content: "hello"})
if err != nil {
t.Fatalf("runCLIMode failed: %v", err)
}
}