mirror of
https://github.com/xlionjuan/searxng-mcp-go.git
synced 2026-11-16 19:40:03 +00:00
256 lines
6 KiB
Go
256 lines
6 KiB
Go
package main
|
|
|
|
import (
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// mockServerResponse is a minimal valid SearXNG JSON response body used by
|
|
// mock-server network boundary tests.
|
|
const mockServerResponse = `{
|
|
"query": "mock query",
|
|
"number_of_results": 1,
|
|
"results": [
|
|
{
|
|
"title": "Mock Result",
|
|
"url": "https://example.com/mock",
|
|
"content": "This is a mock result from the local test server.",
|
|
"engine": "mock"
|
|
}
|
|
],
|
|
"answers": [],
|
|
"infoboxes": [],
|
|
"suggestions": [],
|
|
"unresponsive_engines": []
|
|
}`
|
|
|
|
// TestMockServerNetworkBoundaries exercises network edge cases against a
|
|
// local httptest mock SearXNG server. No live external instance is required.
|
|
//
|
|
//nolint:gocognit,gocyclo,cyclop // table-driven test covering deterministic mock-server network boundary scenarios
|
|
func TestMockServerNetworkBoundaries(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
args func(url string) []string
|
|
handler func(t *testing.T) http.Handler
|
|
wantCode int
|
|
wantOutput string
|
|
wantReqCount int
|
|
checkReqCount bool
|
|
}{
|
|
{
|
|
name: "POST to GET fallback",
|
|
args: func(url string) []string {
|
|
return []string{
|
|
"--allow-get-fallback",
|
|
"--searxng-url", url,
|
|
"--timeout", "5s",
|
|
"--max-retries", "0",
|
|
"test",
|
|
}
|
|
},
|
|
handler: func(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
|
|
var count atomic.Int32
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
n := count.Add(1)
|
|
|
|
switch {
|
|
case n == 1 && r.Method == http.MethodPost:
|
|
w.WriteHeader(http.StatusMethodNotAllowed)
|
|
|
|
return
|
|
case n == 2 && r.Method == http.MethodGet:
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
_, err := w.Write([]byte(mockServerResponse))
|
|
if err != nil {
|
|
t.Logf("mock server write error: %v", err)
|
|
}
|
|
|
|
return
|
|
default:
|
|
t.Logf("unexpected request #%d method %s", n, r.Method)
|
|
w.WriteHeader(http.StatusTeapot)
|
|
}
|
|
})
|
|
},
|
|
wantCode: 0,
|
|
wantOutput: "Mock Result",
|
|
wantReqCount: 2,
|
|
checkReqCount: true,
|
|
},
|
|
{
|
|
name: "HTTP timeout with slow server",
|
|
args: func(url string) []string {
|
|
return []string{
|
|
"--searxng-url", url,
|
|
"--timeout", "500ms",
|
|
"--max-retries", "0",
|
|
"test",
|
|
}
|
|
},
|
|
handler: func(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
// Sleep longer than the configured 500ms timeout. The value
|
|
// is kept short so the test remains fast while still
|
|
// reliably triggering a client-side timeout.
|
|
time.Sleep(1200 * time.Millisecond)
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
_, err := w.Write([]byte(mockServerResponse))
|
|
if err != nil {
|
|
t.Logf("mock server write error: %v", err)
|
|
}
|
|
})
|
|
},
|
|
wantCode: 1,
|
|
wantOutput: "search error",
|
|
},
|
|
{
|
|
name: "retry succeeds after transient 500 errors",
|
|
args: func(url string) []string {
|
|
return []string{
|
|
"--searxng-url", url,
|
|
"--timeout", "5s",
|
|
"--max-retries", "2",
|
|
"test",
|
|
}
|
|
},
|
|
handler: func(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
|
|
var count atomic.Int32
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
n := count.Add(1)
|
|
|
|
if r.Method != http.MethodPost {
|
|
t.Logf("unexpected request method %s", r.Method)
|
|
w.WriteHeader(http.StatusTeapot)
|
|
|
|
return
|
|
}
|
|
|
|
if n <= 2 {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
_, err := w.Write([]byte(mockServerResponse))
|
|
if err != nil {
|
|
t.Logf("mock server write error: %v", err)
|
|
}
|
|
})
|
|
},
|
|
wantCode: 0,
|
|
wantOutput: "Mock Result",
|
|
wantReqCount: 3,
|
|
checkReqCount: true,
|
|
},
|
|
{
|
|
name: "malformed JSON response returns parse error",
|
|
args: func(url string) []string {
|
|
return []string{
|
|
"--searxng-url", url,
|
|
"--timeout", "5s",
|
|
"--max-retries", "0",
|
|
"test",
|
|
}
|
|
},
|
|
handler: func(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
_, err := w.Write([]byte("{invalid json"))
|
|
if err != nil {
|
|
t.Logf("mock server write error: %v", err)
|
|
}
|
|
})
|
|
},
|
|
wantCode: 1,
|
|
wantOutput: "search error",
|
|
},
|
|
{
|
|
name: "5xx server error with no retries",
|
|
args: func(url string) []string {
|
|
return []string{
|
|
"--searxng-url", url,
|
|
"--timeout", "5s",
|
|
"--max-retries", "0",
|
|
"test",
|
|
}
|
|
},
|
|
handler: func(t *testing.T) http.Handler {
|
|
t.Helper()
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.WriteHeader(http.StatusServiceUnavailable)
|
|
|
|
_, err := w.Write([]byte(`{"error":"upstream unavailable"}`))
|
|
if err != nil {
|
|
t.Logf("mock server write error: %v", err)
|
|
}
|
|
})
|
|
},
|
|
wantCode: 1,
|
|
wantOutput: "search error",
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var reqCount atomic.Int32
|
|
|
|
baseHandler := tt.handler(t)
|
|
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
reqCount.Add(1)
|
|
baseHandler.ServeHTTP(w, r)
|
|
}))
|
|
defer server.Close()
|
|
|
|
binPath, cleanup := buildTestBinary(t)
|
|
defer cleanup()
|
|
|
|
env := envWithout(
|
|
"SEARXNG_URL",
|
|
"SEARXNG_TIMEOUT",
|
|
"SEARXNG_MAX_RETRIES",
|
|
"SEARXNG_ALLOW_GET_FALLBACK",
|
|
)
|
|
|
|
out, code := runCLI(t, binPath, env, tt.args(server.URL)...)
|
|
|
|
if code != tt.wantCode {
|
|
t.Errorf("exit code = %d, want %d\noutput: %s", code, tt.wantCode, out)
|
|
}
|
|
|
|
if !strings.Contains(out, tt.wantOutput) {
|
|
t.Errorf("output should contain %q, got: %s", tt.wantOutput, out)
|
|
}
|
|
|
|
if tt.checkReqCount && int(reqCount.Load()) != tt.wantReqCount {
|
|
t.Errorf("request count = %d, want %d", reqCount.Load(), tt.wantReqCount)
|
|
}
|
|
})
|
|
}
|
|
}
|