luzifer/repo-template
1
0
Fork 0
mirror of https://github.com/Luzifer/repo-template.git synced 2024-12-23 12:41:19 +00:00
Code Issues Releases Wiki Activity
repo-template/vendor/google.golang.org/appengine/search/search_test.go

1001 lines
26 KiB
Go
Raw Normal View History

Vendor deps
2018-02-07 09:03:05 +00:00
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package search
import (
"errors"
"fmt"
"reflect"
"strings"
"testing"
"time"
"github.com/golang/protobuf/proto"
"google.golang.org/appengine"
"google.golang.org/appengine/internal/aetesting"
pb "google.golang.org/appengine/internal/search"
)
type TestDoc struct {
String string
Atom Atom
HTML HTML
Float float64
Location appengine.GeoPoint
Time time.Time
}
type FieldListWithMeta struct {
Fields FieldList
Meta *DocumentMetadata
}
func (f *FieldListWithMeta) Load(fields []Field, meta *DocumentMetadata) error {
f.Meta = meta
return f.Fields.Load(fields, nil)
}
func (f *FieldListWithMeta) Save() ([]Field, *DocumentMetadata, error) {
fields, _, err := f.Fields.Save()
return fields, f.Meta, err
}
// Assert that FieldListWithMeta satisfies FieldLoadSaver
var _ FieldLoadSaver = &FieldListWithMeta{}
var (
float = 3.14159
floatOut = "3.14159e+00"
latitude = 37.3894
longitude = 122.0819
testGeo = appengine.GeoPoint{latitude, longitude}
testString = "foo<b>bar"
testTime = time.Unix(1337324400, 0)
testTimeOut = "1337324400000"
searchMeta = &DocumentMetadata{
Rank: 42,
}
searchDoc = TestDoc{
String: testString,
Atom: Atom(testString),
HTML: HTML(testString),
Float: float,
Location: testGeo,
Time: testTime,
}
searchFields = FieldList{
Field{Name: "String", Value: testString},
Field{Name: "Atom", Value: Atom(testString)},
Field{Name: "HTML", Value: HTML(testString)},
Field{Name: "Float", Value: float},
Field{Name: "Location", Value: testGeo},
Field{Name: "Time", Value: testTime},
}
// searchFieldsWithLang is a copy of the searchFields with the Language field
// set on text/HTML Fields.
searchFieldsWithLang = FieldList{}
protoFields = []*pb.Field{
newStringValueField("String", testString, pb.FieldValue_TEXT),
newStringValueField("Atom", testString, pb.FieldValue_ATOM),
newStringValueField("HTML", testString, pb.FieldValue_HTML),
newStringValueField("Float", floatOut, pb.FieldValue_NUMBER),
{
Name: proto.String("Location"),
Value: &pb.FieldValue{
Geo: &pb.FieldValue_Geo{
Lat: proto.Float64(latitude),
Lng: proto.Float64(longitude),
},
Type: pb.FieldValue_GEO.Enum(),
},
},
newStringValueField("Time", testTimeOut, pb.FieldValue_DATE),
}
)
func init() {
for _, f := range searchFields {
if f.Name == "String" || f.Name == "HTML" {
f.Language = "en"
}
searchFieldsWithLang = append(searchFieldsWithLang, f)
}
}
func newStringValueField(name, value string, valueType pb.FieldValue_ContentType) *pb.Field {
return &pb.Field{
Name: proto.String(name),
Value: &pb.FieldValue{
StringValue: proto.String(value),
Type: valueType.Enum(),
},
}
}
func newFacet(name, value string, valueType pb.FacetValue_ContentType) *pb.Facet {
return &pb.Facet{
Name: proto.String(name),
Value: &pb.FacetValue{
StringValue: proto.String(value),
Type: valueType.Enum(),
},
}
}
func TestValidIndexNameOrDocID(t *testing.T) {
testCases := []struct {
s string
want bool
}{
{"", true},
{"!", false},
{"$", true},
{"!bad", false},
{"good!", true},
{"alsoGood", true},
{"has spaces", false},
{"is_inva\xffid_UTF-8", false},
{"is_non-ASCïI", false},
{"underscores_are_ok", true},
}
for _, tc := range testCases {
if got := validIndexNameOrDocID(tc.s); got != tc.want {
t.Errorf("%q: got %v, want %v", tc.s, got, tc.want)
}
}
}
func TestLoadDoc(t *testing.T) {
got, want := TestDoc{}, searchDoc
if err := loadDoc(&got, &pb.Document{Field: protoFields}, nil); err != nil {
t.Fatalf("loadDoc: %v", err)
}
if got != want {
t.Errorf("loadDoc: got %v, wanted %v", got, want)
}
}
func TestSaveDoc(t *testing.T) {
got, err := saveDoc(&searchDoc)
if err != nil {
t.Fatalf("saveDoc: %v", err)
}
want := protoFields
if !reflect.DeepEqual(got.Field, want) {
t.Errorf("\ngot %v\nwant %v", got, want)
}
}
func TestLoadFieldList(t *testing.T) {
var got FieldList
want := searchFieldsWithLang
if err := loadDoc(&got, &pb.Document{Field: protoFields}, nil); err != nil {
t.Fatalf("loadDoc: %v", err)
}
if !reflect.DeepEqual(got, want) {
t.Errorf("\ngot %v\nwant %v", got, want)
}
}
func TestLangFields(t *testing.T) {
fl := &FieldList{
{Name: "Foo", Value: "I am English", Language: "en"},
{Name: "Bar", Value: "私は日本人だ", Language: "jp"},
}
var got FieldList
doc, err := saveDoc(fl)
if err != nil {
t.Fatalf("saveDoc: %v", err)
}
if err := loadDoc(&got, doc, nil); err != nil {
t.Fatalf("loadDoc: %v", err)
}
if want := fl; !reflect.DeepEqual(&got, want) {
t.Errorf("got %v\nwant %v", got, want)
}
}
func TestSaveFieldList(t *testing.T) {
got, err := saveDoc(&searchFields)
if err != nil {
t.Fatalf("saveDoc: %v", err)
}
want := protoFields
if !reflect.DeepEqual(got.Field, want) {
t.Errorf("\ngot %v\nwant %v", got, want)
}
}
func TestLoadFieldAndExprList(t *testing.T) {
var got, want FieldList
for i, f := range searchFieldsWithLang {
f.Derived = (i >= 2) // First 2 elements are "fields", next are "expressions".
want = append(want, f)
}
doc, expr := &pb.Document{Field: protoFields[:2]}, protoFields[2:]
if err := loadDoc(&got, doc, expr); err != nil {
t.Fatalf("loadDoc: %v", err)
}
if !reflect.DeepEqual(got, want) {
t.Errorf("got %v\nwant %v", got, want)
}
}
func TestLoadMeta(t *testing.T) {
var got FieldListWithMeta
want := FieldListWithMeta{
Meta: searchMeta,
Fields: searchFieldsWithLang,
}
doc := &pb.Document{
Field: protoFields,
OrderId: proto.Int32(42),
}
if err := loadDoc(&got, doc, nil); err != nil {
t.Fatalf("loadDoc: %v", err)
}
if !reflect.DeepEqual(got, want) {
t.Errorf("\ngot %v\nwant %v", got, want)
}
}
func TestSaveMeta(t *testing.T) {
got, err := saveDoc(&FieldListWithMeta{
Meta: searchMeta,
Fields: searchFields,
})
if err != nil {
t.Fatalf("saveDoc: %v", err)
}
want := &pb.Document{
Field: protoFields,
OrderId: proto.Int32(42),
}
if !proto.Equal(got, want) {
t.Errorf("\ngot %v\nwant %v", got, want)
}
}
func TestLoadSaveWithStruct(t *testing.T) {
type gopher struct {
Name string
Info string `search:"about"`
Legs float64 `search:",facet"`
Fuzz Atom `search:"Fur,facet"`
}
doc := gopher{"Gopher", "Likes slide rules.", 4, Atom("furry")}
pb := &pb.Document{
Field: []*pb.Field{
newStringValueField("Name", "Gopher", pb.FieldValue_TEXT),
newStringValueField("about", "Likes slide rules.", pb.FieldValue_TEXT),
},
Facet: []*pb.Facet{
newFacet("Legs", "4e+00", pb.FacetValue_NUMBER),
newFacet("Fur", "furry", pb.FacetValue_ATOM),
},
}
var gotDoc gopher
if err := loadDoc(&gotDoc, pb, nil); err != nil {
t.Fatalf("loadDoc: %v", err)
}
if !reflect.DeepEqual(gotDoc, doc) {
t.Errorf("loading doc\ngot %v\nwant %v", gotDoc, doc)
}
gotPB, err := saveDoc(&doc)
if err != nil {
t.Fatalf("saveDoc: %v", err)
}
gotPB.OrderId = nil // Don't test: it's time dependent.
if !proto.Equal(gotPB, pb) {
t.Errorf("saving doc\ngot %v\nwant %v", gotPB, pb)
}
}
func TestValidFieldNames(t *testing.T) {
testCases := []struct {
name string
valid bool
}{
{"Normal", true},
{"Also_OK_123", true},
{"Not so great", false},
{"lower_case", true},
{"Exclaim!", false},
{"Hello세상아 안녕", false},
{"", false},
{"Hεllo", false},
{strings.Repeat("A", 500), true},
{strings.Repeat("A", 501), false},
}
for _, tc := range testCases {
_, err := saveDoc(&FieldList{
Field{Name: tc.name, Value: "val"},
})
if err != nil && !strings.Contains(err.Error(), "invalid field name") {
t.Errorf("unexpected err %q for field name %q", err, tc.name)
}
if (err == nil) != tc.valid {
t.Errorf("field %q: expected valid %t, received err %v", tc.name, tc.valid, err)
}
}
}
func TestValidLangs(t *testing.T) {
testCases := []struct {
field Field
valid bool
}{
{Field{Name: "Foo", Value: "String", Language: ""}, true},
{Field{Name: "Foo", Value: "String", Language: "en"}, true},
{Field{Name: "Foo", Value: "String", Language: "aussie"}, false},
{Field{Name: "Foo", Value: "String", Language: "12"}, false},
{Field{Name: "Foo", Value: HTML("String"), Language: "en"}, true},
{Field{Name: "Foo", Value: Atom("String"), Language: "en"}, false},
{Field{Name: "Foo", Value: 42, Language: "en"}, false},
}
for _, tt := range testCases {
_, err := saveDoc(&FieldList{tt.field})
if err == nil != tt.valid {
t.Errorf("Field %v, got error %v, wanted valid %t", tt.field, err, tt.valid)
}
}
}
func TestDuplicateFields(t *testing.T) {
testCases := []struct {
desc string
fields FieldList
errMsg string // Non-empty if we expect an error
}{
{
desc: "multi string",
fields: FieldList{{Name: "FieldA", Value: "val1"}, {Name: "FieldA", Value: "val2"}, {Name: "FieldA", Value: "val3"}},
},
{
desc: "multi atom",
fields: FieldList{{Name: "FieldA", Value: Atom("val1")}, {Name: "FieldA", Value: Atom("val2")}, {Name: "FieldA", Value: Atom("val3")}},
},
{
desc: "mixed",
fields: FieldList{{Name: "FieldA", Value: testString}, {Name: "FieldA", Value: testTime}, {Name: "FieldA", Value: float}},
},
{
desc: "multi time",
fields: FieldList{{Name: "FieldA", Value: testTime}, {Name: "FieldA", Value: testTime}},
errMsg: `duplicate time field "FieldA"`,
},
{
desc: "multi num",
fields: FieldList{{Name: "FieldA", Value: float}, {Name: "FieldA", Value: float}},
errMsg: `duplicate numeric field "FieldA"`,
},
}
for _, tc := range testCases {
_, err := saveDoc(&tc.fields)
if (err == nil) != (tc.errMsg == "") || (err != nil && !strings.Contains(err.Error(), tc.errMsg)) {
t.Errorf("%s: got err %v, wanted %q", tc.desc, err, tc.errMsg)
}
}
}
func TestLoadErrFieldMismatch(t *testing.T) {
testCases := []struct {
desc string
dst interface{}
src []*pb.Field
err error
}{
{
desc: "missing",
dst: &struct{ One string }{},
src: []*pb.Field{newStringValueField("Two", "woop!", pb.FieldValue_TEXT)},
err: &ErrFieldMismatch{
FieldName: "Two",
Reason: "no such struct field",
},
},
{
desc: "wrong type",
dst: &struct{ Num float64 }{},
src: []*pb.Field{newStringValueField("Num", "woop!", pb.FieldValue_TEXT)},
err: &ErrFieldMismatch{
FieldName: "Num",
Reason: "type mismatch: float64 for string data",
},
},
{
desc: "unsettable",
dst: &struct{ lower string }{},
src: []*pb.Field{newStringValueField("lower", "woop!", pb.FieldValue_TEXT)},
err: &ErrFieldMismatch{
FieldName: "lower",
Reason: "cannot set struct field",
},
},
}
for _, tc := range testCases {
err := loadDoc(tc.dst, &pb.Document{Field: tc.src}, nil)
if !reflect.DeepEqual(err, tc.err) {
t.Errorf("%s, got err %v, wanted %v", tc.desc, err, tc.err)
}
}
}
func TestLimit(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
c := aetesting.FakeSingleContext(t, "search", "Search", func(req *pb.SearchRequest, res *pb.SearchResponse) error {
limit := 20 // Default per page.
if req.Params.Limit != nil {
limit = int(*req.Params.Limit)
}
res.Status = &pb.RequestStatus{Code: pb.SearchServiceError_OK.Enum()}
res.MatchedCount = proto.Int64(int64(limit))
for i := 0; i < limit; i++ {
res.Result = append(res.Result, &pb.SearchResult{Document: &pb.Document{}})
res.Cursor = proto.String("moreresults")
}
return nil
})
const maxDocs = 500 // Limit maximum number of docs.
testCases := []struct {
limit, want int
}{
{limit: 0, want: maxDocs},
{limit: 42, want: 42},
{limit: 100, want: 100},
{limit: 1000, want: maxDocs},
}
for _, tt := range testCases {
it := index.Search(c, "gopher", &SearchOptions{Limit: tt.limit, IDsOnly: true})
count := 0
for ; count < maxDocs; count++ {
_, err := it.Next(nil)
if err == Done {
break
}
if err != nil {
t.Fatalf("err after %d: %v", count, err)
}
}
if count != tt.want {
t.Errorf("got %d results, expected %d", count, tt.want)
}
}
}
func TestPut(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
c := aetesting.FakeSingleContext(t, "search", "IndexDocument", func(in *pb.IndexDocumentRequest, out *pb.IndexDocumentResponse) error {
expectedIn := &pb.IndexDocumentRequest{
Params: &pb.IndexDocumentParams{
Document: []*pb.Document{
{Field: protoFields, OrderId: proto.Int32(42)},
},
IndexSpec: &pb.IndexSpec{
Name: proto.String("Doc"),
},
},
}
if !proto.Equal(in, expectedIn) {
return fmt.Errorf("unsupported argument:\ngot %v\nwant %v", in, expectedIn)
}
*out = pb.IndexDocumentResponse{
Status: []*pb.RequestStatus{
{Code: pb.SearchServiceError_OK.Enum()},
},
DocId: []string{
"doc_id",
},
}
return nil
})
id, err := index.Put(c, "", &FieldListWithMeta{
Meta: searchMeta,
Fields: searchFields,
})
if err != nil {
t.Fatal(err)
}
if want := "doc_id"; id != want {
t.Errorf("Got doc ID %q, want %q", id, want)
}
}
func TestPutAutoOrderID(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
c := aetesting.FakeSingleContext(t, "search", "IndexDocument", func(in *pb.IndexDocumentRequest, out *pb.IndexDocumentResponse) error {
if len(in.Params.GetDocument()) < 1 {
return fmt.Errorf("expected at least one Document, got %v", in)
}
got, want := in.Params.Document[0].GetOrderId(), int32(time.Since(orderIDEpoch).Seconds())
if d := got - want; -5 > d || d > 5 {
return fmt.Errorf("got OrderId %d, want near %d", got, want)
}
*out = pb.IndexDocumentResponse{
Status: []*pb.RequestStatus{
{Code: pb.SearchServiceError_OK.Enum()},
},
DocId: []string{
"doc_id",
},
}
return nil
})
if _, err := index.Put(c, "", &searchFields); err != nil {
t.Fatal(err)
}
}
func TestPutBadStatus(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
c := aetesting.FakeSingleContext(t, "search", "IndexDocument", func(_ *pb.IndexDocumentRequest, out *pb.IndexDocumentResponse) error {
*out = pb.IndexDocumentResponse{
Status: []*pb.RequestStatus{
{
Code: pb.SearchServiceError_INVALID_REQUEST.Enum(),
ErrorDetail: proto.String("insufficient gophers"),
},
},
}
return nil
})
wantErr := "search: INVALID_REQUEST: insufficient gophers"
if _, err := index.Put(c, "", &searchFields); err == nil || err.Error() != wantErr {
t.Fatalf("Put: got %v error, want %q", err, wantErr)
}
}
func TestSortOptions(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
noErr := errors.New("") // Sentinel err to return to prevent sending request.
testCases := []struct {
desc string
sort *SortOptions
wantSort []*pb.SortSpec
wantScorer *pb.ScorerSpec
wantErr string
}{
{
desc: "No SortOptions",
},
{
desc: "Basic",
sort: &SortOptions{
Expressions: []SortExpression{
{Expr: "dog"},
{Expr: "cat", Reverse: true},
{Expr: "gopher", Default: "blue"},
{Expr: "fish", Default: 2.0},
},
Limit: 42,
Scorer: MatchScorer,
},
wantSort: []*pb.SortSpec{
{SortExpression: proto.String("dog")},
{SortExpression: proto.String("cat"), SortDescending: proto.Bool(false)},
{SortExpression: proto.String("gopher"), DefaultValueText: proto.String("blue")},
{SortExpression: proto.String("fish"), DefaultValueNumeric: proto.Float64(2)},
},
wantScorer: &pb.ScorerSpec{
Limit: proto.Int32(42),
Scorer: pb.ScorerSpec_MATCH_SCORER.Enum(),
},
},
{
desc: "Bad expression default",
sort: &SortOptions{
Expressions: []SortExpression{
{Expr: "dog", Default: true},
},
},
wantErr: `search: invalid Default type bool for expression "dog"`,
},
{
desc: "RescoringMatchScorer",
sort: &SortOptions{Scorer: RescoringMatchScorer},
wantScorer: &pb.ScorerSpec{Scorer: pb.ScorerSpec_RESCORING_MATCH_SCORER.Enum()},
},
}
for _, tt := range testCases {
c := aetesting.FakeSingleContext(t, "search", "Search", func(req *pb.SearchRequest, _ *pb.SearchResponse) error {
params := req.Params
if !reflect.DeepEqual(params.SortSpec, tt.wantSort) {
t.Errorf("%s: params.SortSpec=%v; want %v", tt.desc, params.SortSpec, tt.wantSort)
}
if !reflect.DeepEqual(params.ScorerSpec, tt.wantScorer) {
t.Errorf("%s: params.ScorerSpec=%v; want %v", tt.desc, params.ScorerSpec, tt.wantScorer)
}
return noErr // Always return some error to prevent response parsing.
})
it := index.Search(c, "gopher", &SearchOptions{Sort: tt.sort})
_, err := it.Next(nil)
if err == nil {
t.Fatalf("%s: err==nil; should not happen", tt.desc)
}
if err.Error() != tt.wantErr {
t.Errorf("%s: got error %q, want %q", tt.desc, err, tt.wantErr)
}
}
}
func TestFieldSpec(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
errFoo := errors.New("foo") // sentinel error when there isn't one.
testCases := []struct {
desc string
opts *SearchOptions
want *pb.FieldSpec
}{
{
desc: "No options",
want: &pb.FieldSpec{},
},
{
desc: "Fields",
opts: &SearchOptions{
Fields: []string{"one", "two"},
},
want: &pb.FieldSpec{
Name: []string{"one", "two"},
},
},
{
desc: "Expressions",
opts: &SearchOptions{
Expressions: []FieldExpression{
{Name: "one", Expr: "price * quantity"},
{Name: "two", Expr: "min(daily_use, 10) * rate"},
},
},
want: &pb.FieldSpec{
Expression: []*pb.FieldSpec_Expression{
{Name: proto.String("one"), Expression: proto.String("price * quantity")},
{Name: proto.String("two"), Expression: proto.String("min(daily_use, 10) * rate")},
},
},
},
}
for _, tt := range testCases {
c := aetesting.FakeSingleContext(t, "search", "Search", func(req *pb.SearchRequest, _ *pb.SearchResponse) error {
params := req.Params
if !reflect.DeepEqual(params.FieldSpec, tt.want) {
t.Errorf("%s: params.FieldSpec=%v; want %v", tt.desc, params.FieldSpec, tt.want)
}
return errFoo // Always return some error to prevent response parsing.
})
it := index.Search(c, "gopher", tt.opts)
if _, err := it.Next(nil); err != errFoo {
t.Fatalf("%s: got error %v; want %v", tt.desc, err, errFoo)
}
}
}
func TestBasicSearchOpts(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
noErr := errors.New("") // Sentinel err to return to prevent sending request.
testCases := []struct {
desc string
facetOpts []FacetSearchOption
cursor Cursor
offset int
countAccuracy int
want *pb.SearchParams
wantErr string
}{
{
desc: "No options",
want: &pb.SearchParams{},
},
{
desc: "Default auto discovery",
facetOpts: []FacetSearchOption{
AutoFacetDiscovery(0, 0),
},
want: &pb.SearchParams{
AutoDiscoverFacetCount: proto.Int32(10),
},
},
{
desc: "Auto discovery",
facetOpts: []FacetSearchOption{
AutoFacetDiscovery(7, 12),
},
want: &pb.SearchParams{
AutoDiscoverFacetCount: proto.Int32(7),
FacetAutoDetectParam: &pb.FacetAutoDetectParam{
ValueLimit: proto.Int32(12),
},
},
},
{
desc: "Param Depth",
facetOpts: []FacetSearchOption{
AutoFacetDiscovery(7, 12),
},
want: &pb.SearchParams{
AutoDiscoverFacetCount: proto.Int32(7),
FacetAutoDetectParam: &pb.FacetAutoDetectParam{
ValueLimit: proto.Int32(12),
},
},
},
{
desc: "Doc depth",
facetOpts: []FacetSearchOption{
FacetDocumentDepth(123),
},
want: &pb.SearchParams{
FacetDepth: proto.Int32(123),
},
},
{
desc: "Facet discovery",
facetOpts: []FacetSearchOption{
FacetDiscovery("colour"),
FacetDiscovery("size", Atom("M"), Atom("L")),
FacetDiscovery("price", LessThan(7), Range{7, 14}, AtLeast(14)),
},
want: &pb.SearchParams{
IncludeFacet: []*pb.FacetRequest{
{Name: proto.String("colour")},
{Name: proto.String("size"), Params: &pb.FacetRequestParam{
ValueConstraint: []string{"M", "L"},
}},
{Name: proto.String("price"), Params: &pb.FacetRequestParam{
Range: []*pb.FacetRange{
{End: proto.String("7e+00")},
{Start: proto.String("7e+00"), End: proto.String("1.4e+01")},
{Start: proto.String("1.4e+01")},
},
}},
},
},
},
{
desc: "Facet discovery - bad value",
facetOpts: []FacetSearchOption{
FacetDiscovery("colour", true),
},
wantErr: "bad FacetSearchOption: unsupported value type bool",
},
{
desc: "Facet discovery - mix value types",
facetOpts: []FacetSearchOption{
FacetDiscovery("colour", Atom("blue"), AtLeast(7)),
},
wantErr: "bad FacetSearchOption: values must all be Atom, or must all be Range",
},
{
desc: "Facet discovery - invalid range",
facetOpts: []FacetSearchOption{
FacetDiscovery("colour", Range{negInf, posInf}),
},
wantErr: "bad FacetSearchOption: invalid range: either Start or End must be finite",
},
{
desc: "Cursor",
cursor: Cursor("mycursor"),
want: &pb.SearchParams{
Cursor: proto.String("mycursor"),
},
},
{
desc: "Offset",
offset: 121,
want: &pb.SearchParams{
Offset: proto.Int32(121),
},
},
{
desc: "Cursor and Offset set",
cursor: Cursor("mycursor"),
offset: 121,
wantErr: "at most one of Cursor and Offset may be specified",
},
{
desc: "Count accuracy",
countAccuracy: 100,
want: &pb.SearchParams{
MatchedCountAccuracy: proto.Int32(100),
},
},
}
for _, tt := range testCases {
c := aetesting.FakeSingleContext(t, "search", "Search", func(req *pb.SearchRequest, _ *pb.SearchResponse) error {
if tt.want == nil {
t.Errorf("%s: expected call to fail", tt.desc)
return nil
}
// Set default fields.
tt.want.Query = proto.String("gopher")
tt.want.IndexSpec = &pb.IndexSpec{Name: proto.String("Doc")}
tt.want.CursorType = pb.SearchParams_PER_RESULT.Enum()
tt.want.FieldSpec = &pb.FieldSpec{}
if got := req.Params; !reflect.DeepEqual(got, tt.want) {
t.Errorf("%s: params=%v; want %v", tt.desc, got, tt.want)
}
return noErr // Always return some error to prevent response parsing.
})
it := index.Search(c, "gopher", &SearchOptions{
Facets: tt.facetOpts,
Cursor: tt.cursor,
Offset: tt.offset,
CountAccuracy: tt.countAccuracy,
})
_, err := it.Next(nil)
if err == nil {
t.Fatalf("%s: err==nil; should not happen", tt.desc)
}
if err.Error() != tt.wantErr {
t.Errorf("%s: got error %q, want %q", tt.desc, err, tt.wantErr)
}
}
}
func TestFacetRefinements(t *testing.T) {
index, err := Open("Doc")
if err != nil {
t.Fatalf("err from Open: %v", err)
}
noErr := errors.New("") // Sentinel err to return to prevent sending request.
testCases := []struct {
desc string
refine []Facet
want []*pb.FacetRefinement
wantErr string
}{
{
desc: "No refinements",
},
{
desc: "Basic",
refine: []Facet{
{Name: "fur", Value: Atom("fluffy")},
{Name: "age", Value: LessThan(123)},
{Name: "age", Value: AtLeast(0)},
{Name: "legs", Value: Range{Start: 3, End: 5}},
},
want: []*pb.FacetRefinement{
{Name: proto.String("fur"), Value: proto.String("fluffy")},
{Name: proto.String("age"), Range: &pb.FacetRefinement_Range{End: proto.String("1.23e+02")}},
{Name: proto.String("age"), Range: &pb.FacetRefinement_Range{Start: proto.String("0e+00")}},
{Name: proto.String("legs"), Range: &pb.FacetRefinement_Range{Start: proto.String("3e+00"), End: proto.String("5e+00")}},
},
},
{
desc: "Infinite range",
refine: []Facet{
{Name: "age", Value: Range{Start: negInf, End: posInf}},
},
wantErr: `search: refinement for facet "age": either Start or End must be finite`,
},
{
desc: "Bad End value in range",
refine: []Facet{
{Name: "age", Value: LessThan(2147483648)},
},
wantErr: `search: refinement for facet "age": invalid value for End`,
},
{
desc: "Bad Start value in range",
refine: []Facet{
{Name: "age", Value: AtLeast(-2147483649)},
},
wantErr: `search: refinement for facet "age": invalid value for Start`,
},
{
desc: "Unknown value type",
refine: []Facet{
{Name: "age", Value: "you can't use strings!"},
},
wantErr: `search: unsupported refinement for facet "age" of type string`,
},
}
for _, tt := range testCases {
c := aetesting.FakeSingleContext(t, "search", "Search", func(req *pb.SearchRequest, _ *pb.SearchResponse) error {
if got := req.Params.FacetRefinement; !reflect.DeepEqual(got, tt.want) {
t.Errorf("%s: params.FacetRefinement=%v; want %v", tt.desc, got, tt.want)
}
return noErr // Always return some error to prevent response parsing.
})
it := index.Search(c, "gopher", &SearchOptions{Refinements: tt.refine})
_, err := it.Next(nil)
if err == nil {
t.Fatalf("%s: err==nil; should not happen", tt.desc)
}
if err.Error() != tt.wantErr {
t.Errorf("%s: got error %q, want %q", tt.desc, err, tt.wantErr)
}
}
}
func TestNamespaceResetting(t *testing.T) {
namec := make(chan *string, 1)
c0 := aetesting.FakeSingleContext(t, "search", "IndexDocument", func(req *pb.IndexDocumentRequest, res *pb.IndexDocumentResponse) error {
namec <- req.Params.IndexSpec.Namespace
return fmt.Errorf("RPC error")
})
// Check that wrapping c0 in a namespace twice works correctly.
c1, err := appengine.Namespace(c0, "A")
if err != nil {
t.Fatalf("appengine.Namespace: %v", err)
}
c2, err := appengine.Namespace(c1, "") // should act as the original context
if err != nil {
t.Fatalf("appengine.Namespace: %v", err)
}
i := (&Index{})
i.Put(c0, "something", &searchDoc)
if ns := <-namec; ns != nil {
t.Errorf(`Put with c0: ns = %q, want nil`, *ns)
}
i.Put(c1, "something", &searchDoc)
if ns := <-namec; ns == nil {
t.Error(`Put with c1: ns = nil, want "A"`)
} else if *ns != "A" {
t.Errorf(`Put with c1: ns = %q, want "A"`, *ns)
}
i.Put(c2, "something", &searchDoc)
if ns := <-namec; ns != nil {
t.Errorf(`Put with c2: ns = %q, want nil`, *ns)
}
}
Reference in a new issue Copy permalink