public void TestFieldsWithExclusionsByProperty()
{
var fields = typeof(ElasticsearchProject).GetProperties()
.Select(x => x.Name.ToCamelCase())
.Except(new List <string> {
"followers", "contributors", "nestedFollowers", "myGeoShape"
}).ToList();
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Fields(fields.ConvertAll(x => x.ToCamelCase()).ToArray());
var json = TestElasticClient.Serialize(s);
const string expected = @"{
from: 0,
size: 10,
fields: [
""id"",
""name"",
""version"",
""country"",
""content"",
""lOC"",
""origin"",
""startedOn"",
""pingIP"",
""longValue"",
""floatValue"",
""doubleValue"",
""boolValue"",
""intValues"",
""floatValues"",
""locScriptField"",
""stupidIntIWantAsLong"",
""myAttachment"",
""myBinaryField""
]
}" ;
Assert.True(json.JsonEquals(expected));
}
public void TestSortDescending()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Fields(e => e.Id, e => e.Name)
.SortAscending(e => e.LOC.Suffix("sort"))
.SortDescending(e => e.Name.Suffix("sort"));
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
sort: {
""loc.sort"": { order: ""asc"" },
""name.sort"": { order: ""desc"" }
},
fields: [""id"", ""name""]
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void IdsQueryWithTypes()
{
var s = new SearchDescriptor <ElasticSearchProject>().From(0).Size(10)
.Query(filter => filter
.Ids(new [] { "my_type", "my_other_type" }, new[] { "1", "4", "100" })
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
query : {
ids : {
type: [""my_type"", ""my_other_type""],
values : [""1"", ""4"", ""100""]
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TestScriptScoreWithFilter()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.Query(q => q.FunctionScore(
fs => fs.Functions(
func => func.ScriptScore(
ss => ss.Script("_score / pow(param1, param2)")
.Params(
p => p.Add("param1", 1.75).Add("param2", 4)
).Lang(Lang.mvel)
).Filter(
filter => filter.Term("term1", "termValue")
)
)
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{
query: {
function_score: {
functions : [
{
script_score: {
script: ""_score / pow(param1, param2)"",
params: {
param1: 1.75,
param2: 4
},
lang: ""mvel""
},
filter:{
term : {
""term1"":""termValue""
}
}
}
]
}
}
}";
Assert.True(json.JsonEquals(expected), json);
}
public void SpanTermQuery()
{
var s = new SearchDescriptor <ElasticSearchProject>()
.From(0)
.Size(10)
.Query(q => q
.SpanTerm(f => f.Name, "elasticsearch.pm", 1.1)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10, query :
{ span_term: {
name: {
value: ""elasticsearch.pm"",
boost: 1.1
}
}}}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TermsQueryParams()
{
var s = new SearchDescriptor <ElasticSearchProject>()
.From(0)
.Size(10)
.Query(ff => ff.Terms(f => f.Name, "elasticsearch.pm", "nest")
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
query : {
terms: {
""name"": [""elasticsearch.pm"", ""nest""],
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void GeoShapeMultiLineStringFilter()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Filter(f => f
.Cache(true)
.Name("my_geo_filter")
.GeoShapeMultiLineString(p => p.Origin, d => d
.Coordinates(new[] {
new[] { new[] { 102.0, 2.0 }, new[] { 103.0, 2.0 }, new[] { 103.0, 3.0 }, new[] { 102.0, 3.0 } },
new[] { new[] { 100.0, 0.0 }, new[] { 101.0, 0.0 }, new[] { 101.0, 1.0 }, new[] { 100.0, 1.0 } },
new[] { new[] { 100.2, 0.2 }, new[] { 100.8, 0.2 }, new[] { 100.8, 0.8 }, new[] { 100.2, 0.8 } }
}
)
.Relation(GeoShapeRelation.Intersects)
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
filter : {
geo_shape: {
origin: {
shape: {
coordinates: [
[ [ 102.0, 2.0 ], [ 103.0, 2.0 ], [ 103.0, 3.0 ], [ 102.0, 3.0 ] ],
[ [ 100.0, 0.0 ], [ 101.0, 0.0 ], [ 101.0, 1.0 ], [ 100.0, 1.0 ] ],
[ [ 100.2, 0.2 ], [ 100.8, 0.2 ], [ 100.8, 0.8 ], [ 100.2, 0.8 ] ]
],
type: ""multilinestring""
},
relation: ""intersects""
},
_cache: true,
_name: ""my_geo_filter""
}
}
}" ;
Assert.IsTrue(json.JsonEquals(expected), json);
}
public void FunctionScoreQuery()
{
var s = new SearchDescriptor <ElasticsearchProject>().From(0).Size(10)
.Query(q => q
.FunctionScore(fs => fs
.Query(qq => qq.MatchAll())
.Functions(
f => f.Weight(3.0).Filter(ff => ff.Term(p => p.Name, "elasticsearch")),
f => f.Gauss(x => x.StartedOn, d => d.Scale("42w")),
f => f.Linear(x => x.FloatValue, d => d.Scale("0.3")),
f => f.Exp(x => x.DoubleValue, d => d.Scale("0.5")),
f => f.BoostFactor(2.0),
f => f.FieldValueFactor(op => op.Field(ff => ff.DoubleValue).Factor(2.5).Modifier(FieldValueFactorModifier.SquareRoot))
)
.ScoreMode(FunctionScoreMode.Sum)
.BoostMode(FunctionBoostMode.Replace)
)
).Fields(x => x.Content);
var json = TestElasticClient.Serialize(s);
var expected = @"{
from: 0, size: 10,
fields: [""content""],
query : {
function_score : {
functions: [
{weight: 3.0, filter: { term: { 'name': 'elasticsearch' }}},
{gauss: { startedOn : { scale: '42w'}}},
{linear: { floatValue : { scale: '0.3'}}},
{exp: { doubleValue: { scale: '0.5'}}},
{boost_factor: 2.0 },
{field_value_factor: { field: 'doubleValue', factor: 2.5, modifier: 'sqrt'}}
],
query : { match_all : {} },
score_mode: 'sum',
boost_mode: 'replace',
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void BoolQuery()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Query(qd => qd
.Bool(b => b
.Must(q => q.MatchAll())
.MustNot(q => q.Term(p => p.Name, "elasticsearch.pm"))
.Should(q => q.Term(p => p.Name, "elasticflume"))
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
query : {
""bool"": {
""must"": [
{
""match_all"": {}
}
],
""must_not"": [
{
""term"": {
""name"": { value: ""elasticsearch.pm"" }
}
}
],
""should"": [
{
""term"": {
""name"": { value: ""elasticflume"" }
}
}
]
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TermsFilterWithNullTerms()
{
var query = Query <ElasticsearchProject> .Filtered(filtered => filtered
.Filter(f =>
f.Terms(t => t.Name, null)
)
.Query(q => q.MatchAll())
);
var json = TestElasticClient.Serialize(query);
var expected = @"{
filtered: {
query: {
match_all: {}
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TestMoreLikeThisQuery()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Query(q => q
.MoreLikeThis(fz => fz
.OnFields(f => f.Name)
.LikeText("elasticsearcc")
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10, query :
{ mlt: {
fields : [""name"" ],
like_text : ""elasticsearcc""
}}}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void ScriptFilter()
{
var s = new SearchDescriptor <ElasticsearchProject>().From(0).Size(10)
.Filter(filter => filter
.Script(sc => sc
.Script("doc['num1'].value > 1")
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
filter : {
script : {
script : ""doc['num1'].value > 1""
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TermsFilter()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Filter(ff => ff
.Terms(f => f.Name, new [] { "elasticsearch.pm" })
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
filter : {
terms: {
""name"": [""elasticsearch.pm""]
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TestRangeKeyScriptParams()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.QueryRaw(@"{ raw : ""query""}")
.FacetRange <DateTime>("needs_a_name", t => t
.KeyScript("doc['date'].date.minuteOfHour * factor1")
.ValueScript("doc['num1'].value * factor2")
.Ranges(
r => r.To(new DateTime(1990, 1, 1).Date)
)
.Params(p => p
.Add("factor1", 2)
.Add("factor2", 3)
.Add("randomString", "stringy"))
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
facets : {
""needs_a_name"" : {
range : {
key_script : ""doc['date'].date.minuteOfHour * factor1"",
value_script : ""doc['num1'].value * factor2"",
ranges: [
{
to: ""1990-01-01T00:00:00""
}
],
params : {
factor1 : 2,
factor2 : 3,
randomString : ""stringy""
}
}
}
}, query : { raw : ""query""}
}";
Assert.True(json.JsonEquals(expected), json);
}
public void PrefixFilter()
{
var s = new SearchDescriptor <ElasticSearchProject>()
.From(0)
.Size(10)
.Filter(ff => ff
.Prefix(f => f.Name, "elast")
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
filter : {
prefix: {
""name"": ""elast""
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TestTermFacet()
{
var s = new SearchDescriptor <ElasticSearchProject>()
.From(0)
.Size(10)
.QueryRaw(@"{ raw : ""query""}")
.FacetTerm(t => t.OnField(f => f.Country).Size(20));
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
facets : {
country : {
terms : {
field : ""country"",
size : 20
}
}
}, query : { raw : ""query""}
}";
Assert.True(json.JsonEquals(expected));
}
public void PhraseSuggestDescriptorDirectGeneratorTest()
{
var phraseSuggestDescriptor = new PhraseSuggestDescriptor <ElasticsearchProject>()
.Analyzer("body")
.DirectGenerator(m => m.OnField("body").SuggestMode(SuggestMode.Always).MinWordLength(3));
var json = TestElasticClient.Serialize(phraseSuggestDescriptor);
var expected = @"{
""analyzer"": ""body"",
""direct_generator"": [
{
""field"": ""body"",
""suggest_mode"": ""always"",
""min_word_len"": 3
}
],
}";
Assert.True(json.JsonEquals(expected), json);
}
public void PhraseSuggestDescriptorTest()
{
var phraseSuggestDescriptor = new PhraseSuggestDescriptor <ElasticsearchProject>()
.Analyzer("body")
.OnField("bigram")
.Size(1)
.MaxErrors(0.5m)
.GramSize(2);
var json = TestElasticClient.Serialize(phraseSuggestDescriptor);
var expected = @"{
""field"": ""bigram"",
""analyzer"": ""body"",
""size"": 1,
""gram_size"": 2,
""max_errors"": 0.5,
}";
Assert.True(json.JsonEquals(expected), json);
}
public void TestRandomSortWithoutSeed()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.Query(q => q.FunctionScore(
fs => fs.RandomScore()
)
)
.Take(2);
var json = TestElasticClient.Serialize(s);
var expected = @"
{
size: 2,
query: {
function_score: {
random_score: {}
}
}
}";
Assert.True(json.JsonEquals(expected), json);
}
public void HistogramTestTimeInterval()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.QueryRaw(@"{ raw : ""query""}")
.FacetHistogram(h => h.OnField(f => f.StartedOn).TimeInterval("1.5h"));
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
facets : {
""startedOn"" : {
histogram : {
field : ""startedOn"",
time_interval : ""1.5h""
}
}
}, query : { raw : ""query""}
}";
Assert.True(json.JsonEquals(expected), json);
}
public void TermSuggestDescriptorTest()
{
var termSuggestDescriptor = new TermSuggestDescriptor <ElasticsearchProject>()
.MaxEdits(3)
.MaxInspections(17)
.OnField("field1")
.Size(3)
.SuggestMode(SuggestMode.Missing);
var json = TestElasticClient.Serialize(termSuggestDescriptor);
var expected = @"{
""suggest_mode"": ""missing"",
""max_edits"": 3,
""max_inspections"": 17,
""field"": ""field1"",
""size"": 3
}";
Assert.True(json.JsonEquals(expected), json);
}
public void HistogramTest()
{
var s = new SearchDescriptor <ElasticSearchProject>()
.From(0)
.Size(10)
.QueryRaw(@"{ raw : ""query""}")
.FacetHistogram(h => h.OnField(f => f.LOC).Interval(100));
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
facets : {
""loc"" : {
histogram : {
field : ""loc"",
interval : 100
}
}
}, query : { raw : ""query""}
}";
Assert.True(json.JsonEquals(expected), json);
}
public void CompletionSuggestDescriptorDefaultFuzzyTest()
{
var completionSuggestDescriptor = new CompletionSuggestDescriptor <ElasticSearchProject>()
.OnField("suggest")
.Text("n")
.Fuzzy();
var json = TestElasticClient.Serialize(completionSuggestDescriptor);
var expected = @"{
""fuzzy"": {
""edit_distance"": 1,
""transpositions"": true,
""min_length"": 3,
""prefix_length"": 1
},
""field"": ""suggest""
}";
Assert.IsTrue(json.JsonEquals(expected), json);
}
public void RegexpFilterStatic()
{
var s = new SearchDescriptor <ElasticSearchProject>()
.From(0)
.Size(10)
.Filter(Filter <ElasticSearchProject> .Regexp(r => r.OnField(p => p.Name).Value("ab?"))
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
filter : {
regexp: {
""name"": {
""value"" : ""ab?""
}
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void CompletionSuggestDescriptorDefaultFuzzyTest()
{
var completionSuggestDescriptor = new CompletionSuggestDescriptor <ElasticsearchProject>()
.OnField("suggest")
.Text("n")
.Fuzzy();
var json = TestElasticClient.Serialize(completionSuggestDescriptor);
var expected = @"{
fuzzy: {
edit_distance: 1,
transpositions: true,
min_length: 3,
prefix_length: 1
},
field: ""suggest""
}";
Assert.IsTrue(json.JsonEquals(expected), json);
}
public void TestNestedPathObject()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.Sort(sort => sort
.OnField(e => e.Id)
.NestedPath(f => f.Name)
);
var json = TestElasticClient.Serialize(s);
var expected = @"
{
""sort"": [
{
""id"": {
""nested_path"": ""name""
}
}
]
}";
Assert.True(json.JsonEquals(expected), json);
}
public void TestFuzzDateQuery()
{
var s = new SearchDescriptor <ElasticSearchProject>()
.From(0)
.Size(10)
.Query(q => q
.FuzzyDate(fz => fz
.OnField(f => f.StartedOn)
.Value(new DateTime(1999, 12, 31))
.MinSimilarity("1d")
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10, query :
{ fuzzy: { startedOn : {
min_similarity: ""1d"",
value: ""1999-12-31T00:00:00""
} }}}" ;
Assert.True(json.JsonEquals(expected), json);
}
public void TestSortScript()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.SortScript(sort => sort
.MissingLast()
.Descending()
.Mode(SortMode.Average)
.Script("doc['field_name'].value * factor")
.Params(p => p
.Add("factor", 1.1)
)
.Language("native")
.Type("number")
);
var json = TestElasticClient.Serialize(s);
var expected = @"
{
from: 0,
size: 10,
sort: [
{
_script: {
type: ""number"",
script: ""doc['field_name'].value * factor"",
params: {
factor: 1.1
},
missing: ""_last"",
order: ""desc"",
mode: ""avg"",
lang: ""native""
}
}
]
}";
Assert.True(json.JsonEquals(expected), json);
}
public void MatchQuery()
{
var s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Query(q => q
.Match(t => t
.OnField(f => f.Name)
.Query("this is a test")
.Rewrite(RewriteMultiTerm.constant_score_default)
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
query : {
match: {
name : {
query : ""this is a test"",
rewrite: ""constant_score_default""
}
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
s = new SearchDescriptor <ElasticsearchProject>()
.From(0)
.Size(10)
.Query(q => q
.Match(t => t
.OnField(f => f.Name)
.Query("this is a test")
.Rewrite(RewriteMultiTerm.constant_score_default)
)
);
json = TestElasticClient.Serialize(s);
Assert.True(json.JsonEquals(expected), json);
}
public void CustomBoostFactorQuery()
{
var s = new SearchDescriptor <ElasticSearchProject>().From(0).Size(10)
.Query(q => q
.CustomBoostFactor(cs => cs
.BoostFactor(5.2)
.Query(qq => qq.MatchAll())
)
);
var json = TestElasticClient.Serialize(s);
var expected = @"{ from: 0, size: 10,
query : {
custom_boost_factor : {
query : { match_all : {} },
boost_factor : 5.2
}
}
}" ;
Assert.True(json.JsonEquals(expected), json);
}
