231 lines
7.6 KiB
Go
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)
|
|
}
|
|
}
|