Debian Codegraph @

search_aggs_bucket_significant_terms_test.go

raw
1 // Copyright 2012-present Oliver Eilhard. All rights reserved.
2 // Use of this source code is governed by a MIT-license.
3 // See http://olivere.mit-license.org/license.txt for details.
4
5 package elastic
6
7 import (
8 "encoding/json"
9 "testing"
10 )
11
12 func TestSignificantTermsAggregation(t *testing.T) {
13 agg := NewSignificantTermsAggregation().Field("crime_type")
14 src, err := agg.Source()
15 if err != nil {
16 t.Fatal(err)
17 }
18 data, err := json.Marshal(src)
19 if err != nil {
20 t.Fatalf("marshaling to JSON failed: %v", err)
21 }
22 got := string(data)
23 expected := `{"significant_terms":{"field":"crime_type"}}`
24 if got != expected {
25 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
26 }
27 }
28
29 func TestSignificantTermsAggregationWithArgs(t *testing.T) {
30 agg := NewSignificantTermsAggregation().
31 Field("crime_type").
32 ExecutionHint("map").
33 ShardSize(5).
34 MinDocCount(10).
35 BackgroundFilter(NewTermQuery("city", "London"))
36 src, err := agg.Source()
37 if err != nil {
38 t.Fatal(err)
39 }
40 data, err := json.Marshal(src)
41 if err != nil {
42 t.Fatalf("marshaling to JSON failed: %v", err)
43 }
44 got := string(data)
45 expected := `{"significant_terms":{"background_filter":{"term":{"city":"London"}},"execution_hint":"map","field":"crime_type","min_doc_count":10,"shard_size":5}}`
46 if got != expected {
47 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
48 }
49 }
50
51 func TestSignificantTermsAggregationSubAggregation(t *testing.T) {
52 crimeTypesAgg := NewSignificantTermsAggregation().Field("crime_type")
53 agg := NewTermsAggregation().Field("force")
54 agg = agg.SubAggregation("significantCrimeTypes", crimeTypesAgg)
55 src, err := agg.Source()
56 if err != nil {
57 t.Fatal(err)
58 }
59 data, err := json.Marshal(src)
60 if err != nil {
61 t.Fatalf("marshaling to JSON failed: %v", err)
62 }
63 got := string(data)
64 expected := `{"aggregations":{"significantCrimeTypes":{"significant_terms":{"field":"crime_type"}}},"terms":{"field":"force"}}`
65 if got != expected {
66 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
67 }
68 }
69
70 func TestSignificantTermsAggregationWithMetaData(t *testing.T) {
71 agg := NewSignificantTermsAggregation().Field("crime_type")
72 agg = agg.Meta(map[string]interface{}{"name": "Oliver"})
73 src, err := agg.Source()
74 if err != nil {
75 t.Fatal(err)
76 }
77 data, err := json.Marshal(src)
78 if err != nil {
79 t.Fatalf("marshaling to JSON failed: %v", err)
80 }
81 got := string(data)
82 expected := `{"meta":{"name":"Oliver"},"significant_terms":{"field":"crime_type"}}`
83 if got != expected {
84 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
85 }
86 }
87
88 func TestSignificantTermsAggregationWithChiSquare(t *testing.T) {
89 agg := NewSignificantTermsAggregation().Field("crime_type")
90 agg = agg.SignificanceHeuristic(
91 NewChiSquareSignificanceHeuristic().
92 BackgroundIsSuperset(true).
93 IncludeNegatives(false),
94 )
95 src, err := agg.Source()
96 if err != nil {
97 t.Fatal(err)
98 }
99 data, err := json.Marshal(src)
100 if err != nil {
101 t.Fatalf("marshaling to JSON failed: %v", err)
102 }
103 got := string(data)
104 expected := `{"significant_terms":{"chi_square":{"background_is_superset":true,"include_negatives":false},"field":"crime_type"}}`
105 if got != expected {
106 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
107 }
108 }
109
110 func TestSignificantTermsAggregationWithGND(t *testing.T) {
111 agg := NewSignificantTermsAggregation().Field("crime_type")
112 agg = agg.SignificanceHeuristic(
113 NewGNDSignificanceHeuristic(),
114 )
115 src, err := agg.Source()
116 if err != nil {
117 t.Fatal(err)
118 }
119 data, err := json.Marshal(src)
120 if err != nil {
121 t.Fatalf("marshaling to JSON failed: %v", err)
122 }
123 got := string(data)
124 expected := `{"significant_terms":{"field":"crime_type","gnd":{}}}`
125 if got != expected {
126 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
127 }
128 }
129
130 func TestSignificantTermsAggregationWithJLH(t *testing.T) {
131 agg := NewSignificantTermsAggregation().Field("crime_type")
132 agg = agg.SignificanceHeuristic(
133 NewJLHScoreSignificanceHeuristic(),
134 )
135 src, err := agg.Source()
136 if err != nil {
137 t.Fatal(err)
138 }
139 data, err := json.Marshal(src)
140 if err != nil {
141 t.Fatalf("marshaling to JSON failed: %v", err)
142 }
143 got := string(data)
144 expected := `{"significant_terms":{"field":"crime_type","jlh":{}}}`
145 if got != expected {
146 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
147 }
148 }
149
150 func TestSignificantTermsAggregationWithMutualInformation(t *testing.T) {
151 agg := NewSignificantTermsAggregation().Field("crime_type")
152 agg = agg.SignificanceHeuristic(
153 NewMutualInformationSignificanceHeuristic().
154 BackgroundIsSuperset(false).
155 IncludeNegatives(true),
156 )
157 src, err := agg.Source()
158 if err != nil {
159 t.Fatal(err)
160 }
161 data, err := json.Marshal(src)
162 if err != nil {
163 t.Fatalf("marshaling to JSON failed: %v", err)
164 }
165 got := string(data)
166 expected := `{"significant_terms":{"field":"crime_type","mutual_information":{"background_is_superset":false,"include_negatives":true}}}`
167 if got != expected {
168 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
169 }
170 }
171
172 func TestSignificantTermsAggregationWithPercentageScore(t *testing.T) {
173 agg := NewSignificantTermsAggregation().Field("crime_type")
174 agg = agg.SignificanceHeuristic(
175 NewPercentageScoreSignificanceHeuristic(),
176 )
177 src, err := agg.Source()
178 if err != nil {
179 t.Fatal(err)
180 }
181 data, err := json.Marshal(src)
182 if err != nil {
183 t.Fatalf("marshaling to JSON failed: %v", err)
184 }
185 got := string(data)
186 expected := `{"significant_terms":{"field":"crime_type","percentage":{}}}`
187 if got != expected {
188 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
189 }
190 }
191
192 func TestSignificantTermsAggregationWithScript(t *testing.T) {
193 agg := NewSignificantTermsAggregation().Field("crime_type")
194 agg = agg.SignificanceHeuristic(
195 NewScriptSignificanceHeuristic().
196 Script(NewScript("_subset_freq/(_superset_freq - _subset_freq + 1)")),
197 )
198 src, err := agg.Source()
199 if err != nil {
200 t.Fatal(err)
201 }
202 data, err := json.Marshal(src)
203 if err != nil {
204 t.Fatalf("marshaling to JSON failed: %v", err)
205 }
206 got := string(data)
207 expected := `{"significant_terms":{"field":"crime_type","script_heuristic":{"script":{"inline":"_subset_freq/(_superset_freq - _subset_freq + 1)"}}}}`
208 if got != expected {
209 t.Errorf("expected\n%s\n,got:\n%s", expected, got)
210 }
211 }