424 lines
7.5 KiB
Go
424 lines
7.5 KiB
Go
// Copyright (c) 2014 Couchbase, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package search
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestTermFacetResultsMerge(t *testing.T) {
|
|
type testCase struct {
|
|
// Input
|
|
frs1 FacetResults // first facet results
|
|
frs2 FacetResults // second facet results (to be merged into first)
|
|
fixups map[string]int // {facetName:size} (to be applied after merge)
|
|
|
|
// Expected output
|
|
expFrs FacetResults // facet results after merge and fixup
|
|
}
|
|
|
|
tests := []*testCase{
|
|
func() *testCase {
|
|
rv := &testCase{}
|
|
|
|
rv.frs1 = FacetResults{
|
|
"types": &FacetResult{
|
|
Field: "type",
|
|
Total: 100,
|
|
Missing: 25,
|
|
Other: 25,
|
|
Terms: func() *TermFacets {
|
|
tfs := &TermFacets{}
|
|
tfs.Add(
|
|
&TermFacet{
|
|
Term: "blog",
|
|
Count: 25,
|
|
},
|
|
&TermFacet{
|
|
Term: "comment",
|
|
Count: 24,
|
|
},
|
|
&TermFacet{
|
|
Term: "feedback",
|
|
Count: 1,
|
|
},
|
|
)
|
|
return tfs
|
|
}(),
|
|
},
|
|
"categories": &FacetResult{
|
|
Field: "category",
|
|
Total: 97,
|
|
Missing: 22,
|
|
Other: 15,
|
|
Terms: func() *TermFacets {
|
|
tfs := &TermFacets{}
|
|
tfs.Add(
|
|
&TermFacet{
|
|
Term: "clothing",
|
|
Count: 35,
|
|
},
|
|
&TermFacet{
|
|
Term: "electronics",
|
|
Count: 25,
|
|
},
|
|
)
|
|
return tfs
|
|
}(),
|
|
},
|
|
}
|
|
rv.frs2 = FacetResults{
|
|
"types": &FacetResult{
|
|
Field: "type",
|
|
Total: 100,
|
|
Missing: 25,
|
|
Other: 25,
|
|
Terms: func() *TermFacets {
|
|
tfs := &TermFacets{}
|
|
tfs.Add(
|
|
&TermFacet{
|
|
Term: "blog",
|
|
Count: 25,
|
|
},
|
|
&TermFacet{
|
|
Term: "comment",
|
|
Count: 22,
|
|
},
|
|
&TermFacet{
|
|
Term: "flag",
|
|
Count: 3,
|
|
},
|
|
)
|
|
return tfs
|
|
}(),
|
|
},
|
|
}
|
|
rv.fixups = map[string]int{
|
|
"types": 3, // we want top 3 terms based on count
|
|
}
|
|
|
|
rv.expFrs = FacetResults{
|
|
"types": &FacetResult{
|
|
Field: "type",
|
|
Total: 200,
|
|
Missing: 50,
|
|
Other: 51,
|
|
Terms: &TermFacets{
|
|
termFacets: []*TermFacet{
|
|
{
|
|
Term: "blog",
|
|
Count: 50,
|
|
},
|
|
{
|
|
Term: "comment",
|
|
Count: 46,
|
|
},
|
|
{
|
|
Term: "flag",
|
|
Count: 3,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
"categories": rv.frs1["categories"],
|
|
}
|
|
|
|
return rv
|
|
}(),
|
|
func() *testCase {
|
|
rv := &testCase{}
|
|
|
|
rv.frs1 = FacetResults{
|
|
"facetName": &FacetResult{
|
|
Field: "docField",
|
|
Total: 0,
|
|
Missing: 0,
|
|
Other: 0,
|
|
Terms: nil,
|
|
},
|
|
}
|
|
rv.frs2 = FacetResults{
|
|
"facetName": &FacetResult{
|
|
Field: "docField",
|
|
Total: 3,
|
|
Missing: 0,
|
|
Other: 0,
|
|
Terms: &TermFacets{
|
|
termFacets: []*TermFacet{
|
|
{
|
|
Term: "firstTerm",
|
|
Count: 1,
|
|
},
|
|
{
|
|
Term: "secondTerm",
|
|
Count: 2,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
rv.fixups = map[string]int{
|
|
"facetName": 1,
|
|
}
|
|
|
|
rv.expFrs = FacetResults{
|
|
"facetName": &FacetResult{
|
|
Field: "docField",
|
|
Total: 3,
|
|
Missing: 0,
|
|
Other: 1,
|
|
Terms: &TermFacets{
|
|
termFacets: []*TermFacet{
|
|
{
|
|
Term: "secondTerm",
|
|
Count: 2,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
return rv
|
|
}(),
|
|
}
|
|
|
|
for tcIdx, tc := range tests {
|
|
t.Run(fmt.Sprintf("T#%d", tcIdx), func(t *testing.T) {
|
|
tc.frs1.Merge(tc.frs2)
|
|
for facetName, size := range tc.fixups {
|
|
tc.frs1.Fixup(facetName, size)
|
|
}
|
|
|
|
// clear termLookup, so we can compare the facet results
|
|
for _, fr := range tc.frs1 {
|
|
if fr.Terms != nil {
|
|
fr.Terms.termLookup = nil
|
|
}
|
|
}
|
|
|
|
if !reflect.DeepEqual(tc.frs1, tc.expFrs) {
|
|
t.Errorf("expected %v, got %v", tc.expFrs, tc.frs1)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNumericFacetResultsMerge(t *testing.T) {
|
|
|
|
lowmed := 3.0
|
|
medhi := 6.0
|
|
hihigher := 9.0
|
|
|
|
// why second copy? the pointers may be different, but values the same
|
|
lowmed2 := 3.0
|
|
medhi2 := 6.0
|
|
hihigher2 := 9.0
|
|
|
|
fr1 := &FacetResult{
|
|
Field: "rating",
|
|
Total: 100,
|
|
Missing: 25,
|
|
Other: 25,
|
|
NumericRanges: []*NumericRangeFacet{
|
|
{
|
|
Name: "low",
|
|
Max: &lowmed,
|
|
Count: 25,
|
|
},
|
|
{
|
|
Name: "med",
|
|
Count: 24,
|
|
Max: &lowmed,
|
|
Min: &medhi,
|
|
},
|
|
{
|
|
Name: "hi",
|
|
Count: 1,
|
|
Min: &medhi,
|
|
Max: &hihigher,
|
|
},
|
|
},
|
|
}
|
|
frs1 := FacetResults{
|
|
"ratings": fr1,
|
|
}
|
|
|
|
fr2 := &FacetResult{
|
|
Field: "rating",
|
|
Total: 100,
|
|
Missing: 25,
|
|
Other: 25,
|
|
NumericRanges: []*NumericRangeFacet{
|
|
{
|
|
Name: "low",
|
|
Max: &lowmed2,
|
|
Count: 25,
|
|
},
|
|
{
|
|
Name: "med",
|
|
Max: &lowmed2,
|
|
Min: &medhi2,
|
|
Count: 22,
|
|
},
|
|
{
|
|
Name: "highest",
|
|
Min: &hihigher2,
|
|
Count: 3,
|
|
},
|
|
},
|
|
}
|
|
frs2 := FacetResults{
|
|
"ratings": fr2,
|
|
}
|
|
|
|
expectedFr := &FacetResult{
|
|
Field: "rating",
|
|
Total: 200,
|
|
Missing: 50,
|
|
Other: 51,
|
|
NumericRanges: []*NumericRangeFacet{
|
|
{
|
|
Name: "low",
|
|
Count: 50,
|
|
Max: &lowmed,
|
|
},
|
|
{
|
|
Name: "med",
|
|
Max: &lowmed,
|
|
Min: &medhi,
|
|
Count: 46,
|
|
},
|
|
{
|
|
Name: "highest",
|
|
Min: &hihigher,
|
|
Count: 3,
|
|
},
|
|
},
|
|
}
|
|
expectedFrs := FacetResults{
|
|
"ratings": expectedFr,
|
|
}
|
|
|
|
frs1.Merge(frs2)
|
|
frs1.Fixup("ratings", 3)
|
|
if !reflect.DeepEqual(frs1, expectedFrs) {
|
|
t.Errorf("expected %#v, got %#v", expectedFrs, frs1)
|
|
}
|
|
}
|
|
|
|
func TestDateFacetResultsMerge(t *testing.T) {
|
|
|
|
lowmed := "2010-01-01"
|
|
medhi := "2011-01-01"
|
|
hihigher := "2012-01-01"
|
|
|
|
// why second copy? the pointer are to strings done by date time parsing
|
|
// inside the facet generation, so comparing pointers will not work
|
|
lowmed2 := "2010-01-01"
|
|
medhi2 := "2011-01-01"
|
|
hihigher2 := "2012-01-01"
|
|
|
|
fr1 := &FacetResult{
|
|
Field: "birthday",
|
|
Total: 100,
|
|
Missing: 25,
|
|
Other: 25,
|
|
DateRanges: []*DateRangeFacet{
|
|
{
|
|
Name: "low",
|
|
End: &lowmed,
|
|
Count: 25,
|
|
},
|
|
{
|
|
Name: "med",
|
|
Count: 24,
|
|
Start: &lowmed,
|
|
End: &medhi,
|
|
},
|
|
{
|
|
Name: "hi",
|
|
Count: 1,
|
|
Start: &medhi,
|
|
End: &hihigher,
|
|
},
|
|
},
|
|
}
|
|
frs1 := FacetResults{
|
|
"birthdays": fr1,
|
|
}
|
|
|
|
fr2 := &FacetResult{
|
|
Field: "birthday",
|
|
Total: 100,
|
|
Missing: 25,
|
|
Other: 25,
|
|
DateRanges: []*DateRangeFacet{
|
|
{
|
|
Name: "low",
|
|
End: &lowmed2,
|
|
Count: 25,
|
|
},
|
|
{
|
|
Name: "med",
|
|
Start: &lowmed2,
|
|
End: &medhi2,
|
|
Count: 22,
|
|
},
|
|
{
|
|
Name: "highest",
|
|
Start: &hihigher2,
|
|
Count: 3,
|
|
},
|
|
},
|
|
}
|
|
frs2 := FacetResults{
|
|
"birthdays": fr2,
|
|
}
|
|
|
|
expectedFr := &FacetResult{
|
|
Field: "birthday",
|
|
Total: 200,
|
|
Missing: 50,
|
|
Other: 51,
|
|
DateRanges: []*DateRangeFacet{
|
|
{
|
|
Name: "low",
|
|
Count: 50,
|
|
End: &lowmed,
|
|
},
|
|
{
|
|
Name: "med",
|
|
Start: &lowmed,
|
|
End: &medhi,
|
|
Count: 46,
|
|
},
|
|
{
|
|
Name: "highest",
|
|
Start: &hihigher,
|
|
Count: 3,
|
|
},
|
|
},
|
|
}
|
|
expectedFrs := FacetResults{
|
|
"birthdays": expectedFr,
|
|
}
|
|
|
|
frs1.Merge(frs2)
|
|
frs1.Fixup("birthdays", 3)
|
|
if !reflect.DeepEqual(frs1, expectedFrs) {
|
|
t.Errorf("expected %#v, got %#v", expectedFrs, frs1)
|
|
}
|
|
}
|