231 lines
7.6 KiB
Go

package queryserving
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"os"
"reflect"
"strings"
"testing"
"time"
)
func TestQueryServingGramsPreserveSubstringCandidates(t *testing.T) {
for _, text := range []string{"FYLX_B07_AZER764008K_20260927_074440/part0002", "İ中文😀_左右/part", "a.b+?x[1]", "abc def ghi"} {
r := []rune(text)
indexed := map[string]bool{}
for _, g := range IndexGrams(text) {
indexed[g] = true
}
for a := range r {
for z := a + 1; z <= len(r); z++ {
for _, g := range Grams(string(r[a:z])) {
if !indexed[g] {
t.Fatalf("substring lost %q in %q", r[a:z], text)
}
}
}
}
}
if reflect.DeepEqual(Key("namespace-a", "org", []string{"p"}), Key("namespace-b", "org", []string{"p"})) {
t.Fatal("namespace collision")
}
}
func TestQueryServingTypesenseIncompleteImportAndExportFailClosed(t *testing.T) {
mode := "partial"
secret := "synthetic-secret-only"
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("X-TYPESENSE-API-KEY") != secret {
t.Error("missing backend authentication")
}
switch mode {
case "partial":
_, _ = w.Write([]byte("{\"success\":true}\n{\"success\":false,\"error\":\"" + secret + "\"}\n"))
case "short":
_, _ = w.Write([]byte("{\"success\":true}\n"))
case "malformed":
_, _ = w.Write([]byte("{\"item_id\":\"one\"}\n{bad"))
case "failure":
w.WriteHeader(503)
_, _ = w.Write([]byte(secret))
case "ok":
_, _ = w.Write([]byte("{\"item_id\":\"one\"}\n{\"item_id\":\"two\"}\n"))
}
}))
defer server.Close()
client, _ := NewTypesense(server.URL, secret)
docs := []SearchDocument{{ID: "one"}, {ID: "two"}}
for _, m := range []string{"partial", "short"} {
mode = m
if err := client.Import(t.Context(), "dfq_test", docs); err == nil || strings.Contains(err.Error(), secret) {
t.Fatal("partial import accepted or secret leaked", err)
}
}
for _, m := range []string{"malformed", "failure"} {
mode = m
if ids, err := client.Candidates(t.Context(), "dfq_test", "_x/"); err == nil || ids != nil || strings.Contains(err.Error(), secret) {
t.Fatal("incomplete export accepted or secret leaked", ids, err)
}
}
mode = "ok"
if ids, err := client.Candidates(t.Context(), "dfq_test", "part"); err != nil || !reflect.DeepEqual(ids, []string{"one", "two"}) {
t.Fatal(ids, err)
}
}
func TestQueryServingValkeyRealIsolationCorruptionAndColdRecoveryLocal(t *testing.T) {
if os.Getenv("QUERY_SERVING_LOCAL_TEST") != "1" {
t.Skip("isolated loopback query dependencies")
}
namespace := t.Name() + time.Now().Format(time.RFC3339Nano)
a, err := NewValkey("valkey://127.0.0.1:16379", namespace)
if err != nil {
t.Fatal(err)
}
defer a.Close()
b, err := NewValkey("valkey://127.0.0.1:16379", namespace)
if err != nil {
t.Fatal(err)
}
defer b.Close()
foreign, err := NewValkey("valkey://127.0.0.1:16379", namespace+"-foreign")
if err != nil {
t.Fatal(err)
}
defer foreign.Close()
a.Put(t.Context(), "generation-one", []byte(`{"value":42}`), time.Second)
if data, ok := b.Get(t.Context(), "generation-one"); !ok || string(data) != `{"value":42}` {
t.Fatal("cross-instance cache missed")
}
if _, ok := foreign.Get(t.Context(), "generation-one"); ok {
t.Fatal("foreign namespace read cache")
}
if err = a.client.Do(t.Context(), a.client.B().Set().Key(a.prefix+":generation-one").Value(`{}`).Build()).Error(); err != nil {
t.Fatal(err)
}
if _, ok := b.Get(t.Context(), "generation-one"); ok {
t.Fatal("corrupt valid JSON treated as a valid cache value")
}
managed, err := NewManagedValkey("valkey://127.0.0.1:16379", namespace)
if err != nil {
t.Fatal(err)
}
defer managed.Close()
deadline := time.Now().Add(2 * time.Second)
for !managed.Ready() && time.Now().Before(deadline) {
time.Sleep(10 * time.Millisecond)
}
if !managed.Ready() {
t.Fatal("managed cache did not connect")
}
ctx, cancel := context.WithCancel(t.Context())
cancel()
if _, ok := managed.Get(ctx, "generation-one"); ok {
t.Fatal("cancelled cache read succeeded")
}
managed.Put(t.Context(), "different-query", []byte("[]"), time.Second)
data, ok := managed.Get(t.Context(), "different-query")
if !ok {
t.Fatal("managed cache did not warm")
}
var value []string
if json.Unmarshal(data, &value) != nil {
t.Fatal("cache payload changed")
}
}
func TestQueryServingValkeyActiveQueryRegistryLocal(t *testing.T) {
if os.Getenv("QUERY_SERVING_LOCAL_TEST") != "1" {
t.Skip("isolated Valkey only")
}
namespace := fmt.Sprintf("registry-%d", time.Now().UnixNano())
one, e := NewValkey("valkey://127.0.0.1:16379", namespace)
if e != nil {
t.Fatal(e)
}
defer one.Close()
two, e := NewValkey("valkey://127.0.0.1:16379", namespace)
if e != nil {
t.Fatal(e)
}
defer two.Close()
foreign, e := NewValkey("valkey://127.0.0.1:16379", namespace+"-foreign")
if e != nil {
t.Fatal(e)
}
defer foreign.Close()
ctx := t.Context()
scope := "scope"
order, data := one.registryKeys(scope)
defer one.client.Do(context.Background(), one.client.B().Del().Key(order, data).Build())
one.RememberQuery(ctx, scope, "one", []byte("query-one"))
if got := two.RecentQueries(ctx, scope); len(got) != 1 || string(got[0]) != "query-one" {
t.Fatal("registry not shared", got)
}
if len(foreign.RecentQueries(ctx, scope)) != 0 || len(two.RecentQueries(ctx, "other-scope")) != 0 {
t.Fatal("registry crossed namespace/scope")
}
for i := 0; i < 270; i++ {
one.RememberQuery(ctx, scope, fmt.Sprintf("q-%03d", i), []byte("query"))
}
if got := two.RecentQueries(ctx, scope); len(got) != 256 {
t.Fatal("registry retention not bounded", len(got), one.Errors.Load())
}
// A syntactically valid JSON value without its key-bound integrity frame is
// not allowed to become a registered precomputation.
if e = one.client.Do(ctx, one.client.B().Hset().Key(data).FieldValue().FieldValue("bad", "{}").Build()).Error(); e != nil {
t.Fatal(e)
}
if e = one.client.Do(ctx, one.client.B().Zadd().Key(order).ScoreMember().ScoreMember(float64(time.Now().Unix()), "bad").Build()).Error(); e != nil {
t.Fatal(e)
}
for _, value := range two.RecentQueries(ctx, scope) {
if string(value) == "{}" {
t.Fatal("corrupt registry value accepted")
}
}
cancelled, stop := context.WithCancel(ctx)
stop()
before := one.Errors.Load()
one.RememberQuery(cancelled, scope, "cancelled", []byte("x"))
_ = one.RecentQueries(cancelled, scope)
if one.Errors.Load() != before {
t.Fatal("caller cancellation tripped registry breaker")
}
}
func TestQueryServingLongSearchKeepsConservativeOperatorBudget(t *testing.T) {
text := "synthetic-available-load-project-a-load-supplier-a-prepackage_acceptance-0"
grams := candidateGrams(text, "another-long-capture/part0001")
if len(grams) > 40 || len(grams) == 0 {
t.Fatal("filter operation budget", len(grams))
}
full := map[string]bool{}
for _, g := range IndexGrams(text + " another-long-capture/part0001") {
full[g] = true
}
for _, g := range grams {
if !full[g] {
t.Fatal("selected constraint can lose a true result")
}
}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if count := strings.Count(r.URL.Query().Get("filter_by"), "grams:="); count > 40 {
t.Error("long query rejected by server budget", count)
w.WriteHeader(400)
return
}
_, _ = w.Write([]byte("{\"item_id\":\"expected\"}\n"))
}))
defer server.Close()
client, _ := NewTypesense(server.URL, "synthetic")
ids, e := client.Candidates(t.Context(), "dfq_budget", text, "another-long-capture/part0001")
if e != nil || !reflect.DeepEqual(ids, []string{"expected"}) {
t.Fatal("long search response", ids, e)
}
}