searxng-mcp-go/search_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

1005 lines
27 KiB
Go

package main
import (
"context"
"errors"
"io"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"sync/atomic"
"testing"
"testing/synctest"
"time"
"searxng-mcp-go/internal/searxng"
"searxng-mcp-go/internal/testhelper"
)
func TestSearch_TimeoutZeroWithBackgroundContext(t *testing.T) {
t.Parallel()
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{
{Title: "Result", URL: "https://example.com/1", Content: "Content 1", Engine: "test"},
},
NumberOfResults: 1,
Query: "test",
}
server := newJSONTestServer(t, searchResp)
defer server.Close()
cfg := &searxng.Config{
SearXNGURL: server.URL,
Timeout: 0,
}
args := &searxng.SearchArgs{
Query: "test",
}
result, err := testPerformSearch(context.Background(), t, cfg, args)
if err != nil {
t.Fatalf("Search() error = %v, want nil (timeout=0 should not cancel)", err)
}
if len(result.Results) != 1 {
t.Fatalf("results length = %d, want 1", len(result.Results))
}
}
func TestSearch_RetryAfterRequestTimeout(t *testing.T) {
t.Parallel()
synctest.Test(t, func(t *testing.T) {
var attempts atomic.Int32
transport := testhelper.RoundTripperFunc(func(_ *http.Request) (*http.Response, error) {
n := attempts.Add(1)
if n < 3 {
// Simulate a context deadline exceeded (timeout) without real sleep.
return nil, context.DeadlineExceeded
}
return &http.Response{
StatusCode: http.StatusOK,
Header: http.Header{"Content-Type": []string{"application/json"}},
Body: io.NopCloser(strings.NewReader(
`{"query":"test","number_of_results":1,` +
`"results":[{"title":"OK","url":"https://example.com","content":"ok","engine":"test"}],` +
`"suggestions":[]}`,
)),
}, nil
})
searcher := newRetrySearcher(t, "https://search.example.com", transport, 2)
result, err := searcher.Search(context.Background(), &searxng.SearchArgs{Query: "test"})
if err != nil {
t.Fatalf("Search() error = %v, want nil (retries should not be preempted by request timeout)", err)
}
if got := attempts.Load(); got != 3 {
t.Fatalf("attempts = %d, want 3 (2 request timeouts + 1 success)", got)
}
if len(result.Results) != 1 {
t.Fatalf("results length = %d, want 1", len(result.Results))
}
})
}
func TestSearch_CallerContextCancellationStopsRetries(t *testing.T) {
t.Parallel()
var attempts atomic.Int32
started := make(chan struct{})
transport := testhelper.RoundTripperFunc(func(r *http.Request) (*http.Response, error) {
attempts.Add(1)
close(started)
// Block until the caller context is canceled — then return the
// cancellation error so the retry loop sees ctx.Err() and aborts.
<-r.Context().Done()
return nil, r.Context().Err()
})
searcher := newRetrySearcher(t, "https://search.example.com", transport, 10)
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
errCh := make(chan error, 1)
go func() {
_, err := searcher.Search(ctx, &searxng.SearchArgs{Query: "test"})
errCh <- err
}()
// Wait for the first request to actually begin executing, then cancel.
<-started
cancel()
err := <-errCh
if !errors.Is(err, context.Canceled) {
t.Fatalf("Search() error = %v, want context.Canceled", err)
}
if got := attempts.Load(); got != 1 {
t.Fatalf("attempts = %d, want 1", got)
}
}
func TestSearch_Success(t *testing.T) {
t.Parallel()
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{
{Title: "Result 1", URL: "https://example.com/1", Content: "Content 1", Engine: "google"},
{Title: "Result 2", URL: "https://example.com/2", Content: "Content 2", Engine: "bing"},
},
NumberOfResults: 2,
Query: "test",
}
server := newJSONTestServer(t, searchResp)
defer server.Close()
cfg := &searxng.Config{
SearXNGURL: server.URL,
Timeout: 30 * time.Second,
}
args := &searxng.SearchArgs{
Query: "test",
}
ctx := t.Context()
result, err := testPerformSearch(ctx, t, cfg, args)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(result.Results) != 2 {
t.Errorf("expected 2 results, got %d", len(result.Results))
}
if result.Results[0].Title != "Result 1" {
t.Errorf("expected 'Result 1', got %s", result.Results[0].Title)
}
}
func TestSearch_PreservesUnresponsiveEngines(t *testing.T) {
t.Parallel()
searchResp := searxng.SearchResponse{
Query: "test",
NumberOfResults: 1,
Results: []searxng.SearchResult{
{
Title: "Result 1",
URL: "https://example.com/1",
Content: "Content 1",
Engine: "google",
},
},
Suggestions: []string{},
UnresponsiveEngines: [][]string{
{"brave", `Suspended:" too many "requests`},
{"startpage", `Suspended:" "CAPTCHA`},
},
Debug: true,
}
server := newJSONTestServer(t, searchResp)
defer server.Close()
cfg := &searxng.Config{SearXNGURL: server.URL, Timeout: 30 * time.Second}
ctx := t.Context()
result, err := testPerformSearch(ctx, t, cfg, &searxng.SearchArgs{Query: "test"})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(result.UnresponsiveEngines) != 2 {
t.Fatalf("expected 2 unresponsive engines, got %#v", result.UnresponsiveEngines)
}
if result.UnresponsiveEngines[0][0] != "brave" || result.UnresponsiveEngines[1][0] != "startpage" {
t.Fatalf("unexpected unresponsive engines: %#v", result.UnresponsiveEngines)
}
}
//nolint:gocognit // table-driven test covering all search request parameter combinations
func TestSearch_RequestParameters(t *testing.T) {
t.Parallel()
page := 2
tests := []struct {
name string
args *searxng.SearchArgs
wantParams map[string]string
wantAbsent []string
}{
{
name: "basic parameters",
args: &searxng.SearchArgs{Query: "test", Language: "en", SafeSearch: 1},
wantParams: map[string]string{
"q": "test",
"format": "json",
"language": "en",
"safesearch": "1",
},
},
{
name: "default language omitted",
args: &searxng.SearchArgs{Query: "test"},
wantParams: map[string]string{"q": "test", "format": "json"},
wantAbsent: []string{"language"},
},
{
name: "time range day forwarded",
args: &searxng.SearchArgs{Query: "test", TimeRange: "day"},
wantParams: map[string]string{"time_range": "day"},
},
{
name: "time range month forwarded",
args: &searxng.SearchArgs{Query: "test", TimeRange: "month"},
wantParams: map[string]string{"time_range": "month"},
},
{
name: "time range year forwarded",
args: &searxng.SearchArgs{Query: "test", TimeRange: "year"},
wantParams: map[string]string{"time_range": "year"},
},
{
name: "empty time range omitted",
args: &searxng.SearchArgs{Query: "test", TimeRange: ""},
wantAbsent: []string{"time_range"},
},
{
name: "categories forwarded",
args: &searxng.SearchArgs{Query: "test", Categories: "general,news"},
wantParams: map[string]string{"categories": "general,news"},
},
{
name: "engines forwarded",
args: &searxng.SearchArgs{Query: "test", Engines: "google,bing"},
wantParams: map[string]string{"engines": "google,bing"},
},
{
name: "pageno forwarded",
args: &searxng.SearchArgs{Query: "test", Pageno: &page},
wantParams: map[string]string{"pageno": "2"},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
capturedParams := make(chan url.Values, 1)
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{{Title: "test", URL: "https://example.com"}},
NumberOfResults: 1,
Query: "test",
}
body := mustMarshalJSON(t, searchResp)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var params url.Values
if r.Method == http.MethodPost {
_ = r.ParseForm() //nolint:errcheck // test reads form best-effort; failure does not affect test outcome
params = make(url.Values, len(r.PostForm))
for key, values := range r.PostForm {
params[key] = append([]string(nil), values...)
}
} else {
params = r.URL.Query()
}
capturedParams <- params
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(body) //nolint:errcheck // test fixture write; failure does not affect test outcome
}))
defer server.Close()
cfg := &searxng.Config{SearXNGURL: server.URL, Timeout: 30 * time.Second}
_, err := testPerformSearch(t.Context(), t, cfg, tt.args)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
params := <-capturedParams
for key, want := range tt.wantParams {
if got := params.Get(key); got != want {
t.Errorf("%s = %q, want %q", key, got, want)
}
}
for _, key := range tt.wantAbsent {
if _, ok := params[key]; ok {
t.Errorf("expected %s to be omitted, got values %v", key, params[key])
}
}
})
}
}
func TestSearch_SearchPathNormalization(t *testing.T) {
t.Parallel()
tests := []struct {
name string
baseURL string
wantPath string
}{
{name: "root path", baseURL: "", wantPath: "/search"},
{name: "nested path", baseURL: "/api/", wantPath: "/api/search"},
{name: "existing search suffix", baseURL: "/search", wantPath: "/search"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
var gotPath string
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
gotPath = r.URL.Path
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{{Title: "x", URL: "https://x"}},
NumberOfResults: 1,
Query: "test",
}
body := mustMarshalJSON(t, searchResp)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(body) //nolint:errcheck // test fixture write; failure does not affect test outcome
}))
defer server.Close()
cfg := &searxng.Config{SearXNGURL: server.URL + tt.baseURL, Timeout: 30 * time.Second}
_, err := testPerformSearch(t.Context(), t, cfg, &searxng.SearchArgs{Query: "test"})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if gotPath != tt.wantPath {
t.Fatalf("request path = %q, want %q", gotPath, tt.wantPath)
}
})
}
}
// --- helper functions and test utilities ---
// Test that Search properly encodes query parameters.
func TestSearch_QueryEncoding(t *testing.T) {
t.Parallel()
var capturedQuery string
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
capturedQuery = r.PostFormValue("q")
} else {
capturedQuery = r.URL.Query().Get("q")
}
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{{Title: "x", URL: "https://x"}},
NumberOfResults: 1,
Query: capturedQuery,
}
body := mustMarshalJSON(t, searchResp)
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(body) //nolint:errcheck // test fixture write; failure does not affect test outcome
}))
defer server.Close()
cfg := &searxng.Config{
SearXNGURL: server.URL,
Timeout: 30 * time.Second,
}
// Test query with special characters that need URL encoding
args := &searxng.SearchArgs{Query: "test query with spaces & special=chars"}
ctx := t.Context()
_, err := testPerformSearch(ctx, t, cfg, args)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if capturedQuery != "test query with spaces & special=chars" {
t.Errorf("expected decoded query 'test query with spaces & special=chars', got %q", capturedQuery)
}
}
// Test URL validation edge cases.
func TestNewSearXNGSearcher_URLValidation(t *testing.T) {
t.Parallel()
tests := []struct {
name string
baseURL string
wantErr bool
errSubstr string
}{
{"valid URL", "https://search.example.com", false, ""},
{"invalid URL is wrapped", "search.example.com", true, "newSearXNGSearcher: url must use http or https scheme"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
_, err := searxng.NewSearXNGSearcher(&searxng.Config{SearXNGURL: tt.baseURL, Timeout: 30 * time.Second}, false)
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)
}
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
})
}
}
// Test NumberOfResults=0 with actual results (SearXNG quirk).
func TestSearch_NumberOfResultsZeroWithResults(t *testing.T) {
t.Parallel()
// SearXNG may return number_of_results=0 even when results exist
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{
{Title: "Result 1", URL: "https://example.com/1", Content: "Content 1", Engine: "google"},
{Title: "Result 2", URL: "https://example.com/2", Content: "Content 2", Engine: "bing"},
},
NumberOfResults: 0, // API returns 0 but has results
Query: "test",
}
server := newJSONTestServer(t, searchResp)
defer server.Close()
cfg := &searxng.Config{
SearXNGURL: server.URL,
Timeout: 30 * time.Second,
}
args := &searxng.SearchArgs{Query: "test"}
ctx := t.Context()
result, err := testPerformSearch(ctx, t, cfg, args)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
// Should have corrected NumberOfResults to match actual result count
if result.NumberOfResults != 2 {
t.Errorf("NumberOfResults = %d, want 2", result.NumberOfResults)
}
if len(result.Results) != 2 {
t.Errorf("len(Results) = %d, want 2", len(result.Results))
}
}
func TestSearXNGSearcher_Close_Idempotent(t *testing.T) {
t.Parallel()
t.Run("nil client", func(t *testing.T) {
t.Parallel()
searcher, err := searxng.NewSearXNGSearcher(&searxng.Config{SearXNGURL: "https://example.com"}, false)
if err != nil {
t.Fatal(err)
}
err = searcher.Close()
if err != nil {
t.Fatalf("first Close() = %v, want nil", err)
}
err = searcher.Close()
if err != nil {
t.Fatalf("second Close() = %v, want nil", err)
}
})
t.Run("shared default client", func(t *testing.T) {
t.Parallel()
searcher, err := searxng.NewSearXNGSearcher(&searxng.Config{SearXNGURL: "https://example.com"}, false)
if err != nil {
t.Fatal(err)
}
err = searcher.Close()
if err != nil {
t.Fatalf("first Close() = %v, want nil", err)
}
err = searcher.Close()
if err != nil {
t.Fatalf("second Close() = %v, want nil", err)
}
})
t.Run("custom client", func(t *testing.T) {
t.Parallel()
customClient := &http.Client{Timeout: 30 * time.Second}
searcher, err := searxng.NewSearXNGSearcher(
&searxng.Config{SearXNGURL: "https://example.com", HTTPClient: customClient}, false,
)
if err != nil {
t.Fatal(err)
}
err = searcher.Close()
if err != nil {
t.Fatalf("first Close() = %v, want nil", err)
}
err = searcher.Close()
if err != nil {
t.Fatalf("second Close() = %v, want nil", err)
}
})
}
//nolint:gocognit,gocyclo,cyclop // table-driven test covering POST-to-GET fallback with various HTTP responses
func TestSearch_POSTtoGETFallback(t *testing.T) {
t.Parallel()
tests := []struct {
name string
statusCode int
}{
{name: "405 fallback", statusCode: http.StatusMethodNotAllowed},
{name: "501 fallback", statusCode: http.StatusNotImplemented},
}
for _, tt := range tests {
t.Run(tt.name+" default disabled", func(t *testing.T) {
t.Parallel()
var (
postCount int
postReq *http.Request
getReq *http.Request
)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
postCount++
postReq = r
w.WriteHeader(tt.statusCode)
return
}
if r.Method == http.MethodGet {
getReq = r
}
w.WriteHeader(http.StatusInternalServerError)
}))
defer server.Close()
cfg := &searxng.Config{SearXNGURL: server.URL, Timeout: 30 * time.Second}
args := &searxng.SearchArgs{Query: "sensitive search", Language: "en", SafeSearch: 1}
_, err := testPerformSearch(t.Context(), t, cfg, args)
if err == nil {
t.Fatal("expected error when GET fallback is disabled")
}
if postReq == nil {
t.Fatal("POST request was never made")
}
if postCount != 1 {
t.Fatalf("POST count = %d, want 1 (501 should not be retried)", postCount)
}
if getReq != nil {
t.Fatal("GET fallback was called even though it is disabled")
}
if postReq.URL.RawQuery != "" {
t.Error("POST request had query params in URI - query should only be in body")
}
var se *searxng.SearXNGError
if !errors.As(err, &se) {
t.Fatalf("error type = %T, want *searxng.SearXNGError", err)
}
if se.StatusCode != tt.statusCode {
t.Fatalf("SearXNGError.StatusCode = %d, want %d", se.StatusCode, tt.statusCode)
}
errText := err.Error()
if strings.Contains(errText, "sensitive search") || strings.Contains(errText, "q=sensitive") {
t.Fatalf("error leaked query: %v", err)
}
if !strings.Contains(errText, "SEARXNG_ALLOW_GET_FALLBACK=1") {
t.Fatalf("error = %q, want opt-in guidance", errText)
}
})
t.Run(tt.name+" opt-in enabled", func(t *testing.T) {
t.Parallel()
var (
postReq *http.Request
getReq *http.Request
)
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{{Title: "fallback", URL: "https://example.com"}},
NumberOfResults: 1,
Query: "test",
}
body := mustMarshalJSON(t, searchResp)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
postReq = r
w.WriteHeader(tt.statusCode)
return
}
if r.Method == http.MethodGet {
getReq = r
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(body) //nolint:errcheck // test fixture write; failure does not affect test outcome
return
}
w.WriteHeader(http.StatusInternalServerError)
}))
defer server.Close()
cfg := &searxng.Config{SearXNGURL: server.URL, Timeout: 30 * time.Second, AllowGETFallback: true}
args := &searxng.SearchArgs{Query: "test search", Language: "en", SafeSearch: 1}
result, err := testPerformSearch(t.Context(), t, cfg, args)
if err != nil {
t.Fatalf("unexpected error after fallback: %v", err)
}
if result == nil {
t.Fatal("expected result, got nil")
}
if postReq == nil {
t.Fatal("POST request was never made")
}
if getReq == nil {
t.Fatal("GET fallback was never called")
}
if postReq.URL.RawQuery != "" {
t.Error("POST request had query params in URI - query should only be in body")
}
getQuery := getReq.URL.Query()
if getQuery.Get("q") != "test search" ||
getQuery.Get("format") != "json" ||
getQuery.Get("language") != "en" ||
getQuery.Get("safesearch") != "1" {
t.Fatalf("unexpected GET query params: %v", getQuery)
}
})
}
}
func TestSearch_RetriesRetryableStatus(t *testing.T) {
t.Parallel()
const successResponseBody = `{"query":"test","number_of_results":1,` +
`"results":[{"title":"Result","url":"https://example.com","content":"ok","engine":"test"}],` +
`"suggestions":[]}`
tests := []struct {
name string
status int
}{
{name: "429", status: http.StatusTooManyRequests},
{name: "500", status: http.StatusInternalServerError},
{name: "502", status: http.StatusBadGateway},
{name: "503", status: http.StatusServiceUnavailable},
{name: "504", status: http.StatusGatewayTimeout},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Parallel()
synctest.Test(t, func(t *testing.T) {
var attempts atomic.Int32
transport := testhelper.RoundTripperFunc(func(_ *http.Request) (*http.Response, error) {
if attempts.Add(1) == 1 {
return &http.Response{
StatusCode: tt.status,
Body: io.NopCloser(strings.NewReader("")),
}, nil
}
return &http.Response{
StatusCode: http.StatusOK,
Header: http.Header{"Content-Type": []string{"application/json"}},
Body: io.NopCloser(strings.NewReader(successResponseBody)),
}, nil
})
searcher := newRetrySearcher(t, "https://search.example.com", transport, 1)
result, err := searcher.Search(t.Context(), &searxng.SearchArgs{Query: "test"})
if err != nil {
t.Fatalf("Search() error = %v, want nil", err)
}
if got := attempts.Load(); got != 2 {
t.Fatalf("attempts = %d, want 2", got)
}
if len(result.Results) != 1 {
t.Fatalf("results length = %d, want 1", len(result.Results))
}
})
})
}
}
func TestSearch_RetriesEmptySearchResponse(t *testing.T) {
t.Parallel()
synctest.Test(t, func(t *testing.T) {
const successResponseBody = `{"query":"test","number_of_results":1,` +
`"results":[{"title":"Result","url":"https://example.com","content":"ok","engine":"test"}],` +
`"suggestions":[]}`
var attempts atomic.Int32
transport := testhelper.RoundTripperFunc(func(_ *http.Request) (*http.Response, error) {
attempt := attempts.Add(1)
if attempt == 1 {
return &http.Response{
StatusCode: http.StatusOK,
Header: http.Header{"Content-Type": []string{"application/json"}},
Body: io.NopCloser(strings.NewReader(`{"query":"test","results":[],"suggestions":[]}`)),
}, nil
}
return &http.Response{
StatusCode: http.StatusOK,
Header: http.Header{"Content-Type": []string{"application/json"}},
Body: io.NopCloser(strings.NewReader(successResponseBody)),
}, nil
})
searcher := newRetrySearcher(t, "https://search.example.com", transport, 1)
result, err := searcher.Search(t.Context(), &searxng.SearchArgs{Query: "test"})
if err != nil {
t.Fatalf("Search() error = %v, want nil", err)
}
if got := attempts.Load(); got != 2 {
t.Fatalf("attempts = %d, want 2", got)
}
if len(result.Results) != 1 {
t.Fatalf("results length = %d, want 1", len(result.Results))
}
})
}
func TestSearch_CanceledDuringRequest(t *testing.T) {
t.Parallel()
var callCount atomic.Int32
ctx, cancel := context.WithCancel(t.Context())
defer cancel()
transport := testhelper.RoundTripperFunc(func(_ *http.Request) (*http.Response, error) {
callCount.Add(1)
cancel()
return &http.Response{
StatusCode: http.StatusOK,
Header: http.Header{"Content-Type": []string{"application/json"}},
Body: io.NopCloser(strings.NewReader(
`{"query":"test","results":[],"suggestions":[],"answers":[],"infoboxes":[]}`,
)),
}, nil
})
searcher := newRetrySearcher(t, "https://search.example.com", transport, 1)
_, err := searcher.Search(ctx, &searxng.SearchArgs{Query: "test"})
if err == nil {
t.Fatal("Search() error = nil, want context cancellation error")
}
if !errors.Is(err, context.Canceled) {
t.Fatalf("Search() error = %v, want context.Canceled", err)
}
if got := callCount.Load(); got != 1 {
t.Fatalf("attempts = %d, want 1", got)
}
}
func TestSearch_RetryWaitCanceled(t *testing.T) {
t.Parallel()
// synctest.Test runs the enclosed function in a deterministic time bubble
// where timers and context deadlines use synthetic time. Time advances
// only when all goroutines in the bubble are blocked, so there is no
// wall-clock race between the retryWait timer and the context deadline.
synctest.Test(t, func(t *testing.T) {
var callCount atomic.Int32
ctx, cancel := context.WithTimeout(t.Context(), time.Millisecond)
defer cancel()
transport := testhelper.RoundTripperFunc(func(_ *http.Request) (*http.Response, error) {
callCount.Add(1)
return nil, errTestConnectionReset
})
searcher := newRetrySearcher(t, "https://search.example.com", transport, 10)
_, err := searcher.Search(ctx, &searxng.SearchArgs{Query: "test"})
if err == nil {
t.Fatal("Search() error = nil, want context deadline exceeded error")
}
if !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("Search() error = %v, want context.DeadlineExceeded", err)
}
if got := callCount.Load(); got != 1 {
t.Fatalf("attempts = %d, want 1", got)
}
})
}
// assertBrowserHeaders checks that common browser-like headers are set on search requests.
func assertBrowserHeaders(t *testing.T, headers http.Header, label string) {
t.Helper()
if headers.Get("User-Agent") == "" {
t.Errorf("User-Agent header should be set%s", label)
}
if headers.Get("Accept") == "" {
t.Errorf("Accept header should be set%s", label)
}
if !strings.Contains(headers.Get("Accept"), "text/html") {
t.Errorf("Accept header should contain text/html%s, got: %s", label, headers.Get("Accept"))
}
if headers.Get("Accept-Language") == "" {
t.Errorf("Accept-Language header should be set%s", label)
}
if headers.Get("Accept-Encoding") == "" {
t.Errorf("Accept-Encoding header should be set%s", label)
}
if headers.Get("Sec-Fetch-Mode") != "navigate" {
t.Errorf("Sec-Fetch-Mode should be navigate%s, got: %s", label, headers.Get("Sec-Fetch-Mode"))
}
}
func TestSearch_BrowserHeaders(t *testing.T) {
t.Parallel()
t.Run("POST request headers", func(t *testing.T) {
t.Parallel()
var capturedHeaders http.Header
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{{Title: "x", URL: "https://x"}},
NumberOfResults: 1,
Query: "test",
}
body := mustMarshalJSON(t, searchResp)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
capturedHeaders = r.Header
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(body) //nolint:errcheck // test fixture write; failure does not affect test outcome
}))
defer server.Close()
cfg := &searxng.Config{SearXNGURL: server.URL, Timeout: 30 * time.Second}
_, err := testPerformSearch(t.Context(), t, cfg, &searxng.SearchArgs{Query: "test"})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
assertBrowserHeaders(t, capturedHeaders, "")
})
t.Run("GET fallback headers", func(t *testing.T) {
t.Parallel()
var capturedHeaders http.Header
searchResp := searxng.SearchResponse{
Results: []searxng.SearchResult{{Title: "x", URL: "https://x"}},
NumberOfResults: 1,
Query: "test",
}
body := mustMarshalJSON(t, searchResp)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method == http.MethodPost {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
capturedHeaders = r.Header
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(body) //nolint:errcheck // test fixture write; failure does not affect test outcome
}))
defer server.Close()
cfg := &searxng.Config{SearXNGURL: server.URL, Timeout: 30 * time.Second, AllowGETFallback: true}
_, err := testPerformSearch(t.Context(), t, cfg, &searxng.SearchArgs{Query: "test"})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
assertBrowserHeaders(t, capturedHeaders, " on GET fallback")
})
}