searxng-mcp-go/main_test.go
xlion-bot-renovate[bot] 6e4c553a9e
chore(deps): update dependency go to v1.27.1 (#588)
* chore(deps): update dependency go to v1.27.1

* Fixed all lints; just verify passes.

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

* Fixed `.golangci.yml` paths→path; `just verify` passes.

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

* Parallelized golden & error-path tests; verify passes.

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

* Verify passes; HTTPClient/Logger nil set; exhaustruct covers Config.

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

---------

Co-authored-by: xlion-bot-renovate[bot] <218815870+xlion-bot-renovate[bot]@users.noreply.github.com>
Co-authored-by: opencode-agent[bot] <opencode-agent[bot]@users.noreply.github.com>
Co-authored-by: xlionjuan <[email protected]>
2026-09-06 23:14:09 +08:00

1982 lines
52 KiB
Go

package main
import (
"bytes"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
"net/url"
"os"
"reflect"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"go.uber.org/goleak"
"searxng-mcp-go/internal/searxng"
)
func TestMain(m *testing.M) {
goleak.VerifyTestMain(m)
}
func TestPrintParseError(t *testing.T) {
t.Parallel()
tests := []struct {
name string
args []string
}{
{name: "unknown flag", args: []string{"--unknown"}},
{name: "missing query value", args: []string{"--query"}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
_, _, _, err := parseArgs(tt.args)
if err == nil {
t.Fatal("expected error, got nil")
}
var buf bytes.Buffer
printParseError(err, &buf)
output := buf.String()
if !strings.Contains(output, "ERROR:") {
t.Error("output should contain error message")
}
if !strings.Contains(output, "SearXNG MCP Server") {
t.Error("output should contain help text")
}
})
}
}
func TestMainRoutesParseErrorToStderr(t *testing.T) {
t.Parallel()
// Capture os.Stderr via pipe.
stderrR, stderrW, err := os.Pipe()
if err != nil {
t.Fatalf("failed to create stderr pipe: %v", err)
}
oldStderr := os.Stderr
os.Stderr = stderrW
readCh := make(chan string)
go func() {
var buf bytes.Buffer
_, readErr := buf.ReadFrom(stderrR)
if readErr != nil {
t.Errorf("failed to read from stderr pipe: %v", readErr)
}
readCh <- buf.String()
}()
// Call printParseError with os.Stderr — same routing as main().
//nolint:dogsled // parseArgs returns 4 values; only error is needed
_, _, _, parseErr := parseArgs([]string{"--unknown"})
if parseErr == nil {
t.Fatal("expected parse error, got nil")
}
// Capture stdout to verify nothing leaks there.
stdout := captureStdout(t, func() {
printParseError(parseErr, os.Stderr)
})
err = stderrW.Close()
if err != nil {
t.Errorf("failed to close stderr pipe: %v", err)
}
os.Stderr = oldStderr
stderrOutput := <-readCh
if stdout != "" {
t.Error("printParseError should not write to stdout")
}
if !strings.Contains(stderrOutput, "ERROR:") {
t.Error("stderr should contain error message")
}
if !strings.Contains(stderrOutput, "SearXNG MCP Server") {
t.Error("stderr should contain help text")
}
}
func TestPrintCLIHelp(t *testing.T) {
t.Parallel()
var buf bytes.Buffer
printCLIHelp(&buf)
output := buf.String()
expectedContent := []string{
"SearXNG MCP Server - CLI Mode",
"USAGE:",
"OPTIONS:",
"--query",
"--json",
"--searxng-url",
"--language",
"--safesearch",
"--time_range",
"--categories",
"--engines",
"--pageno",
"--limit",
"--debug",
"--allow-get-fallback",
"--help",
"--version",
"ARGUMENTS:",
"QUERY",
"OUTPUT:",
"EXAMPLES:",
"MCP MODE:",
"EXIT CODES:",
"https://github.com/xlionjuan/searxng-mcp-go",
}
for _, expected := range expectedContent {
if !strings.Contains(output, expected) {
t.Errorf("printCLIHelp() output missing expected content %q", expected)
}
}
}
func TestParseArgs_InvalidFlags(t *testing.T) {
t.Parallel()
tests := []struct {
name string
args []string
errSubstr string
}{
{name: "unknown flag", args: []string{"--unknown"}, errSubstr: "flag provided but not defined"},
{name: "missing query value", args: []string{"--query"}, errSubstr: "flag needs an argument"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
_, _, _, err := parseArgs(tt.args)
if err == nil {
t.Fatal("expected error, got nil")
}
if !strings.Contains(err.Error(), tt.errSubstr) {
t.Errorf("error %q does not contain %q", err.Error(), tt.errSubstr)
}
})
}
}
//nolint:gocognit,gocyclo,cyclop,maintidx // comprehensive table-driven test covering all CLI flag parsing scenarios
func TestParseArgs(t *testing.T) {
t.Parallel()
tests := []struct {
name string
args []string
wantCLIMode bool
wantFlags CLIFlags
wantPositional []string
wantLimit *int
wantErr bool
errSubstr string
}{
{
name: "empty args",
args: []string{},
wantCLIMode: false,
wantFlags: CLIFlags{Language: "", SafeSearch: 0, Pageno: nil},
wantErr: false,
},
{
name: "--limit explicitly set",
args: []string{"--limit", "7", "test query"},
wantCLIMode: true,
wantFlags: CLIFlags{Language: "", SafeSearch: 0, Pageno: nil},
wantPositional: []string{"test query"},
wantLimit: new(7),
wantErr: false,
},
{
name: "positional query only",
args: []string{"test query"},
wantCLIMode: true,
wantFlags: CLIFlags{Language: "", SafeSearch: 0, Pageno: nil},
wantPositional: []string{"test query"},
wantLimit: new(searxng.DefaultResultLimit),
wantErr: false,
},
{
name: "--help flag",
args: []string{"--help"},
wantCLIMode: true,
wantFlags: CLIFlags{Help: true, Language: "", SafeSearch: 0, Pageno: nil},
wantErr: false,
},
{
name: "--version flag",
args: []string{"--version"},
wantCLIMode: true,
wantFlags: CLIFlags{Version: true, Language: "", SafeSearch: 0, Pageno: nil},
wantErr: false,
},
{
name: "--query flag",
args: []string{"--query", "my search"},
wantCLIMode: true,
wantFlags: CLIFlags{Query: "my search", Language: "", SafeSearch: 0, Pageno: nil},
wantErr: false,
},
{
name: "--json flag",
args: []string{"--json"},
wantCLIMode: true,
wantFlags: CLIFlags{JSON: true, Language: "", SafeSearch: 0, Pageno: nil},
wantErr: false,
},
{
name: "searxng-url flag without query",
args: []string{"--searxng-url", "https://example.com"},
wantCLIMode: true,
wantFlags: CLIFlags{SearXNGURL: "https://example.com", Language: "", SafeSearch: 0, Pageno: nil},
wantErr: false,
},
{
name: "language and safesearch flags without query",
args: []string{"--language", "ja", "--safesearch", "2"},
wantCLIMode: true,
wantFlags: CLIFlags{Language: "ja", SafeSearch: 2, Pageno: nil},
wantErr: false,
},
{
name: "multiple flags with positional",
args: []string{"--language", "fr", "--safesearch", "1", "positional query"},
wantCLIMode: true,
wantFlags: CLIFlags{Language: "fr", SafeSearch: 1, Pageno: nil},
wantPositional: []string{"positional query"},
wantErr: false,
},
{
name: "flags after positional",
args: []string{"positional", "--json"},
wantCLIMode: true,
wantFlags: CLIFlags{JSON: true, Language: "", SafeSearch: 0, Pageno: nil},
wantPositional: []string{"positional"},
wantErr: false,
},
{
name: "double dash separator treats subsequent args as positional",
args: []string{"--", "--help"},
wantCLIMode: true,
wantFlags: CLIFlags{Language: "", SafeSearch: 0, Pageno: nil},
wantPositional: []string{"--help"},
wantErr: false,
},
{
name: "double dash with leading dash query",
args: []string{"--", "-leading-dash-query"},
wantCLIMode: true,
wantFlags: CLIFlags{Language: "", SafeSearch: 0, Pageno: nil},
wantPositional: []string{"-leading-dash-query"},
wantErr: false,
},
{
name: "server config flags without query",
args: []string{"--searxng-url", "https://example.com", "--language", "zh-tw", "--safesearch", "2"},
wantCLIMode: true,
wantFlags: CLIFlags{SearXNGURL: "https://example.com", Language: "zh-tw", SafeSearch: 2, Pageno: nil},
wantErr: false,
},
{
name: "--debug flag with query",
args: []string{"--debug", "test query"},
wantCLIMode: true,
wantFlags: CLIFlags{Debug: true, Language: "", SafeSearch: 0, Pageno: nil},
wantPositional: []string{"test query"},
wantErr: false,
},
{
name: "--pageno explicitly set",
args: []string{"--pageno", "3", "test query"},
wantCLIMode: true,
wantFlags: CLIFlags{Language: "", SafeSearch: 0, Pageno: new(3)},
wantPositional: []string{"test query"},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
isCLIMode, flags, positionalArgs, err := parseArgs(tt.args)
if tt.wantErr {
if err == nil {
t.Fatal("expected error, got nil")
}
if tt.errSubstr != "" && !strings.Contains(err.Error(), tt.errSubstr) {
t.Errorf("error %q does not contain %q", err.Error(), tt.errSubstr)
}
return
}
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if isCLIMode != tt.wantCLIMode {
t.Errorf("isCLIMode = %v, want %v", isCLIMode, tt.wantCLIMode)
}
if flags.Language != tt.wantFlags.Language {
t.Errorf("flags.Language = %q, want %q", flags.Language, tt.wantFlags.Language)
}
if flags.SafeSearch != tt.wantFlags.SafeSearch {
t.Errorf("flags.SafeSearch = %d, want %d", flags.SafeSearch, tt.wantFlags.SafeSearch)
}
if (flags.Pageno == nil) != (tt.wantFlags.Pageno == nil) ||
(flags.Pageno != nil && tt.wantFlags.Pageno != nil && *flags.Pageno != *tt.wantFlags.Pageno) {
t.Errorf("flags.Pageno = %v, want %v", flags.Pageno, tt.wantFlags.Pageno)
}
if tt.wantLimit != nil {
if flags.Limit == nil {
t.Fatal("flags.Limit = nil, want limit pointer")
}
if *flags.Limit != *tt.wantLimit {
t.Errorf("flags.Limit = %d, want %d", *flags.Limit, *tt.wantLimit)
}
}
if flags.Query != tt.wantFlags.Query {
t.Errorf("flags.Query = %q, want %q", flags.Query, tt.wantFlags.Query)
}
if flags.Help != tt.wantFlags.Help {
t.Errorf("flags.Help = %v, want %v", flags.Help, tt.wantFlags.Help)
}
if flags.Version != tt.wantFlags.Version {
t.Errorf("flags.Version = %v, want %v", flags.Version, tt.wantFlags.Version)
}
if flags.JSON != tt.wantFlags.JSON {
t.Errorf("flags.JSON = %v, want %v", flags.JSON, tt.wantFlags.JSON)
}
if flags.SearXNGURL != tt.wantFlags.SearXNGURL {
t.Errorf("flags.SearXNGURL = %q, want %q", flags.SearXNGURL, tt.wantFlags.SearXNGURL)
}
if flags.TimeRange != tt.wantFlags.TimeRange {
t.Errorf("flags.TimeRange = %q, want %q", flags.TimeRange, tt.wantFlags.TimeRange)
}
if flags.Categories != tt.wantFlags.Categories {
t.Errorf("flags.Categories = %q, want %q", flags.Categories, tt.wantFlags.Categories)
}
if flags.Engines != tt.wantFlags.Engines {
t.Errorf("flags.Engines = %q, want %q", flags.Engines, tt.wantFlags.Engines)
}
if flags.Debug != tt.wantFlags.Debug {
t.Errorf("flags.Debug = %v, want %v", flags.Debug, tt.wantFlags.Debug)
}
if len(positionalArgs) != len(tt.wantPositional) {
t.Errorf("positionalArgs = %v, want %v", positionalArgs, tt.wantPositional)
}
for i, pos := range positionalArgs {
if i >= len(tt.wantPositional) {
break
}
if pos != tt.wantPositional[i] {
t.Errorf("positionalArgs[%d] = %q, want %q", i, pos, tt.wantPositional[i])
}
}
})
}
}
func TestIsValidMCPFirstMessage(t *testing.T) {
t.Parallel()
tests := []struct {
name string
line string
want bool
}{
{
name: "valid initialize",
line: `{"jsonrpc":"2.0","method":"initialize","id":1}` + "\n",
want: true,
},
{
name: "valid server discover",
line: `{"jsonrpc":"2.0","method":"server/discover","id":1}` + "\n",
want: true,
},
{
name: "server discover with params",
line: `{"jsonrpc":"2.0","method":"server/discover","params":` +
`{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28"}}}` + "\n",
want: true,
},
{
name: "valid stateless request",
line: `{"jsonrpc":"2.0","method":"tools/list","id":1,"params":` +
`{"_meta":{"io.modelcontextprotocol/clientCapabilities":{},` +
`"io.modelcontextprotocol/protocolVersion":"2026-07-28"}}}` + "\n",
want: true,
},
{
name: "wrong method without stateless metadata",
line: `{"jsonrpc":"2.0","method":"tools/list"}` + "\n",
want: false,
},
{
name: "valid notification with stateless metadata",
line: `{"jsonrpc":"2.0","method":"notifications/initialized","params":` +
`{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28"}}}` + "\n",
want: true,
},
{
name: "stateless metadata missing protocol version",
line: `{"jsonrpc":"2.0","method":"tools/list","params":` +
`{"_meta":{"io.modelcontextprotocol/clientCapabilities":{}}}}` + "\n",
want: false,
},
{
name: "stateless request with non-object params",
line: `{"jsonrpc":"2.0","method":"tools/list","params":[1,2,3]}` + "\n",
want: false,
},
{
name: "stateless request with non-object metadata",
line: `{"jsonrpc":"2.0","method":"tools/list","params":` +
`{"_meta":"not an object"}}` + "\n",
want: false,
},
{
name: "metadata in wrong location",
line: `{"jsonrpc":"2.0","method":"tools/list","_meta":` +
`{"io.modelcontextprotocol/protocolVersion":"2026-07-28"}}` + "\n",
want: false,
},
{
name: "wrong method",
line: `{"jsonrpc":"2.0","method":"ping"}` + "\n",
want: false,
},
{
name: "wrong JSON-RPC version initialize",
line: `{"jsonrpc":"1.0","method":"initialize"}` + "\n",
want: false,
},
{
name: "wrong JSON-RPC version server discover",
line: `{"jsonrpc":"1.0","method":"server/discover"}` + "\n",
want: false,
},
{
name: "wrong JSON-RPC version stateless request",
line: `{"jsonrpc":"1.0","method":"tools/list","params":` +
`{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28"}}}` + "\n",
want: false,
},
{name: "empty input", line: "", want: false},
{name: "not json", line: `not json at all`, want: false},
{name: "whitespace only", line: " \t\n ", want: false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
if got := isValidMCPFirstMessage([]byte(tt.line)); got != tt.want {
t.Fatalf("isValidMCPFirstMessage() = %v, want %v", got, tt.want)
}
})
}
}
func TestPrintParseErrorNoColor(t *testing.T) {
// Not t.Parallel(): modifies global env.
t.Setenv("NO_COLOR", "1")
t.Setenv("TERM", "") // clear TERM so NO_COLOR is tested independently
//nolint:dogsled // parseArgs returns 4 values; only error is needed
_, _, _, err := parseArgs([]string{"--unknown"})
if err == nil {
t.Fatal("expected error, got nil")
}
var buf bytes.Buffer
printParseError(err, &buf)
output := buf.String()
if !strings.Contains(output, "ERROR:") {
t.Error("output should contain error message")
}
if strings.Contains(output, "\033[31m") {
t.Error("output should not contain ANSI escape codes when NO_COLOR is set")
}
}
func TestPrintParseErrorTermDumb(t *testing.T) {
// Not t.Parallel(): modifies global env.
t.Setenv("TERM", "dumb")
//nolint:dogsled // parseArgs returns 4 values; only error is needed
_, _, _, err := parseArgs([]string{"--unknown"})
if err == nil {
t.Fatal("expected error, got nil")
}
var buf bytes.Buffer
printParseError(err, &buf)
output := buf.String()
if !strings.Contains(output, "ERROR:") {
t.Error("output should contain error message")
}
if strings.Contains(output, "\033[31m") {
t.Error("output should not contain ANSI escape codes when TERM=dumb")
}
}
func TestPrepareMCPStdin(t *testing.T) {
t.Parallel()
input := `{"jsonrpc":"2.0","method":"initialize","id":1}` + "\n" +
`{"jsonrpc":"2.0","method":"tools/list","id":2}` + "\n"
stdin, err := prepareMCPStdin(strings.NewReader(input))
if err != nil {
t.Fatalf("prepareMCPStdin() returned error: %v", err)
}
got, err := io.ReadAll(stdin)
if err != nil {
t.Fatalf("failed to read prepared stdin: %v", err)
}
if string(got) != input {
t.Fatalf("prepared stdin mismatch\nwant: %q\ngot: %q", input, string(got))
}
}
func TestPrepareMCPStdinAllowsLargePostInitializeTraffic(t *testing.T) {
t.Parallel()
initialize := `{"jsonrpc":"2.0","method":"initialize","id":1}` + "\n"
laterTraffic := `{"jsonrpc":"2.0","method":"tools/call","id":2,"params":{"payload":"` +
strings.Repeat("a", mcpFirstMessageMaxBytes+1024) + `"}}` + "\n"
input := initialize + laterTraffic
stdin, err := prepareMCPStdin(strings.NewReader(input))
if err != nil {
t.Fatalf("prepareMCPStdin() returned error: %v", err)
}
got, err := io.ReadAll(stdin)
if err != nil {
t.Fatalf("failed to read prepared stdin: %v", err)
}
if string(got) != input {
t.Fatalf("prepared stdin mismatch\nwant length: %d\ngot length: %d", len(input), len(got))
}
}
func TestPrepareMCPStdinRejectsInvalidInput(t *testing.T) {
t.Parallel()
_, err := prepareMCPStdin(strings.NewReader("not initialize\n"))
if err == nil {
t.Fatal("expected error, got nil")
}
if err.Error() != "stdin does not contain a valid MCP first message" {
t.Fatalf("unexpected error: %v", err)
}
}
func TestPrepareMCPStdinRejectsOversizedInitializeLine(t *testing.T) {
t.Parallel()
input := `{"jsonrpc":"2.0","method":"initialize","padding":"` +
strings.Repeat("a", mcpFirstMessageMaxBytes) + `"}` + "\n"
reader := &countingMCPReader{reader: strings.NewReader(input)}
_, err := prepareMCPStdin(reader)
if err == nil {
t.Fatal("expected error, got nil")
}
if err.Error() != "stdin does not contain a valid MCP first message" {
t.Fatalf("unexpected error: %v", err)
}
maxConsumed := mcpFirstMessageMaxBytes + mcpFirstMessageMaxDelimiterBytes
if reader.consumed > maxConsumed {
t.Fatalf("prepareMCPStdin consumed %d bytes, want at most %d", reader.consumed, maxConsumed)
}
}
func TestPrepareMCPStdinAcceptsEOFWithoutNewline(t *testing.T) {
t.Parallel()
input := `{"jsonrpc":"2.0","method":"initialize","id":1}`
stdin, err := prepareMCPStdin(strings.NewReader(input))
if err != nil {
t.Fatalf("prepareMCPStdin() returned error: %v", err)
}
got, err := io.ReadAll(stdin)
if err != nil {
t.Fatalf("failed to read prepared stdin: %v", err)
}
if string(got) != input {
t.Fatalf("prepared stdin mismatch\nwant: %q\ngot: %q", input, string(got))
}
}
type mcpFirstMessageLimitTest struct {
name string
firstMessage string
delimiter string
tail string
wantErr bool
}
func TestPrepareMCPStdinFirstMessageLimit(t *testing.T) {
t.Parallel()
const (
prefix = `{"jsonrpc":"2.0","id":1,"method":"tools/list","params":` +
`{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28"},"padding":"`
suffix = `"}}`
)
paddingLength := mcpFirstMessageMaxBytes - len(prefix) - len(suffix)
if paddingLength < 0 {
t.Fatalf("test prefix exceeds transport limit: %d bytes", len(prefix)+len(suffix))
}
exact := prefix + strings.Repeat("a", paddingLength) + suffix
if len(exact) != mcpFirstMessageMaxBytes {
t.Fatalf("exact first message length = %d, want %d", len(exact), mcpFirstMessageMaxBytes)
}
if !json.Valid([]byte(exact)) {
t.Fatal("exact first message is not valid JSON")
}
over := prefix + strings.Repeat("a", paddingLength+1) + suffix
if len(over) != mcpFirstMessageMaxBytes+1 {
t.Fatalf("over-limit first message length = %d, want %d", len(over), mcpFirstMessageMaxBytes+1)
}
if !json.Valid([]byte(over)) {
t.Fatal("over-limit first message is not valid JSON")
}
tests := []mcpFirstMessageLimitTest{
{
name: "exact limit with LF",
firstMessage: exact,
delimiter: "\n",
tail: "tail",
},
{
name: "exact limit with CRLF",
firstMessage: exact,
delimiter: "\r\n",
tail: "tail",
},
{
name: "exact limit at EOF",
firstMessage: exact,
},
{
name: "over limit with LF",
firstMessage: over,
delimiter: "\n",
wantErr: true,
},
{
name: "over limit with CRLF",
firstMessage: over,
delimiter: "\r\n",
wantErr: true,
},
{
name: "over limit at EOF",
firstMessage: over,
wantErr: true,
},
}
maxConsumed := mcpFirstMessageMaxBytes + mcpFirstMessageMaxDelimiterBytes
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
assertMCPFirstMessageLimit(t, tt, maxConsumed)
})
}
}
func TestPrepareMCPStdinFirstMessageLimitAcceptsCRLFAcrossReads(t *testing.T) {
t.Parallel()
const (
prefix = `{"jsonrpc":"2.0","id":1,"method":"tools/list","params":` +
`{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28"},"padding":"`
suffix = `"}}`
)
paddingLength := mcpFirstMessageMaxBytes - len(prefix) - len(suffix)
exact := prefix + strings.Repeat("a", paddingLength) + suffix
input := exact + "\r\n" + "tail"
reader := &countingMCPReader{reader: io.MultiReader(
strings.NewReader(exact+"\r"),
strings.NewReader("\ntail"),
)}
stdin, err := prepareMCPStdin(reader)
if err != nil {
t.Fatalf("prepareMCPStdin() rejected exact-limit CRLF message across reads: %v", err)
}
maxConsumed := mcpFirstMessageMaxBytes + mcpFirstMessageMaxDelimiterBytes
if reader.consumed > maxConsumed {
t.Fatalf("preflight read consumed %d bytes, want at most %d", reader.consumed, maxConsumed)
}
got, err := io.ReadAll(stdin)
if err != nil {
t.Fatalf("failed to read prepared stdin: %v", err)
}
if string(got) != input {
t.Fatalf("prepared CRLF stdin mismatch\nwant: %q\ngot: %q", input, string(got))
}
}
func assertMCPFirstMessageLimit(t *testing.T, tt mcpFirstMessageLimitTest, maxConsumed int) {
t.Helper()
input := tt.firstMessage + tt.delimiter + tt.tail
reader := &countingMCPReader{reader: strings.NewReader(input)}
stdin, err := prepareMCPStdin(reader)
if reader.consumed > maxConsumed {
t.Fatalf("preflight read consumed %d bytes, want at most %d", reader.consumed, maxConsumed)
}
if tt.wantErr {
if !errors.Is(err, errInvalidMCPFirstMessage) {
t.Fatalf("prepareMCPStdin() error = %v, want %v", err, errInvalidMCPFirstMessage)
}
return
}
if err != nil {
t.Fatalf("prepareMCPStdin() rejected exact-limit message: %v", err)
}
got, err := io.ReadAll(stdin)
if err != nil {
t.Fatalf("failed to read prepared stdin: %v", err)
}
if string(got) != input {
t.Fatalf("prepared exact-limit stdin mismatch\nwant: %q\ngot: %q", input, string(got))
}
}
func TestPrepareMCPStdinAcceptsEscapedStatelessFirstMessage(t *testing.T) {
t.Parallel()
message, err := json.Marshal(map[string]any{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": map[string]any{
"_meta": map[string]any{
metaKeyProtocolVersion: "2026-07-28",
},
"arguments": map[string]any{
"text": "quote \" slash \\ NUL \x00 HTML <",
},
},
})
if err != nil {
t.Fatalf("json.Marshal() returned error: %v", err)
}
input := string(message) + "\n"
stdin, err := prepareMCPStdin(strings.NewReader(input))
if err != nil {
t.Fatalf("prepareMCPStdin() rejected escaped stateless message: %v", err)
}
got, err := io.ReadAll(stdin)
if err != nil {
t.Fatalf("failed to read prepared stdin: %v", err)
}
if string(got) != input {
t.Fatalf("prepared escaped stateless stdin mismatch\nwant: %q\ngot: %q", input, got)
}
}
var errMCPFirstMessageReader = errors.New("simulated MCP stdin read failure")
type mcpFirstMessageDataErrorReader struct {
data []byte
err error
done bool
}
func (r *mcpFirstMessageDataErrorReader) Read(p []byte) (int, error) {
if r.done {
return 0, io.EOF
}
r.done = true
return copy(p, r.data), r.err
}
func TestPrepareMCPStdinAcceptsCompleteLineWithReadError(t *testing.T) {
t.Parallel()
input := `{"jsonrpc":"2.0","method":"initialize","id":1}` + "\n" + "tail"
stdin, err := prepareMCPStdin(&mcpFirstMessageDataErrorReader{
data: []byte(input),
err: errMCPFirstMessageReader,
})
if err != nil {
t.Fatalf("prepareMCPStdin() rejected complete line with read error: %v", err)
}
got, err := io.ReadAll(stdin)
if err != nil {
t.Fatalf("failed to read prepared stdin: %v", err)
}
if string(got) != input {
t.Fatalf("prepared stdin mismatch\nwant: %q\ngot: %q", input, string(got))
}
}
type mcpFirstMessageErrorReader struct{}
func (mcpFirstMessageErrorReader) Read([]byte) (int, error) {
return 0, errMCPFirstMessageReader
}
func TestPrepareMCPStdinRejectsReadErrorBeforeCompleteLine(t *testing.T) {
t.Parallel()
_, err := prepareMCPStdin(mcpFirstMessageErrorReader{})
if !errors.Is(err, errInvalidMCPFirstMessage) {
t.Fatalf("prepareMCPStdin() error = %v, want %v", err, errInvalidMCPFirstMessage)
}
}
type mcpFirstMessageZeroProgressReader struct{}
func (mcpFirstMessageZeroProgressReader) Read([]byte) (int, error) {
return 0, nil
}
func TestPrepareMCPStdinRejectsZeroProgressReader(t *testing.T) {
t.Parallel()
_, err := prepareMCPStdin(mcpFirstMessageZeroProgressReader{})
if !errors.Is(err, errInvalidMCPFirstMessage) {
t.Fatalf("prepareMCPStdin() error = %v, want %v", err, errInvalidMCPFirstMessage)
}
}
type countingMCPReader struct {
reader io.Reader
consumed int
}
func (r *countingMCPReader) Read(p []byte) (int, error) {
n, err := r.reader.Read(p)
r.consumed += n
return n, err
}
func captureStdout(t *testing.T, fn func()) string {
t.Helper()
stdoutMu.Lock()
defer stdoutMu.Unlock()
oldStdout := os.Stdout
r, w, pipeErr := os.Pipe()
if pipeErr != nil {
t.Fatalf("failed to create pipe for stdout capture: %v", pipeErr)
}
os.Stdout = w
defer func() {
os.Stdout = oldStdout
}()
fn()
err := w.Close()
if err != nil {
t.Logf("warning: failed to close stdout pipe writer: %v", err)
}
var buf bytes.Buffer
_, err = buf.ReadFrom(r)
if err != nil {
t.Fatalf("failed to read stdout: %v", err)
}
return buf.String()
}
// stdoutMu serializes access to the process-global os.Stdout variable inside
// captureStdout. Without it, two tests that call captureStdout in parallel can
// race: one test's os.Stdout swap may capture output belonging to another
// test, or one test's own output may be captured by the other. The mutex keeps
// the invariant local to captureStdout so individual tests can keep
// t.Parallel() without coordinating at the call site.
var stdoutMu sync.Mutex
//nolint:gocognit,gocyclo,cyclop,maintidx // comprehensive table-driven test covering all config resolution scenarios
func TestGetConfig(t *testing.T) {
t.Setenv("SEARXNG_URL", "https://env.example.com")
//nolint:paralleltest // t.Setenv-based config resolution mutates process-global env vars
t.Run("flag overrides env", func(t *testing.T) {
cfg, err := getConfig(&CLIFlags{SearXNGURL: "https://flag.example.com"}, false)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.SearXNGURL != "https://flag.example.com" {
t.Fatalf("SearXNGURL = %q, want flag value", cfg.SearXNGURL)
}
})
//nolint:paralleltest // t.Setenv-based config resolution mutates process-global env vars
t.Run("env used when flag empty", func(t *testing.T) {
cfg, err := getConfig(&CLIFlags{}, false)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.SearXNGURL != "https://env.example.com" {
t.Fatalf("SearXNGURL = %q, want env value", cfg.SearXNGURL)
}
})
t.Run("timeout env parsed", func(t *testing.T) {
t.Setenv("SEARXNG_TIMEOUT", "250ms")
cfg, err := getConfig(&CLIFlags{}, false)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.Timeout != 250*time.Millisecond {
t.Fatalf("Timeout = %v, want 250ms", cfg.Timeout)
}
})
t.Run("max retries env parsed", func(t *testing.T) {
t.Setenv("SEARXNG_MAX_RETRIES", "3")
cfg, err := getConfig(&CLIFlags{}, false)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.MaxRetries != 3 {
t.Fatalf("MaxRetries = %d, want 3", cfg.MaxRetries)
}
})
t.Run("GET fallback env parsed", func(t *testing.T) {
t.Setenv("SEARXNG_ALLOW_GET_FALLBACK", "1")
cfg, err := getConfig(&CLIFlags{}, false)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if !cfg.AllowGETFallback {
t.Fatal("AllowGETFallback = false, want true")
}
})
t.Run("GET fallback env zero disables", func(t *testing.T) {
t.Setenv("SEARXNG_ALLOW_GET_FALLBACK", "0")
cfg, err := getConfig(&CLIFlags{}, false)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.AllowGETFallback {
t.Fatal("AllowGETFallback = true, want false")
}
})
t.Run("cli flags override env", func(t *testing.T) {
t.Setenv("SEARXNG_TIMEOUT", "30s")
t.Setenv("SEARXNG_MAX_RETRIES", "9")
t.Setenv("SEARXNG_ALLOW_GET_FALLBACK", "0")
_, flags, _, err := parseArgs([]string{
"--searxng-url", "https://flag.example.com",
"--timeout", "1500ms",
"--max-retries", "4",
"--allow-get-fallback",
"test query",
})
if err != nil {
t.Fatalf("parseArgs() error = %v, want nil", err)
}
cfg, err := getConfig(flags, true)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.Timeout != 1500*time.Millisecond {
t.Fatalf("Timeout = %v, want 1500ms", cfg.Timeout)
}
if cfg.MaxRetries != 4 {
t.Fatalf("MaxRetries = %d, want 4", cfg.MaxRetries)
}
if !cfg.AllowGETFallback {
t.Fatal("AllowGETFallback = false, want true (CLI flag overrides env var)")
}
})
//nolint:paralleltest // t.Setenv-based config resolution mutates process-global env vars
t.Run("--allow-get-fallback flag without env enables fallback", func(t *testing.T) {
_, flags, _, err := parseArgs([]string{
"--searxng-url", "https://flag.example.com",
"--allow-get-fallback",
"test query",
})
if err != nil {
t.Fatalf("parseArgs() error = %v, want nil", err)
}
if !flags.AllowGETFallback {
t.Fatal("flags.AllowGETFallback = false, want true")
}
cfg, err := getConfig(flags, true)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if !cfg.AllowGETFallback {
t.Fatal("cfg.AllowGETFallback = false, want true (CLI flag alone enables fallback)")
}
})
t.Run("--allow-get-fallback=false overrides env true", func(t *testing.T) {
t.Setenv("SEARXNG_ALLOW_GET_FALLBACK", "1")
_, flags, _, err := parseArgs([]string{
"--searxng-url", "https://flag.example.com",
"--allow-get-fallback=false",
"test query",
})
if err != nil {
t.Fatalf("parseArgs() error = %v, want nil", err)
}
if !flags.AllowGETFallbackExplicit {
t.Fatal("flags.AllowGETFallbackExplicit = false, want true (flag was explicitly set)")
}
if flags.AllowGETFallback {
t.Fatal("flags.AllowGETFallback = true, want false (flag explicitly set to false)")
}
cfg, err := getConfig(flags, true)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.AllowGETFallback {
t.Fatal("cfg.AllowGETFallback = true, want false (CLI false overrides env true)")
}
})
t.Run("--allow-get-fallback absent preserves env value", func(t *testing.T) {
t.Setenv("SEARXNG_ALLOW_GET_FALLBACK", "1")
_, flags, _, err := parseArgs([]string{
"--searxng-url", "https://flag.example.com",
"test query",
})
if err != nil {
t.Fatalf("parseArgs() error = %v, want nil", err)
}
if flags.AllowGETFallback {
t.Fatal("flags.AllowGETFallback = true, want false (flag not passed)")
}
cfg, err := getConfig(flags, true)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if !cfg.AllowGETFallback {
t.Fatal("cfg.AllowGETFallback = false, want true (env=1, no flag)")
}
})
t.Run("invalid env parse values fall back to defaults", func(t *testing.T) {
t.Setenv("SEARXNG_TIMEOUT", "not-a-duration")
t.Setenv("SEARXNG_MAX_RETRIES", "xyz")
t.Setenv("SEARXNG_ALLOW_GET_FALLBACK", "true")
cfg, err := getConfig(&CLIFlags{}, false)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil (parse errors fall back)", err)
}
if cfg.Timeout != searxng.DefaultTimeout {
t.Fatalf("Timeout = %v, want default %v", cfg.Timeout, searxng.DefaultTimeout)
}
if cfg.MaxRetries != searxng.DefaultMaxRetries {
t.Fatalf("MaxRetries = %d, want default %d", cfg.MaxRetries, searxng.DefaultMaxRetries)
}
if cfg.AllowGETFallback {
t.Fatal("AllowGETFallback = true, want false for invalid env value")
}
})
t.Run("env semantic error: timeout zero", func(t *testing.T) {
t.Setenv("SEARXNG_TIMEOUT", "0")
_, err := getConfig(&CLIFlags{}, false)
if err == nil {
t.Fatal("getConfig() error = nil, want error for SEARXNG_TIMEOUT=0")
}
})
t.Run("env semantic error: max retries negative", func(t *testing.T) {
t.Setenv("SEARXNG_MAX_RETRIES", "-1")
_, err := getConfig(&CLIFlags{}, false)
if err == nil {
t.Fatal("getConfig() error = nil, want error for SEARXNG_MAX_RETRIES=-1")
}
})
t.Run("env parse error still allows CLI flag override", func(t *testing.T) {
t.Setenv("SEARXNG_TIMEOUT", "not-a-duration")
t.Setenv("SEARXNG_MAX_RETRIES", "abc")
t.Setenv("SEARXNG_ALLOW_GET_FALLBACK", "true")
_, flags, _, err := parseArgs([]string{
"--searxng-url", "https://flag.example.com",
"--timeout", "30s",
"--max-retries", "10",
"--allow-get-fallback",
"test query",
})
if err != nil {
t.Fatalf("parseArgs() error = %v, want nil", err)
}
cfg, err := getConfig(flags, true)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.Timeout != 30*time.Second {
t.Fatalf("Timeout = %v, want 30s", cfg.Timeout)
}
if cfg.MaxRetries != 10 {
t.Fatalf("MaxRetries = %d, want 10", cfg.MaxRetries)
}
if !cfg.AllowGETFallback {
t.Fatal("AllowGETFallback = false, want true (CLI flag overrides unparseable env)")
}
})
t.Run("max retries zero flag disables retries", func(t *testing.T) {
t.Setenv("SEARXNG_MAX_RETRIES", "7")
_, flags, _, err := parseArgs([]string{
"--searxng-url", "https://flag.example.com",
"--max-retries", "0",
"test query",
})
if err != nil {
t.Fatalf("parseArgs() error = %v, want nil", err)
}
cfg, err := getConfig(flags, true)
if err != nil {
t.Fatalf("getConfig() error = %v, want nil", err)
}
if cfg.MaxRetries != 0 {
t.Fatalf("MaxRetries = %d, want 0", cfg.MaxRetries)
}
})
t.Run("timeout zero flag rejected by SetTimeout", func(t *testing.T) {
t.Setenv("SEARXNG_TIMEOUT", "30s")
_, flags, _, err := parseArgs([]string{
"--searxng-url", "https://flag.example.com",
"--timeout", "0",
"test query",
})
if err != nil {
t.Fatalf("parseArgs() error = %v, want nil", err)
}
cfg, err := getConfig(flags, true)
if err == nil {
t.Fatal("getConfig() error = nil, want error (timeout=0 should be rejected)")
}
if cfg != nil {
t.Fatal("getConfig() returned non-nil config on error")
}
})
t.Run("error when neither set", func(t *testing.T) {
t.Setenv("SEARXNG_URL", "")
_, err := getConfig(&CLIFlags{}, false)
if err == nil {
t.Fatal("getConfig() error = nil, want error")
}
if !strings.Contains(err.Error(), "SearXNG_URL") || !strings.Contains(err.Error(), "required") {
t.Fatalf("getConfig() error = %q, want error mentioning 'SearXNG_URL' and 'required'", err.Error())
}
})
//nolint:paralleltest // t.Setenv-based config resolution mutates process-global env vars
t.Run("cli max-retries exceeds cap", func(t *testing.T) {
_, err := getConfig(&CLIFlags{
SearXNGURL: "https://example.com",
MaxRetries: new(21),
}, true)
if err == nil {
t.Fatal("getConfig() error = nil, want error for --max-retries=21")
}
if !strings.Contains(err.Error(), "max retries cannot exceed 20") {
t.Fatalf("getConfig() error = %q, want mention of max retry cap", err.Error())
}
})
//nolint:paralleltest // t.Setenv-based config resolution mutates process-global env vars
t.Run("cli timeout negative", func(t *testing.T) {
_, err := getConfig(&CLIFlags{
SearXNGURL: "https://example.com",
Timeout: new(-1 * time.Second),
}, true)
if err == nil {
t.Fatal("getConfig() error = nil, want error for --timeout=-1s")
}
if !strings.Contains(err.Error(), "timeout cannot be negative") {
t.Fatalf("getConfig() error = %q, want mention of negative timeout", err.Error())
}
})
}
// TestRegisterFlagsDefaultPinning guards against the bug reported in
// xlionjuan/searxng-mcp-go issue: the Go flag package reports the literal
// flag default (flag.Lookup(...).DefValue), not the effective default. If
// the flag default diverges from searxng.DefaultTimeout / DefaultMaxRetries,
// programmatic introspection of the FlagSet contradicts the help text and
// any consumer relying on DefValue will see a stale value.
func TestRegisterFlagsDefaultPinning(t *testing.T) {
t.Parallel()
fs, _ := registerFlags()
timeoutFlag := fs.Lookup("timeout")
if timeoutFlag == nil {
t.Fatal("timeout flag not registered")
}
if got, want := timeoutFlag.DefValue, searxng.DefaultTimeout.String(); got != want {
t.Errorf("timeout DefValue = %q, want %q (effective default)", got, want)
}
maxRetriesFlag := fs.Lookup("max-retries")
if maxRetriesFlag == nil {
t.Fatal("max-retries flag not registered")
}
if got, want := maxRetriesFlag.DefValue, strconv.Itoa(searxng.DefaultMaxRetries); got != want {
t.Errorf("max-retries DefValue = %q, want %q (effective default)", got, want)
}
}
// TestRegisterFlagsIntDefaultsParse guards against the defensive-programming
// issue where a future ParamDef with GoType "int" and a non-integer Default
// would be silently coerced to 0 by registerFlags. Every int-typed ParamDef
// in searxng.SearchParams must have a Default that strconv.Atoi can parse
// without error; if a new parameter is added with a malformed default, this
// test fails before registerFlags ever runs (and, in production,
// registerFlags would panic with errParamDefaultNotInt).
func TestRegisterFlagsIntDefaultsParse(t *testing.T) {
t.Parallel()
for _, p := range searxng.SearchParams {
if p.GoType != "int" {
continue
}
_, err := strconv.Atoi(p.Default)
if err != nil {
t.Errorf("SearchParams[%q] has GoType %q but Default %q does not parse as int: %v",
p.Name, p.GoType, p.Default, err)
}
}
// Smoke-check the end-to-end registration path: calling registerFlags
// must not panic. Today this is a no-op because all int defaults are
// valid, but it is the path that would panic on a regression.
_, _ = registerFlags()
}
func TestRunCLIMode_Success(t *testing.T) {
t.Parallel()
successResp := searxng.SearchResponse{
Query: "golang",
NumberOfResults: 1,
Results: []searxng.SearchResult{
{Title: "Go", URL: "https://go.dev", Content: "Go language", Engine: "google"},
},
}
tests := []struct {
name string
resp searxng.SearchResponse
rawResp string
flags *CLIFlags
positional []string
debug bool
check func(t *testing.T, output string)
}{
{
name: "text output",
resp: successResp,
flags: &CLIFlags{Query: "golang", Pageno: nil},
check: func(t *testing.T, output string) {
t.Helper()
if !strings.Contains(output, "=== Results ===") || !strings.Contains(output, "Go") {
t.Fatalf("unexpected text output: %q", output)
}
},
},
{
name: "json output",
resp: successResp,
flags: &CLIFlags{Query: "golang", JSON: true, Pageno: nil},
check: func(t *testing.T, output string) {
t.Helper()
var resp searxng.SearchResponse
err := json.Unmarshal([]byte(output), &resp)
if err != nil {
t.Fatalf("output is not valid JSON: %v\n%s", err, output)
}
if resp.Query != "golang" || len(resp.Results) != 1 || resp.Results[0].Title != "Go" {
t.Fatalf("unexpected JSON output: %+v", resp)
}
},
},
{
name: "debug json includes unresponsive engines",
rawResp: `{"query":"golang","number_of_results":1,` +
`"results":[{"title":"Go","url":"https://go.dev","content":"Go language","engine":"google"}],` +
`"suggestions":[],` +
`"unresponsive_engines":[["brave","Suspended:\" too many \"requests"]]}`,
flags: &CLIFlags{Query: "golang", JSON: true, Pageno: nil},
debug: true,
check: func(t *testing.T, output string) {
t.Helper()
if !strings.Contains(output, "unresponsive_engines") {
t.Fatalf("expected debug JSON to include unresponsive_engines, got %q", output)
}
},
},
{
name: "query flag wins over positional query",
resp: searxng.SearchResponse{
Query: "flag query",
NumberOfResults: 1,
Results: []searxng.SearchResult{
{Title: "Go", URL: "https://go.dev", Content: "Go language", Engine: "google"},
},
},
flags: &CLIFlags{Query: "flag query", Pageno: nil},
positional: []string{"positional query"},
check: func(t *testing.T, output string) {
t.Helper()
if !strings.Contains(output, "flag query") {
t.Fatalf("expected flag query to win, got %q", output)
}
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
var server *httptest.Server
if tt.rawResp != "" {
server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write([]byte(tt.rawResp)) //nolint:errcheck // test fixture write; failure does not affect test outcome
}))
} else {
server = newJSONTestServer(t, tt.resp)
}
defer server.Close()
flags := *tt.flags
flags.SearXNGURL = server.URL
var err error
output := captureStdout(t, func() {
err = runCLIMode(tt.debug, &flags, tt.positional)
})
if err != nil {
t.Fatalf("runCLIMode() error = %v", err)
}
tt.check(t, output)
})
}
}
func TestRunCLIMode_MapsParsedFlagsToSearchRequest(t *testing.T) {
t.Parallel()
type capturedCLIRequest struct {
method string
form url.Values
parseErr error
}
capturedRequest := make(chan capturedCLIRequest, 1)
responseBody := mustMarshalJSON(t, searxng.SearchResponse{
Query: "cli seam mapping",
NumberOfResults: 3,
Results: []searxng.SearchResult{
{Title: "First", URL: "https://example.com/1", Engine: "first-engine"},
{Title: "Second", URL: "https://example.com/2", Engine: "second-engine"},
{Title: "Third", URL: "https://example.com/3", Engine: "third-engine"},
},
})
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
parseErr := r.ParseForm()
form := make(url.Values, len(r.PostForm))
for key, values := range r.PostForm {
form[key] = append([]string(nil), values...)
}
capturedRequest <- capturedCLIRequest{
method: r.Method,
form: form,
parseErr: parseErr,
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(responseBody) //nolint:errcheck // test fixture write; failure is observed by the client
}))
defer server.Close()
isCLIMode, flags, positionalArgs, err := parseArgs([]string{
"--searxng-url", server.URL,
"--timeout", "2s",
"--max-retries", "0",
"--json",
"--query", "cli seam mapping",
"--language", "fr",
"--safesearch", "2",
"--time_range", "month",
"--categories", "news,science",
"--engines", "google,bing",
"--pageno", "7",
"--limit", "2",
})
if err != nil {
t.Fatalf("parseArgs() error = %v", err)
}
if !isCLIMode {
t.Fatal("parseArgs() isCLIMode = false, want true")
}
var runErr error
output := captureStdout(t, func() {
runErr = runCLIMode(flags.Debug, flags, positionalArgs)
})
if runErr != nil {
t.Fatalf("runCLIMode() error = %v", runErr)
}
request := <-capturedRequest
if request.parseErr != nil {
t.Fatalf("ParseForm() error = %v", request.parseErr)
}
if request.method != http.MethodPost {
t.Errorf("request method = %q, want %q", request.method, http.MethodPost)
}
wantForm := url.Values{
"q": []string{"cli seam mapping"},
"format": []string{"json"},
"language": []string{"fr"},
"safesearch": []string{"2"},
"time_range": []string{"month"},
"categories": []string{"news,science"},
"engines": []string{"google,bing"},
"pageno": []string{"7"},
}
if !reflect.DeepEqual(request.form, wantForm) {
t.Errorf("request form = %#v, want %#v", request.form, wantForm)
}
if request.form.Has("limit") {
t.Error("request form contains client-side-only limit")
}
var response searxng.SearchResponse
err = json.Unmarshal([]byte(output), &response)
if err != nil {
t.Fatalf("runCLIMode() output is not valid JSON: %v\n%s", err, output)
}
if got, want := len(response.Results), 2; got != want {
t.Fatalf("len(response.Results) = %d, want %d (--limit must be applied client-side)", got, want)
}
}
func TestRunCLIMode_MultiplePositionalArgsError(t *testing.T) {
t.Parallel()
err := runCLIMode(false, &CLIFlags{Pageno: nil}, []string{"golang", "programming"})
if err == nil {
t.Fatal("expected error, got nil")
}
if !strings.Contains(err.Error(), "only one query is accepted") {
t.Fatalf("error %q does not contain %q", err.Error(), "only one query is accepted")
}
if !strings.Contains(err.Error(), "use quotes") {
t.Fatalf("error %q does not contain %q", err.Error(), "use quotes")
}
}
func TestRunCLIMode_ValidationErrors(t *testing.T) {
t.Parallel()
tests := []struct {
name string
flags *CLIFlags
query []string
wantErr bool
errSubstr string
}{
{
name: "missing query",
flags: &CLIFlags{Language: "", SafeSearch: 0, Pageno: nil},
query: []string{},
wantErr: true,
errSubstr: "search query is required",
},
{
name: "safesearch out of range",
flags: &CLIFlags{Query: "test", SearXNGURL: "http://localhost:9999", Language: "", SafeSearch: -1, Pageno: nil},
query: []string{},
wantErr: true,
errSubstr: "validation error",
},
{
name: "invalid time_range",
flags: &CLIFlags{
Query: "test", SearXNGURL: "http://localhost:9999",
Language: "", SafeSearch: 0, TimeRange: "invalid", Pageno: nil,
},
query: []string{},
wantErr: true,
errSubstr: "validation error",
},
{
name: "pageno zero",
flags: &CLIFlags{
Query: "test", SearXNGURL: "http://localhost:9999",
Language: "", SafeSearch: 0, Pageno: new(0),
},
query: []string{},
wantErr: true,
errSubstr: "validation error",
},
{
name: "query too long",
flags: &CLIFlags{
Query: strings.Repeat("a", 501), SearXNGURL: "http://localhost:9999",
Language: "", SafeSearch: 0, Pageno: nil,
},
query: []string{},
wantErr: true,
errSubstr: "validation error",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
err := runCLIMode(false, tt.flags, tt.query)
if tt.wantErr {
if err == nil {
t.Fatal("expected error, got nil")
}
if !strings.Contains(err.Error(), tt.errSubstr) {
t.Errorf("error %q does not contain %q", err.Error(), tt.errSubstr)
}
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
})
}
}
func TestRunCLIMode_HelpFlag(t *testing.T) {
t.Parallel()
flags := &CLIFlags{Help: true, Language: "", SafeSearch: 0, Pageno: nil}
output := captureStdout(t, func() {
err := runCLIMode(false, flags, []string{})
if err != nil {
t.Errorf("runCLIMode() with --help should return nil, got: %v", err)
}
})
if !strings.Contains(output, "SearXNG") {
t.Errorf("expected help output to contain 'SearXNG', got output: %q", output)
}
if !strings.Contains(output, "USAGE:") {
t.Errorf("expected help output to contain 'USAGE:', got output: %q", output)
}
}
func TestRunCLIMode_VersionFlag(t *testing.T) {
t.Parallel()
flags := &CLIFlags{Version: true, Language: "", SafeSearch: 0, Pageno: nil}
output := captureStdout(t, func() {
err := runCLIMode(false, flags, []string{})
if err != nil {
t.Errorf("runCLIMode() with --version should return nil, got: %v", err)
}
})
if !strings.Contains(output, "version") {
t.Errorf("expected version output to contain 'version', got output: %q", output)
}
if !strings.Contains(output, "searxng-mcp-go") {
t.Errorf("expected version output to contain 'searxng-mcp-go', got output: %q", output)
}
}
func TestRunCLIMode_SearchErrorReturnsError(t *testing.T) {
t.Parallel()
server := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) {}))
server.Close()
maxRetries := 0
flags := &CLIFlags{
Query: "test",
SearXNGURL: server.URL,
Language: "",
SafeSearch: 0,
Pageno: nil,
MaxRetries: &maxRetries,
}
err := runCLIMode(false, flags, []string{})
if err == nil {
t.Fatal("expected error for connection refused, got nil")
}
if !strings.Contains(err.Error(), "search error") {
t.Fatalf("expected error containing 'search error', got: %v", err)
}
}
func TestRunCLIMode_TimeoutZeroRejected(t *testing.T) {
t.Parallel()
resp := searxng.SearchResponse{
Query: "test",
NumberOfResults: 1,
Results: []searxng.SearchResult{
{Title: "Go", URL: "https://go.dev", Content: "Go language", Engine: "test"},
},
}
server := newJSONTestServer(t, resp)
defer server.Close()
timeout := time.Duration(0)
flags := &CLIFlags{
Query: "test",
Pageno: nil,
Timeout: &timeout,
}
flags.SearXNGURL = server.URL
err := runCLIMode(false, flags, []string{})
if err == nil {
t.Fatal("runCLIMode() error = nil, want error (timeout=0 should be rejected)")
}
}
func TestRunCLIMode_TimeoutExceeded(t *testing.T) {
t.Parallel()
server := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, _ *http.Request) {
time.Sleep(5 * time.Second)
}))
defer server.Close()
timeout := 1 * time.Millisecond
maxRetries := 0
flags := &CLIFlags{
Query: "test",
SearXNGURL: server.URL,
Pageno: nil,
Timeout: &timeout,
MaxRetries: &maxRetries,
}
err := runCLIMode(false, flags, []string{})
if err == nil {
t.Fatal("expected error, got nil")
}
errStr := err.Error()
if !strings.Contains(errStr, "search error") {
t.Fatalf("expected 'search error' in error, got: %v", err)
}
}
func TestRunCLIMode_TimeoutIsPerRequestNotOverall(t *testing.T) {
t.Parallel()
var attempts atomic.Int32
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
n := attempts.Add(1)
if n == 1 {
// Exceed the per-request timeout so the first attempt is
// canceled. Under the old CLI behavior this would also have
// exhausted the overall search deadline, preventing retries.
time.Sleep(100 * time.Millisecond)
return
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
//nolint:errcheck // test fixture write best-effort
_, _ = w.Write([]byte(
`{"query":"test","number_of_results":1,` +
`"results":[{"title":"OK","url":"https://example.com","content":"ok","engine":"test"}],` +
`"suggestions":[]}`,
))
}))
defer server.Close()
// Per-request timeout is shorter than the first request sleep, but the
// overall search is bounded by context.Background() (no deadline), so
// retries can still succeed.
timeout := 50 * time.Millisecond
maxRetries := 1
flags := &CLIFlags{
Query: "test",
SearXNGURL: server.URL,
Pageno: nil,
Timeout: &timeout,
MaxRetries: &maxRetries,
}
output := captureStdout(t, func() {
err := runCLIMode(false, flags, []string{})
if err != nil {
t.Fatalf("runCLIMode() error = %v, want nil (timeout is per-request, retries should not be preempted)", err)
}
})
if got := attempts.Load(); got != 2 {
t.Fatalf("attempts = %d, want 2 (1 request timeout + 1 success)", got)
}
if !strings.Contains(output, "=== Results ===") {
t.Fatalf("expected results output, got: %q", output)
}
}
func TestRunCLIMode_FlagOnlyInvocations(t *testing.T) {
t.Parallel()
tests := []struct {
name string
flags *CLIFlags
wantErr bool
errSubstr string
}{
{
name: "language flag only - no query",
flags: &CLIFlags{Language: "ja", SafeSearch: 0, Pageno: nil},
wantErr: true,
errSubstr: "search query is required",
},
{
name: "searxng-url flag only - no query",
flags: &CLIFlags{SearXNGURL: "https://example.com", Language: "", SafeSearch: 0, Pageno: nil},
wantErr: true,
errSubstr: "search query is required",
},
{
name: "multiple flags only - no query",
flags: &CLIFlags{Language: "", SafeSearch: 1, Pageno: nil},
wantErr: true,
errSubstr: "search query is required",
},
{
name: "all optional flags without query",
flags: &CLIFlags{
Language: "zh-tw", SafeSearch: 2, TimeRange: "month",
Categories: "general", Engines: "google", Pageno: nil,
},
wantErr: true,
errSubstr: "search query is required",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
err := runCLIMode(false, tt.flags, []string{})
if tt.wantErr {
if err == nil {
t.Fatal("expected error, got nil")
}
if !strings.Contains(err.Error(), tt.errSubstr) {
t.Errorf("error %q does not contain %q", err.Error(), tt.errSubstr)
}
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
})
}
}